import { Command, CommandOptions } from "./types/commands.js";
import { Arg, CoerceFn, Param, Type, Opts, Args, Params, ValidateFn } from "./types/units.js";
export declare function command<A extends Args, P extends Params>(o: CommandOptions<A, P>): Command<A, P>;
export declare const asType: <T extends Type<any>>(type: T) => T;
export declare function asTypes<C extends Record<string, CoerceFn<any>>>(coersions: C): { [K in keyof C]: Type<ReturnType<C[K]>>; };
export declare const type: {
    string: Type<string>;
    number: Type<number>;
    integer: Type<number>;
    boolean: Type<boolean>;
};
declare const string: Type<string>, number: Type<number>, integer: Type<number>, boolean: Type<boolean>;
export { string, number, integer, boolean };
type Ingestion<T> = {
    coerce: CoerceFn<T>;
    validate: ValidateFn<T>;
};
export declare const ingestors: {
    default: <T>({ validate, coerce }: Ingestion<T>, fallback: string) => (value: string | undefined) => T;
    required: <T>({ validate, coerce }: Ingestion<T>) => (value: string | undefined) => T;
    optional: <T>({ validate, coerce }: Ingestion<T>) => (value: string | undefined) => T | undefined;
};
export declare const param: {
    flag(flag: string, o?: {
        help?: string;
    }): Param<boolean>;
    default: <T>({ name: type, coerce }: Type<T>, fallback: string, { help, validate }?: Opts<T>) => Param<T>;
    required: <T>({ name: type, coerce }: Type<T>, { help, validate }?: Opts<T>) => Param<T>;
    optional: <T>({ name: type, coerce }: Type<T>, { help, validate }?: Opts<T>) => Param<T | undefined>;
};
export declare const arg: <N extends string>(name: N) => {
    default: <T>({ name: type, coerce }: Type<T>, fallback: string, { help, validate }?: Opts<T>) => Arg<N, T>;
    required: <T>({ name: type, coerce }: Type<T>, { help, validate }?: Opts<T>) => Arg<N, T>;
    optional: <T>({ name: type, coerce }: Type<T>, { help, validate }?: Opts<T>) => Arg<N, T | undefined>;
};
export declare function choice<T>(allowable: T[], { help }?: {
    help?: string;
}): Opts<T>;
export declare function multipleChoice<T>(allowable: T[], { zeroAllowed, help }?: {
    zeroAllowed?: boolean;
    help?: string;
}): Opts<T[]>;
export declare function list<T>({ name: type, coerce }: Type<T>, delimiter?: string): Type<T[]>;