export declare abstract class Type<TsType> {
    required: boolean;
    description: string | undefined;
    defaultValue: TsType | undefined;
    abstract name: string;
    abstract _parse: (value: any) => void;
    parse: (value: any) => TsType;
    optional: () => Type<TsType | undefined>;
    describe: (str: string) => this;
    default: (val: TsType) => this;
}
export declare class ZodNumber extends Type<number> {
    name: string;
    _parse: (value: any) => void;
}
export declare class ZodEnum<T extends string> extends Type<T> {
    options: T[];
    name: string;
    constructor(options: T[]);
    _parse: (value: any) => void;
}
export declare class ZodString extends Type<string> {
    name: string;
    _parse: (value: any) => void;
}
export declare class ZodBoolean extends Type<boolean> {
    name: string;
    _parse: (value: any) => void;
}
export declare const z: {
    number: () => ZodNumber;
    enum: <T extends string>(options: T[]) => ZodEnum<T>;
    string: () => ZodString;
    boolean: () => ZodBoolean;
};
export type Schema = Record<string, Type<any>>;
export type ExtractType<T> = T extends Type<infer U> ? U : never;
export type ParsedSchema<T extends Schema> = {
    [K in keyof T]: ExtractType<T[K]>;
};
export type ParsingError = {
    message: string;
    path: string[];
};
export declare const parse: <T extends Schema>(value: any, schema: T) => {
    success: true;
    data: ParsedSchema<T>;
} | {
    success: false;
    errors: ParsingError[];
};
export declare const parseArgs: <T extends Schema>(schema: T) => ParsedSchema<T>;