type ParserZodEsque<TInput, TParsedInput> = {
    _input: TInput;
    _output: TParsedInput;
};
type ParserValibotEsque<TInput, TParsedInput> = {
    types?: {
        input: TInput;
        output: TParsedInput;
    };
};
type ParserMyZodEsque<TInput> = {
    parse: (input: any) => TInput;
};
type ParserSuperstructEsque<TInput> = {
    create: (input: unknown) => TInput;
};
type ParserCustomValidatorEsque<TInput> = (input: unknown) => Promise<TInput> | TInput;
type ParserYupEsque<TInput> = {
    validateSync: (input: unknown) => TInput;
};
type ParserScaleEsque<TInput> = {
    assert(value: unknown): asserts value is TInput;
};
type ParserWithoutInput<TInput> = ParserCustomValidatorEsque<TInput> | ParserMyZodEsque<TInput> | ParserScaleEsque<TInput> | ParserSuperstructEsque<TInput> | ParserYupEsque<TInput>;
type ParserWithInputOutput<TInput, TParsedInput> = ParserZodEsque<TInput, TParsedInput> | ParserValibotEsque<TInput, TParsedInput>;
type Parser = ParserWithInputOutput<any, any> | ParserWithoutInput<any>;
type InferParser<TParser> = TParser extends ParserWithInputOutput<infer $TIn, infer $TOut> ? {
    in: $TIn;
    out: $TOut;
} : TParser extends ParserWithoutInput<infer $InOut> ? {
    in: $InOut;
    out: $InOut;
} : never;
type Infer<T> = InferParser<T>["out"];
type InferIn<T> = InferParser<T>["in"];

type ParseFn<TType> = (value: unknown) => Promise<TType> | TType;
declare function getParseFn<TType>(procedureParser: Parser): ParseFn<TType>;

declare const parse: <T extends Parser>(parser: T, value: unknown) => Infer<T>;

export { type Infer, type InferIn, type ParseFn, type Parser, getParseFn, parse };