import { Argument, Description, Group } from "./types";
export interface OppaOptions {
    name: string;
    version: string;
    usage: string;
    description: Description;
    noHelp: boolean;
    noHelpAlias: boolean;
    noVersionAlias: boolean;
    allowUnknown: boolean;
    throwOnError: boolean;
    noExit: boolean;
}
export declare type OppaSingleString = {
    type: 'string';
    multi?: false;
};
export declare type OppaSingleBoolean = {
    type: 'boolean';
    multi?: false;
};
export declare type OppaSingleNumber = {
    type: 'number';
    multi?: false;
};
export declare type OppaMultiString = {
    type: 'string';
    multi: true;
};
export declare type OppaMultiBoolean = {
    type: 'boolean';
    multi: true;
};
export declare type OppaMultiNumber = {
    type: 'number';
    multi: true;
};
export declare type Unknown = Array<{
    name: string;
    value: string;
}>;
export interface Result<Arguments> {
    /**
     * Parsed arguments
     */
    args: Arguments;
    /**
     * Unknown arguments
     */
    unknown: Unknown;
    /**
     * "Commands" after the last argument (but before '--')
     */
    rest: Array<string>;
    /**
     * '--' *and* the arguments after '--'
     */
    dashdash: Array<string>;
}
export declare type Oppifyer<Name extends string, Type> = {
    [P in Name]: Type;
};
export declare class Oppa<U> {
    private readonly opts;
    private readonly arguments;
    private byLongs;
    private byShorts;
    constructor(opts: OppaOptions);
    group(group: Group): Oppa<U>;
    add<T extends string>(argument: Argument<T> & OppaSingleString): Oppa<U & Oppifyer<T, string>>;
    add<T extends string>(argument: Argument<T> & OppaSingleBoolean): Oppa<U & Oppifyer<T, boolean>>;
    add<T extends string>(argument: Argument<T> & OppaSingleNumber): Oppa<U & Oppifyer<T, number>>;
    add<T extends string>(argument: Argument<T> & OppaMultiString): Oppa<U & Oppifyer<T, Array<string>>>;
    add<T extends string>(argument: Argument<T> & OppaMultiBoolean): Oppa<U & Oppifyer<T, Array<boolean>>>;
    add<T extends string>(argument: Argument<T> & OppaMultiNumber): Oppa<U & Oppifyer<T, Array<number>>>;
    private _parse;
    parse(args?: ReadonlyArray<string>): Result<U>;
    showVersion<Exit extends boolean>(exit?: Exit): Exit extends true ? never : void;
    showHelp<Exit extends boolean>(exit?: Exit): Exit extends true ? never : void;
}
export declare function oppa(opts?: Partial<OppaOptions>): Oppa<{}>;
export declare type TypeOf<T> = T extends Oppa<infer U> ? Result<U> : never;