import { Argument } from './argument.js';
import { Declaration } from './declaration.js';
import { Param } from './param.js';
export type ArgumentMapping = {
    path: string;
    static?: string;
    key?: string;
} | {
    static: string;
    path?: string;
    key?: string;
};
export interface ArgumentMap<V> {
    indices: Declaration[];
    keys: {
        [key: string]: number;
    };
    values: V[];
    implicit: {
        [key: string]: Argument;
    };
}
export type Indices = {
    key?: string;
    value?: any;
    type?: any;
    defaults?: any;
};
export declare class FunctionArguments {
    indices: Declaration[];
    keys: Map<string, number>;
    values: any[];
    implicit: Map<string, Argument>;
    constructor(indices: Indices[]);
    get length(): number;
    getIndices(): Indices[];
    set(key: string, value: any): this;
    setDeclaredValue(key: string | number, value: any): this;
    setImplicitValue(name: string, value: any): this;
    hasImplicitArgumentNamed(name: string): boolean;
    getImplicitArguments(): {
        [key: string]: Argument;
    };
    hasDeclarationNamed(key: string): boolean;
    hasDeclaredValueNamed(key: string): boolean;
    getDeclaration(key: string): string;
    getDeclaredValueNamed(key: string): string;
    hasImplicitValueNamed(key: string): boolean;
    getImplicitValueNamed(key: string): any;
    hasDeclaredValueAtIndex(index: number): boolean;
    getDeclaredValueAtIndex(index: number): any;
    getDeclaredNameAtIndex(index: number): any;
    getIndexOfDeclarationName(key: string): number;
    get(key: string, defaultor?: (key: string) => any): any;
    getArguments(): any[];
    toObject(defaultValues: any): void;
    readDeclaredArgumentValues(): Generator<{
        value: any;
        key?: string;
        type?: string;
    }, void, unknown>;
    readDefinedArgumentValues(): Generator<{
        key: string;
        value: any;
        type?: any;
    }>;
    readImplicitArgumentValues(): Generator<{
        key: string;
        value: Argument;
    }, void, unknown>;
    readDeclarations(): Generator<{
        defaults?: string;
        key?: string;
        type?: string;
        index: number;
    }, void, unknown>;
    getDefinedKeys(): Declaration[];
    getUndefinedKeys(): string[];
    copyDeclarations(): Declaration[];
    toParams(): Param[];
    toJSON(): ArgumentMap<string>;
    declaredArgumentCount(): number;
    shuntKnownValues(): {
        urlQueryString: string;
        remaining: FunctionArguments;
        shunted: {
            [key: number]: Indices;
        };
    };
    toUrlParams(override?: boolean): string;
    static fromJSON(json: Param.JSON[] | {
        [key: string]: any;
    }): any;
    /**
     * Accept a set of declarations with potential values and then function arguments
     * which should map to them.
     *
     * The first input contains the set of indices we want to map the secondary arguments onto.
     *
     * If keys are found within these objects, which aren't required for resolution
     * of the declarations we still store them in the function arguments under the
     * keyword 'implicit arguments', only preserving the first observed value under
     * each new key.
     *
     * This method effectively asks as an object mapper along with a resolution
     * hierarchy.
     */
    static resolve(indices: Indices[], ...resolveOrderAll: (FunctionArguments.JSON | FunctionArguments)[]): FunctionArguments;
    static merge(indices: Indices[], args: FunctionArguments): FunctionArguments;
    [Symbol.iterator](): Generator<{
        key: string;
        value: any;
        type?: any;
    }, any, any>;
    static create(indices: Indices[]): FunctionArguments;
    static Builder: {
        new (): {
            indeterminedArg: any;
            params: Param[];
            setArgument(value: any): /*elided*/ any;
            setArgumentValue(value: any): /*elided*/ any;
            build(): FunctionArguments;
        };
    };
}
export declare namespace FunctionArguments {
    namespace JSON {
        type Array = Param.JSON[];
        type Object = {
            [key: string]: string;
        };
    }
    type JSON = JSON.Array | JSON.Object;
}
export { Argument, Param, Declaration };
export { FunctionArguments as Arguments };
//# sourceMappingURL=index.d.ts.map