export declare const r2gSmokeTest: () => boolean;
type TypeMapping<T> = {
    Boolean: boolean;
    String: string;
    Number: number;
    Integer: number;
    ArrayOfString: Array<string>;
    ArrayOfBoolean: Array<boolean>;
    ArrayOfNumber: Array<number>;
    ArrayOfInteger: Array<number>;
    JSON: T;
    SeparatedStrings: Array<string>;
    SeparatedNumbers: Array<number>;
    SeparatedIntegers: Array<number>;
    SeparatedBooleans: Array<boolean>;
};
export declare enum Foo {
    JSONType = 0
}
export declare enum Type {
    Boolean = "Boolean",
    String = "String",
    Number = "Number",
    Integer = "Integer",
    ArrayOfString = "ArrayOfString",
    ArrayOfBoolean = "ArrayOfBoolean",
    ArrayOfNumber = "ArrayOfNumber",
    ArrayOfInteger = "ArrayOfInteger",
    JSON = "JSON",
    SeparatedStrings = "SeparatedStrings",
    SeparatedNumbers = "SeparatedNumbers",
    SeparatedIntegers = "SeparatedIntegers",
    SeparatedBooleans = "SeparatedBooleans"
}
declare const defaultMod: unique symbol;
export interface ElemType<T> {
    name: string;
    alt?: string | Array<string>;
    short?: string;
    type: keyof TypeMapping<T>;
    default?: any;
    separator?: string;
    env?: string;
    help?: string;
    description?: string;
    [defaultMod]?: any;
}
export declare const asOptions: <Z, K extends string | number | symbol, T extends {
    name: K;
    type: keyof TypeMapping<Z>;
}[]>(t: T) => T;
export type OptionsToType<T extends Array<ElemType<any>>> = {
    [K in T[number]['name']]: TypeMapping<any>[Extract<T[number], {
        name: K;
    }>['type']];
};
export interface ParsedValue<Z> extends ElemType<Z> {
    cleanName: string;
}
export interface Parsed {
    [key: string]: ParsedValue<any>;
}
export interface CliParserHelpOpts {
    includeEnv: boolean;
}
export interface CliParserOptions {
    commandName: string;
    commandExample: string;
    commandExamples: Array<string>;
    allowUnknown: boolean;
    useJSONEnv: boolean;
}
export type ParsedType = Date | string | number | boolean | Array<string> | Array<number> | Array<boolean> | Array<Date>;
export interface CliParserGroup {
    [key: string]: ParsedType;
}
export interface CliParserOrder {
    name: string;
    value: ParsedType;
    from: 'env' | 'argv';
}
export declare class CliParser<T extends Array<ElemType<any>>> {
    private readonly options;
    private readonly opts;
    private readonly parserOpts;
    static separators: Type[];
    static arrays: Type[];
    allowUnknown: boolean;
    useJSONEnv: boolean;
    env: {
        [key: string]: string;
    };
    constructor(o: T, opts?: Partial<CliParserOptions>);
    getHelpString(v?: CliParserHelpOpts): string;
    parse(argv: Array<string>): {
        opts: OptionsToType<T>;
        values: string[];
        groups: CliParserGroup[];
        order: CliParserOrder[];
    };
}
export declare const Parser: typeof CliParser;
export {};