@oclif/parser

newArg: {
    <T>(arg: IArg<T> & { Parse: ParseFn<T> }): Arg<T>;
    (arg: IArg<string>): Arg<string>;
};

type Arg<T> = RequiredArg<T> | OptionalArg<T>;

type Input = IArg<any>[];

type OptionalArg<T> = ArgBase<T> & {
    required: false;
    value?: T;
};

type ParseFn<T> = (input: string) => T;

type RequiredArg<T> = ArgBase<T> & {
    required: true;
    value: T;
};

const defaultFlags: { color: IBooleanFlag<boolean> };

const integer: Definition<number>;

const string: Definition<string>;

boolean: <T = boolean>(options?: Partial<IBooleanFlag<T>>) => IBooleanFlag<T>;

build: {
    <T>(
        defaults: { parse: IOptionFlag<T>['parse'] } & Partial<IOptionFlag<T>>
    ): Definition<T>;
    (defaults: Partial<IOptionFlag<string>>): Definition<string>;
};

option: <T>(
    options: { parse: IOptionFlag<T>['parse'] } & Partial<IOptionFlag<T>>
) => IOptionFlag<T | undefined>;

type Default<T> = T | ((context: DefaultContext<T>) => T);

type DefaultContext<T> = {
    options: IOptionFlag<T>;
    flags: {
        [k: string]: string;
    };
};

type Definition<T> = {
    (
        options: {
            multiple: true;
        } & Partial<IOptionFlag<T[]>>
    ): IOptionFlag<T[]>;
    (
        options: (
            | {
                  required: true;
              }
            | {
                  default: Default<T>;
              }
        ) &
            Partial<IOptionFlag<T>>
    ): IOptionFlag<T>;
    (options?: Partial<IOptionFlag<T>>): IOptionFlag<T | undefined>;
};

type EnumFlagOptions<T> = Partial<IOptionFlag<T>> & {
    options: T[];
};

type IBooleanFlag<T> = IFlagBase<T, boolean> & {
    type: 'boolean';
    allowNo: boolean;
    /**
     * specifying a default of false is the same not specifying a default
     */
    default?: Default<boolean>;
};

type IFlag<T> = IBooleanFlag<T> | IOptionFlag<T>;

type IFlagBase<T, I> = {
    name: string;
    char?: AlphabetLowercase | AlphabetUppercase;
    description?: string;
    helpLabel?: string;
    hidden?: boolean;
    required?: boolean;
    dependsOn?: string[];
    exclusive?: string[];
    exactlyOne?: string[];
    /**
     * also accept an environment variable as input
     */
    env?: string;
    parse(input: I, context: any): T;
};

type Input<T extends Output> = {
    [P in keyof T]: IFlag<T[P]>;
};

type IOptionFlag<T> = IFlagBase<T, string> & {
    type: 'option';
    helpValue?: string;
    default?: Default<T | undefined>;
    multiple: boolean;
    input: string[];
    options?: string[];
};

type Output = {
    [name: string]: any;
};