import { C as MiddlewareInput, F as RouteMeta, I as RouteOptions, N as Route, P as RouteMatch, R as RouteSchema, S as MiddlewareEntry, a as MiddlewareResponseDeclaration, f as ContextFromMiddlewareInput, g as HandlerResult, h as HandlerContext, l as AddedContextFromMiddlewareInput, n as DeclaredMiddleware, r as DefineMiddlewareOptions, t as Router, u as AnyContext } from "./router-Cwb7ak0J.mjs";
import { n as RoutekitResponse } from "./core-CzUCxvGk.mjs";
import { a as ValibotRouteHandler, c as ValibotSchemaMiddlewareOptions, d as ValibotValidationErrorHandler, f as createValibotRouteBuilder, i as ValibotRouteBuilder, l as ValibotValidationError, m as valibotSchemaMiddleware, n as ValibotHandlerContext, o as ValibotRouteHelperDefaults, p as defineValibotMiddleware, r as ValibotHandlerParams, s as ValibotRouteSchemaInput, t as DefineValibotMiddlewareOptions, u as ValibotValidationErrorBody } from "./valibot-2MepBTEi.mjs";
import { z } from "zod";

//#region src/router/routes/zod/zod.d.ts
/**
 * Validation error component identifiers for Zod-backed routes.
 */
declare const enum ValidationError {
  REQUEST_BODY = 0,
  URL_PATH = 1,
  QUERY_PARAMETERS = 2
}
type ErrorTree = ReturnType<typeof z.treeifyError>;
type ZodSchema = z.ZodTypeAny | undefined;
type AnyZodResponseBodySchemas = Partial<Record<number | 'default', z.ZodTypeAny>>;
type ZodResponseBodySchemas = AnyZodResponseBodySchemas | undefined;
type ResponseValidationMode = false | 'strict' | 'parse';
type ResponseValidationOption = boolean | ResponseValidationMode;
type ZodRouteContext<Ctx extends object, BuilderMiddleware, RouteMiddleware> = Ctx & AddedContextFromMiddlewareInput<BuilderMiddleware> & AddedContextFromMiddlewareInput<RouteMiddleware>;
type ZodBuilderMiddlewareInput<Ctx extends object, BuilderMiddleware extends MiddlewareInput<Ctx>, RouteMiddleware extends MiddlewareInput<Ctx>> = [BuilderMiddleware] extends [undefined] ? RouteMiddleware : [RouteMiddleware] extends [undefined] ? BuilderMiddleware : MiddlewareInput<Ctx>;
/**
 * Default validation error payload returned by Zod-backed routes.
 */
type ZodValidationErrorBody = {
  component: 'request_body' | 'url_path' | 'query_parameters';
  errorTree: ErrorTree;
  message: string;
};
/**
 * Zod schema input that mirrors the core route `schema` shape.
 */
type ZodRouteSchemaInput<BodySchema extends ZodSchema = undefined, PathSchema extends ZodSchema = undefined, QuerySchema extends ZodSchema = undefined, ResponseBodySchemas extends ZodResponseBodySchemas = undefined> = {
  request?: {
    query?: QuerySchema;
    path?: PathSchema;
    body?: BodySchema;
  };
  response?: {
    body?: ResponseBodySchemas;
  };
};
type InferSchema<Schema extends ZodSchema> = Schema extends z.ZodTypeAny ? z.infer<Schema> : unknown;
type InferResponseBodySchemaInputUnion<ResponseBodySchemas extends AnyZodResponseBodySchemas> = [keyof ResponseBodySchemas] extends [never] ? unknown : { [Status in keyof ResponseBodySchemas]: NonNullable<ResponseBodySchemas[Status]> extends z.ZodTypeAny ? z.input<NonNullable<ResponseBodySchemas[Status]>> : never }[keyof ResponseBodySchemas];
type InferResponseBodySchemaOutputUnion<ResponseBodySchemas extends AnyZodResponseBodySchemas> = [keyof ResponseBodySchemas] extends [never] ? unknown : { [Status in keyof ResponseBodySchemas]: NonNullable<ResponseBodySchemas[Status]> extends z.ZodTypeAny ? z.output<NonNullable<ResponseBodySchemas[Status]>> : never }[keyof ResponseBodySchemas];
type InferResponseBodyInput<ResponseBodySchemas extends ZodResponseBodySchemas> = ResponseBodySchemas extends AnyZodResponseBodySchemas ? 200 extends keyof ResponseBodySchemas ? InferResponseBodySchemaInputUnion<ResponseBodySchemas> : 'default' extends keyof ResponseBodySchemas ? InferResponseBodySchemaInputUnion<ResponseBodySchemas> : unknown : unknown;
type InferResponseBodyOutput<ResponseBodySchemas extends ZodResponseBodySchemas> = ResponseBodySchemas extends AnyZodResponseBodySchemas ? 200 extends keyof ResponseBodySchemas ? InferResponseBodySchemaOutputUnion<ResponseBodySchemas> : 'default' extends keyof ResponseBodySchemas ? InferResponseBodySchemaOutputUnion<ResponseBodySchemas> : unknown : unknown;
type InferResponseBodyAccepted<ResponseBodySchemas extends ZodResponseBodySchemas> = InferResponseBodyInput<ResponseBodySchemas> | InferResponseBodyOutput<ResponseBodySchemas>;
type NormalizeSchema<Schema> = Schema extends ZodRouteSchemaInput<any, any, any, any> ? Schema : ZodRouteSchemaInput<undefined, undefined, undefined, undefined>;
type ExtractBodySchema<Schema extends ZodRouteSchemaInput<any, any, any, any> | undefined> = NormalizeSchema<Schema> extends ZodRouteSchemaInput<infer BodySchema, any, any, any> ? BodySchema : undefined;
type ExtractPathSchema<Schema extends ZodRouteSchemaInput<any, any, any, any> | undefined> = NormalizeSchema<Schema> extends ZodRouteSchemaInput<any, infer PathSchema, any, any> ? PathSchema : undefined;
type ExtractQuerySchema<Schema extends ZodRouteSchemaInput<any, any, any, any> | undefined> = NormalizeSchema<Schema> extends ZodRouteSchemaInput<any, any, infer QuerySchema, any> ? QuerySchema : undefined;
type ExtractResponseBodySchemas<Schema extends ZodRouteSchemaInput<any, any, any, any> | undefined> = NormalizeSchema<Schema> extends ZodRouteSchemaInput<any, any, any, infer ResponseBodySchemas> ? ResponseBodySchemas : undefined;
type ZodMiddlewareDeclarations<Schemas extends AnyZodResponseBodySchemas> = { [Status in keyof Schemas]: NonNullable<Schemas[Status]> extends z.ZodTypeAny ? MiddlewareResponseDeclaration<z.infer<NonNullable<Schemas[Status]>>> : never };
type ZodDeclaredResponse<Schemas extends AnyZodResponseBodySchemas> = { [Status in keyof Schemas]-?: NonNullable<Schemas[Status]> extends z.ZodTypeAny ? RoutekitResponse<z.infer<NonNullable<Schemas[Status]>>, Status extends number ? Status : number> : never }[keyof Schemas];
type ZodSchemaMiddlewareContext<Schema extends ZodRouteSchemaInput<any, any, any, any> | undefined> = {
  params: ZodHandlerParams<ExtractBodySchema<Schema>, ExtractPathSchema<Schema>, ExtractQuerySchema<Schema>>;
};
/**
 * Validated request inputs exposed to a Zod-backed handler.
 */
type ZodHandlerParams<BodySchema extends ZodSchema, PathSchema extends ZodSchema, QuerySchema extends ZodSchema> = {
  path: InferSchema<PathSchema>;
  query: InferSchema<QuerySchema>;
  body: InferSchema<BodySchema>;
};
/**
 * Context object exposed to a Zod-backed handler.
 */
type ZodHandlerContext<BodySchema extends ZodSchema, PathSchema extends ZodSchema, QuerySchema extends ZodSchema, Ctx extends object> = Omit<HandlerContext<Ctx>, 'path'> & {
  params: ZodHandlerParams<BodySchema, PathSchema, QuerySchema>;
};
/**
 * Validation error handler used when request parsing fails.
 *
 * @param component - Request component that failed validation.
 * @param error - The Zod validation error.
 * @returns A handler result that should be returned to the client.
 */
type ValidationErrorHandler<Responses extends AnyZodResponseBodySchemas = AnyZodResponseBodySchemas> = (component: ValidationError, error: z.ZodError) => ZodDeclaredResponse<Responses>;
/**
 * Shared defaults that can be applied to Zod handler helpers.
 */
type ZodHandlerDefaults = {
  /**
   * Route schema fragments that should be merged into every factory-built route.
   * Route-level schemas override matching request fields and response status codes.
   */
  schema?: ZodRouteSchemaInput<any, any, any, any>;
  /**
   * Whether and how to apply `schema.response.body` to handler responses.
   * `false` disables response validation, `true` and `'strict'` validate without changing the
   * response body, and `'parse'` returns the parsed response body. Defaults to `'parse'`.
   */
  validateResponse?: ResponseValidationOption;
} & ({
  onRequestValidationError?: undefined;
  validationResponses?: undefined;
} | {
  /**
   * Override the default request validation error response.
   */
  onRequestValidationError: ValidationErrorHandler;
  /**
   * Response schemas returned by `onRequestValidationError`.
   */
  validationResponses: AnyZodResponseBodySchemas;
});
/**
 * Shared defaults that can be applied to Zod route helpers.
 */
type ZodRouteHelperDefaults<BuilderCtx extends object = AnyContext, BuilderMiddleware extends MiddlewareInput<BuilderCtx> = undefined> = ZodHandlerDefaults & {
  /**
   * Middleware applied to every route built by the helper.
   */
  middleware?: BuilderMiddleware;
};
/**
 * Handler signature used by Zod schema boundaries and route builders.
 */
type ZodRouteHandler<BodySchema extends ZodSchema, PathSchema extends ZodSchema, QuerySchema extends ZodSchema, ResponseBodySchemas extends ZodResponseBodySchemas, Ctx extends object = AnyContext> = (this: Router<any>, ctx: ZodHandlerContext<BodySchema, PathSchema, QuerySchema, Ctx>) => HandlerResult<InferResponseBodyAccepted<ResponseBodySchemas>>;
/**
 * Shared options used by Zod route builders.
 */
type ZodHandlerOptions<Schema extends ZodRouteSchemaInput<any, any, any, any> | undefined, Ctx extends object = AnyContext> = ZodHandlerDefaults & {
  schema?: Schema;
  handler: ZodRouteHandler<ExtractBodySchema<Schema>, ExtractPathSchema<Schema>, ExtractQuerySchema<Schema>, ExtractResponseBodySchemas<Schema>, Ctx>;
};
/**
 * Full route options used by Zod route builders.
 */
type ZodRouteOptions<Schema extends ZodRouteSchemaInput<any, any, any, any> | undefined, Ctx extends object = AnyContext, BuilderMiddleware extends MiddlewareInput<Ctx> = undefined, RouteMiddleware extends MiddlewareInput<Ctx> = undefined> = Omit<Route<Ctx, RouteMiddleware, ZodRouteContext<Ctx, BuilderMiddleware, RouteMiddleware>>, 'handler' | 'schema' | 'middleware'> & ZodHandlerOptions<Schema, ZodRouteContext<Ctx, BuilderMiddleware, RouteMiddleware>> & {
  middleware?: RouteMiddleware;
};
/**
 * Method-specific route options used by Zod route builders.
 */
type WithZodOptions<Schema extends ZodRouteSchemaInput<any, any, any, any> | undefined, Ctx extends object = AnyContext, BuilderMiddleware extends MiddlewareInput<Ctx> = undefined, RouteMiddleware extends MiddlewareInput<Ctx> = undefined> = Omit<RouteOptions<Ctx, RouteMiddleware, ZodRouteContext<Ctx, BuilderMiddleware, RouteMiddleware>>, 'handler' | 'schema' | 'middleware'> & ZodHandlerOptions<Schema, ZodRouteContext<Ctx, BuilderMiddleware, RouteMiddleware>> & {
  middleware?: RouteMiddleware;
};
/**
 * Zod route builder created by [`createZodRouteBuilder`]{@link createZodRouteBuilder}.
 *
 * @example
 * ```ts
 * const route = createZodRouteBuilder()
 *
 * router.get('/users/:id', route({
 *   schema: {
 *     request: {
 *       path: z.object({id: z.string()}),
 *     },
 *   },
 *   handler: ({params}) => ({id: params.path.id}),
 * }))
 *
 * router.add(route({
 *   method: HttpMethod.GET,
 *   path: '/health',
 *   handler: () => ({ok: true}),
 * }))
 * ```
 */
type ZodRouteBuilder<BuilderCtx extends object = AnyContext, BuilderMiddleware extends MiddlewareInput<BuilderCtx> = undefined> = {
  /**
   * Build a full route definition that includes its own path.
   *
   * @param options - Full route options including `path`.
   * @returns A full route definition compatible with [`Router.add`]{@link Router#add}.
   */
  <Schema extends ZodRouteSchemaInput<any, any, any, any> | undefined, RouteMiddleware extends MiddlewareInput<BuilderCtx> = undefined>(options: ZodRouteOptions<Schema, BuilderCtx, BuilderMiddleware, RouteMiddleware>): Route<BuilderCtx, ZodBuilderMiddlewareInput<BuilderCtx, BuilderMiddleware, RouteMiddleware>, ZodRouteContext<BuilderCtx, BuilderMiddleware, RouteMiddleware>>;
  /**
   * Build method-specific route options that leave the path to the registering router.
   *
   * @param options - Method route options without a route path.
   * @returns Route options compatible with helpers like [`Router.get`]{@link Router#get}.
   */
  <Schema extends ZodRouteSchemaInput<any, any, any, any> | undefined, RouteMiddleware extends MiddlewareInput<BuilderCtx> = undefined>(options: WithZodOptions<Schema, BuilderCtx, BuilderMiddleware, RouteMiddleware>): RouteOptions<BuilderCtx, ZodBuilderMiddlewareInput<BuilderCtx, BuilderMiddleware, RouteMiddleware>, ZodRouteContext<BuilderCtx, BuilderMiddleware, RouteMiddleware>>;
};
/**
 * Options for [`defineZodMiddleware`]{@link defineZodMiddleware}.
 *
 * @typeParam AddedCtx - Context made available to downstream handlers.
 * @typeParam Ctx - Context required by the middleware.
 * @typeParam Responses - Status-keyed Zod schemas for locally originated responses.
 */
type DefineZodMiddlewareOptions<AddedCtx extends object, Ctx extends object, Responses extends AnyZodResponseBodySchemas> = {
  responses: Responses;
  run: DefineMiddlewareOptions<AddedCtx, Ctx, ZodMiddlewareDeclarations<Responses>>['run'];
};
/**
 * Create response-declaring middleware backed by Zod response schemas.
 *
 * @example
 * ```ts
 * const requireAuth = defineZodMiddleware({
 *     responses: { 401: z.object({ message: z.string() }) },
 *     run: (_ctx, { respond }) => respond(response({ message: 'Sign in' }, { status: 401 })),
 * })
 * ```
 *
 * @param options - Locally originated response schemas and middleware implementation.
 * @returns Declared middleware with inferred, runtime-validated terminal responses.
 * @typeParam AddedCtx - Context made available to downstream handlers.
 * @typeParam Ctx - Context required by the middleware.
 * @typeParam Responses - Status-keyed Zod schemas for locally originated responses.
 */
declare function defineZodMiddleware<AddedCtx extends object = {}, Ctx extends object = AnyContext, const Responses extends AnyZodResponseBodySchemas = {}>(options: DefineZodMiddlewareOptions<AddedCtx, Ctx, Responses>): DeclaredMiddleware<AddedCtx, Ctx>;
/**
 * Options for [`zodSchemaMiddleware`]{@link zodSchemaMiddleware}.
 *
 * @typeParam Schema - Zod request and downstream response schema declaration.
 */
type ZodSchemaMiddlewareBaseOptions<Schema extends ZodRouteSchemaInput<any, any, any, any> | undefined> = {
  schema?: Schema;
  validateResponse?: ResponseValidationOption;
};
/**
 * Options for a Zod request/response schema boundary.
 *
 * A custom request-validation callback must declare the response schemas it can originate.
 *
 * @typeParam Schema - Zod request and downstream response schema declaration.
 * @typeParam ValidationResponses - Schemas owned by a custom validation-error callback.
 */
type ZodSchemaMiddlewareOptions<Schema extends ZodRouteSchemaInput<any, any, any, any> | undefined, ValidationResponses extends AnyZodResponseBodySchemas | undefined = undefined> = ZodSchemaMiddlewareBaseOptions<Schema> & ([ValidationResponses] extends [undefined] ? {
  onRequestValidationError?: undefined;
  validationResponses?: undefined;
} : {
  onRequestValidationError: ValidationErrorHandler<Extract<ValidationResponses, AnyZodResponseBodySchemas>>;
  validationResponses: ValidationResponses;
});
/**
 * Create Zod middleware that parses request inputs and validates downstream responses.
 *
 * @example
 * ```ts
 * const parseUserId = zodSchemaMiddleware({
 *     schema: { request: { path: z.object({ id: z.string() }) } },
 * })
 * ```
 *
 * @param options - Request, response, and validation-error schema behavior.
 * @returns Declared middleware exposing parsed request values to downstream handlers.
 * @typeParam Schema - Zod request and downstream response schema declaration.
 * @typeParam Ctx - Context required before this middleware executes.
 */
declare function zodSchemaMiddleware<Schema extends ZodRouteSchemaInput<any, any, any, any> | undefined, const ValidationResponses extends AnyZodResponseBodySchemas | undefined = undefined, Ctx extends object = AnyContext>(options: ZodSchemaMiddlewareOptions<Schema, ValidationResponses>): DeclaredMiddleware<ZodSchemaMiddlewareContext<Schema>, Ctx>;
/**
 * Create a Zod route builder with shared defaults.
 *
 * @example
 * ```ts
 * const route = createZodRouteBuilder({
 *   validateResponse: false,
 *   schema: {
 *     response: {
 *       body: {
 *         400: z.object({message: z.string()}),
 *       },
 *     },
 *   },
 * })
 *
 * router.post('/users/:id', route({
 *   name: 'user.update',
 *   schema: {
 *     request: {
 *       path: z.object({id: z.string()}),
 *     },
 *   },
 *   handler: ({params}) => ({id: params.path.id}),
 * }))
 * ```
 *
 * @param defaults - Default schema fragments, response validation, and request validation error handling.
 * @returns A route builder compatible with method-specific router helpers and full route definitions.
 */
declare function createZodRouteBuilder<BuilderMiddleware extends MiddlewareInput<any>, BuilderCtx extends object = ContextFromMiddlewareInput<BuilderMiddleware>>(defaults: ZodRouteHelperDefaults<BuilderCtx, BuilderMiddleware> & {
  middleware: BuilderMiddleware;
}): ZodRouteBuilder<BuilderCtx, BuilderMiddleware>;
declare function createZodRouteBuilder<BuilderCtx extends object = AnyContext, BuilderMiddleware extends MiddlewareInput<BuilderCtx> = undefined>(defaults?: ZodRouteHelperDefaults<BuilderCtx, BuilderMiddleware>): ZodRouteBuilder<BuilderCtx, BuilderMiddleware>;
//#endregion
export { type AddedContextFromMiddlewareInput, type ContextFromMiddlewareInput, type DefineValibotMiddlewareOptions, type DefineZodMiddlewareOptions, type MiddlewareEntry, type Route, type RouteMatch, type RouteMeta, type RouteOptions, type RouteSchema, type ValibotHandlerContext, type ValibotHandlerParams, type ValibotRouteBuilder, type ValibotRouteHandler, type ValibotRouteHelperDefaults, type ValibotRouteSchemaInput, type ValibotSchemaMiddlewareOptions, ValibotValidationError, type ValibotValidationErrorBody, type ValibotValidationErrorHandler, ValidationError, type ValidationErrorHandler, type ZodHandlerContext, type ZodHandlerParams, type ZodRouteBuilder, type ZodRouteHandler, type ZodRouteHelperDefaults, type ZodRouteSchemaInput, type ZodSchemaMiddlewareOptions, type ZodValidationErrorBody, createValibotRouteBuilder, createZodRouteBuilder, defineValibotMiddleware, defineZodMiddleware, valibotSchemaMiddleware, zodSchemaMiddleware };