import { S as Strip, A as AnyCtx, a as AnyMeta, b as Awaitable } from './util-CHs1TI3T.js';
import { Parser, Infer, InferIn } from 'schema-shift';
import { Typify, TypeKey, TypeOf } from './util.js';
import { Midwinter, AnyCtx as AnyCtx$1, AnyMeta as AnyMeta$1 } from 'midwinter';
import { d as EndMiddleware } from './types-xEg9liKj.js';

type ValidSchemaOpts = {
    Query?: Parser;
    Params?: Parser;
    Body?: Parser;
    Headers?: Parser;
    Output?: Parser;
};
type ValidSchemaCtx<T extends ValidSchemaOpts> = {
    params: unknown extends T["Params"] ? Default["Params"] : Infer<T["Params"]>;
    query: unknown extends T["Query"] ? Default["Query"] : Infer<T["Query"]>;
    body: unknown extends T["Body"] ? Default["Body"] : Infer<T["Body"]>;
    headers: unknown extends T["Headers"] ? Default["Headers"] : Infer<T["Headers"]>;
};
type ValidLazySchemaCtx<T extends ValidSchemaOpts> = {
    parse: ParseInputsFn<ValidSchemaCtx<T>>;
};
type ValidSchemaMeta<T extends ValidSchemaOpts> = T & Typify<Strip<{
    [Key in keyof T & string as `${Key}_Out`]: Infer<T[Key]>;
} & {
    [Key in keyof T & string as `${Key}_In`]: InferIn<T[Key]>;
}, [
    never,
    never
]>>;
type ValidTypeOpts = {
    Query?: Record<string, any>;
    Params?: Record<string, any>;
    Headers?: Record<string, any>;
    Body?: unknown;
    Output?: unknown;
};
type ValidTypeCtx<T extends ValidTypeOpts> = {
    params: unknown extends T["Params"] ? Default["Params"] : T["Params"];
    query: unknown extends T["Query"] ? Default["Query"] : T["Query"];
    body: unknown extends T["Body"] ? Default["Body"] : T["Body"];
    headers: unknown extends T["Headers"] ? Default["Headers"] : T["Headers"];
};
type ValidLazyTypeCtx<T extends ValidTypeOpts> = {
    parse: ParseInputsFn<ValidTypeCtx<T>>;
};
type ValidTypeMeta<T extends ValidTypeOpts> = Typify<Strip<{
    [Key in keyof T & string as `${Key}_Out`]: T[Key];
} & {
    [Key in keyof T & string as `${Key}_In`]: T[Key];
}, never>>;
type Default = {
    Params: Record<string, string | undefined>;
    Query: Record<string, string | undefined>;
    Body: unknown;
    Headers: Record<string, string | undefined>;
};
type OutputHandler<TValue extends any = unknown, TCtx extends AnyCtx = AnyCtx, TMetaIn extends AnyMeta = AnyMeta> = (request: Request, ctx: TCtx, meta: Readonly<TMetaIn>) => Awaitable<TValue | Response>;
type InputTypeKey = "params" | "query" | "body" | "headers";
interface ParseInputsFn<T extends Record<InputTypeKey, any>> {
    /** Parses the selected input part */
    <TKey extends InputTypeKey>(key: TKey): Promise<T[TKey]>;
    /** Parses all inputs and returns as an object */
    (): Promise<T>;
}
type InferMetaOutputIn<TMeta extends AnyMeta> = TMeta[TypeKey<"Output_In">] extends TypeOf<infer Inner> ? Inner : any;
type ParseQueryStringFn = (url: URL) => Record<PropertyKey, unknown>;

type ParseOpts = ValidSchemaOpts & {
    path?: string;
    parseQueryString?: ParseQueryStringFn;
};
type ParserFn<T = any> = (req: Request, opts: ParseOpts) => T;
declare const parseQuery: (req: Request, opts: ParseOpts) => any;
declare const parseParams: (req: Request, opts: ParseOpts) => any;
declare const parseBody: (_req: Request, opts: ParseOpts) => Promise<any>;
declare const parseHeaders: (req: Request, opts: ParseOpts) => any;
declare const getCachedParsers: (req: Request, opts: ParseOpts) => {
    query: () => Promise<any>;
    params: () => Promise<any>;
    headers: () => Promise<any>;
    body: () => Promise<Promise<any>>;
};
declare const makeParseFn: <T extends ParseOpts>(req: Request, opts: T) => ParseInputsFn<ValidSchemaCtx<T>>;

interface ValidationOpts {
    parseQueryString?: ParseQueryStringFn;
}
interface ValidationPlugin {
    /**
     * Add synchronous parsing and validation, resulting in the
     * query, params, body and headers being added to the ctx.
     */
    valid<T extends ValidTypeOpts = {}>(): Midwinter<ValidTypeCtx<T>, ValidTypeMeta<T>>;
    valid<T extends ValidSchemaOpts = {}>(opts: T): Midwinter<ValidSchemaCtx<T>, ValidSchemaMeta<T>>;
    validLazy<T extends ValidTypeOpts = {}>(): Midwinter<ValidLazyTypeCtx<T>, ValidTypeMeta<T>>;
    /** Add lazy validation that can be triggered via the `ctx.parse()` function */
    validLazy<T extends ValidSchemaOpts = {}>(opts: T): Midwinter<ValidLazySchemaCtx<T>, ValidSchemaMeta<T>>;
    /**
     * Parses the response type according to the valid.Output field and packages
     * within a Response object.
     *
     * If no `Output` schema was provided, the result JSON.stringified without any validation.
     */
    output<TCtx extends AnyCtx$1 = AnyCtx$1, TMeta extends AnyMeta$1 = AnyMeta$1, TValue extends InferMetaOutputIn<TMeta> = InferMetaOutputIn<TMeta>>(handler: OutputHandler<TValue, TCtx, TMeta>, opts?: ResponseInit): EndMiddleware<TCtx, [
        InferMetaOutputIn<TMeta>
    ] extends [never] ? {} : ValidTypeMeta<{
        Output: TValue;
    }>, TMeta>;
}
declare const init: (opts?: ValidationOpts) => ValidationPlugin;

export { type Default, type InferMetaOutputIn, type InputTypeKey, type OutputHandler, type ParseInputsFn, type ParseOpts, type ParseQueryStringFn, type ParserFn, type ValidLazySchemaCtx, type ValidLazyTypeCtx, type ValidSchemaCtx, type ValidSchemaMeta, type ValidSchemaOpts, type ValidTypeCtx, type ValidTypeMeta, type ValidTypeOpts, type ValidationOpts, type ValidationPlugin, getCachedParsers, init, makeParseFn, parseBody, parseHeaders, parseParams, parseQuery };