import { GenericConstructor, GenericObject } from "../interfaces";

declare namespace dojoLang {
    /* dojo/_base/lang */

    interface ReplaceCallback {
        (match: string, name: string, offset: number, tmpl: string): string;
    }

    interface Lang {
        /**
         * Lists property names that must be explicitly processed during for-in iteration
         * in environments that have has("bug-for-in-skips-shadowed") true.
         */
        _extraNames: string[];

        /**
         * Copies/adds all properties of one or more sources to dest; returns dest.
         */
        _mixin<T, U>(dest: T, source: U, copyFunc?: (s: any) => any): T & U;

        /**
         * Copies/adds all properties of one or more sources to dest; returns dest.
         */
        mixin<T, U>(dest: T, sources: U): T & U;
        mixin<T, U, V>(dest: T, source1: U, source2: V): T & U & V;
        mixin<T, U, V, W>(dest: T, source1: U, source2: V, source3: W): T & U & V & W;
        mixin<T, U, V, W, X>(dest: T, source1: U, source2: V, source3: W, source4: X): T & U & V & W & X;
        mixin<T, U, V, W, X, Y>(dest: T, source1: U, source2: V, source3: W, source4: X, source5: Y): T & U & V & W & X & Y;
        mixin<T, U, V, W, X, Y, Z>(dest: T, source1: U, source2: V, source3: W, source4: X, source5: Y, source6: Z): T & U & V & W & X & Y & Z;
        mixin<T, U>(dest: T, ...sources: U[]): T & U;

        /**
         * Set a property from a dot-separated string, such as "A.B.C"
         */
        setObject(name: string, value: any, context?: any): any;

        /**
         * Get a property from a dot-separated string, such as "A.B.C"
         */
        getObject<T>(name: string, create?: boolean, context?: any): T;

        /**
         * determine if an object supports a given method
         */
        exists(name: string, obj?: any): boolean;

        /**
         * Return true if it is a String
         */
        isString(it: any): it is string;

        /**
         * Return true if it is an Array.
         */
        isArray(it: any): it is any[];

        /**
         * Return true if it is a Function
         */
        isFunction(it: any): it is Function;

        /**
         * Returns true if it is a JavaScript object (or an Array, a Function
         * or null)
         */
        isObject(it: any): it is { [id: string]: any; };

        /**
         * similar to isArray() but more permissive
         */
        isArrayLike(it: any): boolean;

        /**
         * Returns true if it is a built-in function or some other kind of
         * oddball that *should* report as a function but doesn't
         */
        isAlien(it: any): boolean;

        /**
         * Adds all properties and methods of props to constructor's
         * prototype, making them available to all instances created with
         * constructor.
         */
        extend<T, U>(ctor: GenericConstructor<T>, props: U): GenericConstructor<T & U>;

        _hitchArgs<T extends Function>(scope: any, method: T): T;

        /**
         * Returns a function that will only ever execute in the given scope.
         * This allows for easy use of object member functions
         * in callbacks and other places in which the "this" keyword may
         * otherwise not reference the expected scope.
         * Any number of default positional arguments may be passed as parameters
         * beyond "method".
         * Each of these values will be used to "placehold" (similar to curry)
         * for the hitched function.
         */
        hitch(method: string): Function;
        hitch<T extends Function>(method: T): T;
        hitch<T extends Function>(scope: any, method: T): T;
        hitch<T extends Function>(scope: any, method: string | Function, ...args: any[]): T;

        /**
         * Returns a new object which "looks" to obj for properties which it
         * does not have a value for. Optionally takes a bag of properties to
         * seed the returned object with initially.
         */
        delegate<T, U>(obj: T, props?: U): T & U;

        /**
         * Converts an array-like object (i.e. arguments, DOMCollection) to an
         * array. Returns a new Array with the elements of obj.
         */
        _toArray(obj: any, offset?: number, startWith?: any[]): any[];

        /**
         * similar to hitch() except that the scope object is left to be
         * whatever the execution context eventually becomes.
         */
        partial<U extends Function>(method: Function | string, ...args: any[]): U;

        /**
         * Clones objects (including DOM nodes) and all children.
         * Warning: do not clone cyclic structures.
         */
        clone<T>(src: T): T;

        /**
         * Trims whitespace from both sides of the string
         */
        trim(str: string): string;

        /**
         * Performs parameterized substitutions on a string. Throws an
         * exception if any parameter is unmatched.
         */
        replace(tmpl: string, map: GenericObject | ReplaceCallback, pattern?: RegExp): string;
    }
}

declare const dojoLang: dojoLang.Lang;
export = dojoLang;