import { C as MiddlewareInput, I as RouteOptions, N as Route, a as MiddlewareResponseDeclaration, f as ContextFromMiddlewareInput, g as HandlerResult, h as HandlerContext, l as AddedContextFromMiddlewareInput, n as DeclaredMiddleware, r as DefineMiddlewareOptions, t as Router } from "./router-Cwb7ak0J.mjs";
import { n as RoutekitResponse } from "./core-CzUCxvGk.mjs";
import * as v from "valibot";

//#region src/router/routes/valibot/valibot.d.ts
/**
 * Validation error component identifiers for Valibot-backed routes.
 */
declare const enum ValibotValidationError {
  REQUEST_BODY = 0,
  URL_PATH = 1,
  QUERY_PARAMETERS = 2
}
type AnyValibotSchema = v.GenericSchema;
type ValibotSchema = AnyValibotSchema | undefined;
type ValibotObjectSchema = v.ObjectSchema<v.ObjectEntries, v.ErrorMessage<v.ObjectIssue> | undefined>;
type ValibotPathSchema = ValibotObjectSchema | undefined;
type AnyValibotResponseBodySchemas = Partial<Record<number | 'default', AnyValibotSchema>>;
type ValibotResponseBodySchemas = AnyValibotResponseBodySchemas | undefined;
type ResponseValidationMode = false | 'strict' | 'parse';
type ResponseValidationOption = boolean | ResponseValidationMode;
type ValibotRouteContext<Ctx extends object, BuilderMiddleware, RouteMiddleware> = Ctx & AddedContextFromMiddlewareInput<BuilderMiddleware> & AddedContextFromMiddlewareInput<RouteMiddleware>;
type ValibotBuilderMiddlewareInput<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 Valibot-backed routes.
 */
type ValibotValidationErrorBody = {
  component: 'request_body' | 'url_path' | 'query_parameters';
  issues: v.BaseIssue<unknown>[];
  message: string;
};
/**
 * Valibot schema input that mirrors the core route `schema` shape.
 */
type ValibotRouteSchemaInput<BodySchema extends ValibotSchema = undefined, PathSchema extends ValibotPathSchema = undefined, QuerySchema extends ValibotSchema = undefined, ResponseBodySchemas extends ValibotResponseBodySchemas = undefined> = {
  request?: {
    query?: QuerySchema;
    path?: PathSchema;
    body?: BodySchema;
  };
  response?: {
    body?: ResponseBodySchemas;
  };
};
type AnyValibotRouteSchemaInput = ValibotRouteSchemaInput<AnyValibotSchema, ValibotObjectSchema, AnyValibotSchema, AnyValibotResponseBodySchemas>;
type InferSchema<Schema extends ValibotSchema> = Schema extends v.GenericSchema ? v.InferOutput<Schema> : unknown;
type InferResponseBodySchemaInputUnion<ResponseBodySchemas extends AnyValibotResponseBodySchemas> = [keyof ResponseBodySchemas] extends [never] ? unknown : { [Status in keyof ResponseBodySchemas]: NonNullable<ResponseBodySchemas[Status]> extends AnyValibotSchema ? v.InferInput<NonNullable<ResponseBodySchemas[Status]>> : never }[keyof ResponseBodySchemas];
type InferResponseBodySchemaOutputUnion<ResponseBodySchemas extends AnyValibotResponseBodySchemas> = [keyof ResponseBodySchemas] extends [never] ? unknown : { [Status in keyof ResponseBodySchemas]: NonNullable<ResponseBodySchemas[Status]> extends AnyValibotSchema ? v.InferOutput<NonNullable<ResponseBodySchemas[Status]>> : never }[keyof ResponseBodySchemas];
type InferResponseBodyInput<ResponseBodySchemas extends ValibotResponseBodySchemas> = ResponseBodySchemas extends AnyValibotResponseBodySchemas ? 200 extends keyof ResponseBodySchemas ? InferResponseBodySchemaInputUnion<ResponseBodySchemas> : 'default' extends keyof ResponseBodySchemas ? InferResponseBodySchemaInputUnion<ResponseBodySchemas> : unknown : unknown;
type InferResponseBodyOutput<ResponseBodySchemas extends ValibotResponseBodySchemas> = ResponseBodySchemas extends AnyValibotResponseBodySchemas ? 200 extends keyof ResponseBodySchemas ? InferResponseBodySchemaOutputUnion<ResponseBodySchemas> : 'default' extends keyof ResponseBodySchemas ? InferResponseBodySchemaOutputUnion<ResponseBodySchemas> : unknown : unknown;
type InferResponseBodyAccepted<ResponseBodySchemas extends ValibotResponseBodySchemas> = InferResponseBodyInput<ResponseBodySchemas> | InferResponseBodyOutput<ResponseBodySchemas>;
type NormalizeSchema<Schema> = Schema extends AnyValibotRouteSchemaInput ? Schema : ValibotRouteSchemaInput<undefined, undefined, undefined, undefined>;
type ExtractBodySchema<Schema extends AnyValibotRouteSchemaInput | undefined> = NormalizeSchema<Schema> extends ValibotRouteSchemaInput<infer BodySchema, infer _PathSchema, infer _QuerySchema, infer _ResponseBodySchemas> ? BodySchema : undefined;
type ExtractPathSchema<Schema extends AnyValibotRouteSchemaInput | undefined> = NormalizeSchema<Schema> extends ValibotRouteSchemaInput<infer _BodySchema, infer PathSchema, infer _QuerySchema, infer _ResponseBodySchemas> ? PathSchema : undefined;
type ExtractQuerySchema<Schema extends AnyValibotRouteSchemaInput | undefined> = NormalizeSchema<Schema> extends ValibotRouteSchemaInput<infer _BodySchema, infer _PathSchema, infer QuerySchema, infer _ResponseBodySchemas> ? QuerySchema : undefined;
type ExtractResponseBodySchemas<Schema extends AnyValibotRouteSchemaInput | undefined> = NormalizeSchema<Schema> extends ValibotRouteSchemaInput<infer _BodySchema, infer _PathSchema, infer _QuerySchema, infer ResponseBodySchemas> ? ResponseBodySchemas : undefined;
type ValibotMiddlewareDeclarations<Schemas extends AnyValibotResponseBodySchemas> = { [Status in keyof Schemas]: NonNullable<Schemas[Status]> extends AnyValibotSchema ? MiddlewareResponseDeclaration<v.InferOutput<NonNullable<Schemas[Status]>>> : never };
type ValibotDeclaredResponse<Schemas extends AnyValibotResponseBodySchemas> = { [Status in keyof Schemas]-?: NonNullable<Schemas[Status]> extends AnyValibotSchema ? RoutekitResponse<v.InferOutput<NonNullable<Schemas[Status]>>, Status extends number ? Status : number> : never }[keyof Schemas];
type ValibotSchemaMiddlewareContext<Schema extends AnyValibotRouteSchemaInput | undefined> = ValibotHandlerParams<ExtractBodySchema<Schema>, ExtractPathSchema<Schema>, ExtractQuerySchema<Schema>> & {
  params: ValibotHandlerParams<ExtractBodySchema<Schema>, ExtractPathSchema<Schema>, ExtractQuerySchema<Schema>>;
};
/**
 * Validated request inputs exposed to a Valibot-backed handler.
 */
type ValibotHandlerParams<BodySchema extends ValibotSchema, PathSchema extends ValibotPathSchema, QuerySchema extends ValibotSchema> = {
  path: InferSchema<PathSchema>;
  query: InferSchema<QuerySchema>;
  body: InferSchema<BodySchema>;
};
/**
 * Context object exposed to a Valibot-backed handler.
 */
type ValibotHandlerContext<BodySchema extends ValibotSchema, PathSchema extends ValibotPathSchema, QuerySchema extends ValibotSchema, Ctx extends object> = Omit<HandlerContext<Ctx>, 'path'> & ValibotHandlerParams<BodySchema, PathSchema, QuerySchema> & {
  params: ValibotHandlerParams<BodySchema, PathSchema, QuerySchema>;
};
/**
 * Validation error handler used when request parsing fails.
 *
 * @param component - Request component that failed validation.
 * @param issues - The Valibot validation issues.
 * @returns A handler result that should be returned to the client.
 */
type ValibotValidationErrorHandler<Responses extends AnyValibotResponseBodySchemas = AnyValibotResponseBodySchemas> = (component: ValibotValidationError, issues: [v.BaseIssue<unknown>, ...v.BaseIssue<unknown>[]]) => ValibotDeclaredResponse<Responses>;
/**
 * Shared defaults that can be applied to Valibot handler helpers.
 */
type ValibotHandlerDefaults = {
  /**
   * Route schema fragments that should be merged into every built route.
   * Route-level schemas override matching request fields and response status codes.
   */
  schema?: AnyValibotRouteSchemaInput;
  /**
   * 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: ValibotValidationErrorHandler;
  /**
   * Response schemas returned by `onRequestValidationError`.
   */
  validationResponses: AnyValibotResponseBodySchemas;
});
/**
 * Shared defaults that can be applied to Valibot route helpers.
 */
type ValibotRouteHelperDefaults<BuilderCtx extends object = object, BuilderMiddleware extends MiddlewareInput<BuilderCtx> = undefined> = ValibotHandlerDefaults & {
  /**
   * Middleware applied to every route built by the helper.
   */
  middleware?: BuilderMiddleware;
};
/**
 * Handler signature used by Valibot schema boundaries and route builders.
 */
type ValibotRouteHandler<BodySchema extends ValibotSchema, PathSchema extends ValibotPathSchema, QuerySchema extends ValibotSchema, ResponseBodySchemas extends ValibotResponseBodySchemas, Ctx extends object = object> = (this: Router<any>, ctx: ValibotHandlerContext<BodySchema, PathSchema, QuerySchema, Ctx>) => HandlerResult<InferResponseBodyAccepted<ResponseBodySchemas>>;
/**
 * Shared options used by Valibot route builders.
 */
type ValibotHandlerOptions<Schema extends AnyValibotRouteSchemaInput | undefined, Ctx extends object = object> = ValibotHandlerDefaults & {
  schema?: Schema;
  handler: ValibotRouteHandler<ExtractBodySchema<Schema>, ExtractPathSchema<Schema>, ExtractQuerySchema<Schema>, ExtractResponseBodySchemas<Schema>, Ctx>;
};
/**
 * Full route options used by Valibot route builders.
 */
type ValibotRouteOptions<Schema extends AnyValibotRouteSchemaInput | undefined, Ctx extends object = object, BuilderMiddleware extends MiddlewareInput<Ctx> = undefined, RouteMiddleware extends MiddlewareInput<Ctx> = undefined> = Omit<Route<Ctx, RouteMiddleware, ValibotRouteContext<Ctx, BuilderMiddleware, RouteMiddleware>>, 'handler' | 'schema' | 'middleware'> & ValibotHandlerOptions<Schema, ValibotRouteContext<Ctx, BuilderMiddleware, RouteMiddleware>> & {
  middleware?: RouteMiddleware;
};
/**
 * Method-specific route options used by Valibot route builders.
 */
type WithValibotOptions<Schema extends AnyValibotRouteSchemaInput | undefined, Ctx extends object = object, BuilderMiddleware extends MiddlewareInput<Ctx> = undefined, RouteMiddleware extends MiddlewareInput<Ctx> = undefined> = Omit<RouteOptions<Ctx, RouteMiddleware, ValibotRouteContext<Ctx, BuilderMiddleware, RouteMiddleware>>, 'handler' | 'schema' | 'middleware'> & ValibotHandlerOptions<Schema, ValibotRouteContext<Ctx, BuilderMiddleware, RouteMiddleware>> & {
  middleware?: RouteMiddleware;
};
/**
 * Valibot route builder created by [`createValibotRouteBuilder`]{@link createValibotRouteBuilder}.
 *
 * @example
 * ```ts
 * const route = createValibotRouteBuilder()
 *
 * router.get('/users/:id', route({
 *   schema: {
 *     request: {
 *       path: v.object({id: v.string()}),
 *     },
 *   },
 *   handler: ({path}) => ({id: path.id}),
 * }))
 *
 * router.add(route({
 *   method: HttpMethod.GET,
 *   path: '/health',
 *   handler: () => ({ok: true}),
 * }))
 * ```
 */
type ValibotRouteBuilder<BuilderCtx extends object = object, 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 AnyValibotRouteSchemaInput | undefined, RouteMiddleware extends MiddlewareInput<BuilderCtx> = undefined>(options: ValibotRouteOptions<Schema, BuilderCtx, BuilderMiddleware, RouteMiddleware>): Route<BuilderCtx, ValibotBuilderMiddlewareInput<BuilderCtx, BuilderMiddleware, RouteMiddleware>, ValibotRouteContext<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 AnyValibotRouteSchemaInput | undefined, RouteMiddleware extends MiddlewareInput<BuilderCtx> = undefined>(options: WithValibotOptions<Schema, BuilderCtx, BuilderMiddleware, RouteMiddleware>): RouteOptions<BuilderCtx, ValibotBuilderMiddlewareInput<BuilderCtx, BuilderMiddleware, RouteMiddleware>, ValibotRouteContext<BuilderCtx, BuilderMiddleware, RouteMiddleware>>;
};
/**
 * Options for [`defineValibotMiddleware`]{@link defineValibotMiddleware}.
 *
 * @typeParam AddedCtx - Context made available to downstream handlers.
 * @typeParam Ctx - Context required by the middleware.
 * @typeParam Responses - Status-keyed Valibot schemas for locally originated responses.
 */
type DefineValibotMiddlewareOptions<AddedCtx extends object, Ctx extends object, Responses extends AnyValibotResponseBodySchemas> = {
  /**
   * Responses that this middleware may originate.
   */
  responses: Responses;
  /**
   * Execute middleware behavior using typed `respond(...)` and `forward(...)` controls.
   */
  run: DefineMiddlewareOptions<AddedCtx, Ctx, ValibotMiddlewareDeclarations<Responses>>['run'];
};
/**
 * Create response-declaring middleware backed by Valibot response schemas.
 *
 * @example
 * ```ts
 * const requireAuth = defineValibotMiddleware({
 *     responses: { 401: v.object({ message: v.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 Valibot schemas for locally originated responses.
 */
declare function defineValibotMiddleware<AddedCtx extends object = {}, Ctx extends object = object, const Responses extends AnyValibotResponseBodySchemas = {}>(options: DefineValibotMiddlewareOptions<AddedCtx, Ctx, Responses>): DeclaredMiddleware<AddedCtx, Ctx>;
/**
 * Options for [`valibotSchemaMiddleware`]{@link valibotSchemaMiddleware}.
 *
 * @typeParam Schema - Valibot request and downstream response schema declaration.
 */
type ValibotSchemaMiddlewareBaseOptions<Schema extends AnyValibotRouteSchemaInput | undefined> = {
  schema?: Schema;
  validateResponse?: ResponseValidationOption;
};
/**
 * Options for a Valibot request/response schema boundary.
 *
 * A custom request-validation callback must declare the response schemas it can originate.
 *
 * @typeParam Schema - Valibot request and downstream response schema declaration.
 * @typeParam ValidationResponses - Schemas owned by a custom validation-error callback.
 */
type ValibotSchemaMiddlewareOptions<Schema extends AnyValibotRouteSchemaInput | undefined, ValidationResponses extends AnyValibotResponseBodySchemas | undefined = undefined> = ValibotSchemaMiddlewareBaseOptions<Schema> & ([ValidationResponses] extends [undefined] ? {
  onRequestValidationError?: undefined;
  validationResponses?: undefined;
} : {
  onRequestValidationError: ValibotValidationErrorHandler<Extract<ValidationResponses, AnyValibotResponseBodySchemas>>;
  validationResponses: ValidationResponses;
});
/**
 * Create Valibot middleware that parses request inputs and validates downstream responses.
 *
 * @example
 * ```ts
 * const parseUserId = valibotSchemaMiddleware({
 *     schema: { request: { path: v.object({ id: v.string() }) } },
 * })
 * ```
 *
 * @param options - Request, response, and validation-error schema behavior.
 * @returns Declared middleware exposing parsed request values to downstream handlers.
 * @typeParam Schema - Valibot request and downstream response schema declaration.
 * @typeParam Ctx - Context required before this middleware executes.
 */
declare function valibotSchemaMiddleware<Schema extends AnyValibotRouteSchemaInput | undefined, const ValidationResponses extends AnyValibotResponseBodySchemas | undefined = undefined, Ctx extends object = object>(options: ValibotSchemaMiddlewareOptions<Schema, ValidationResponses>): DeclaredMiddleware<ValibotSchemaMiddlewareContext<Schema>, Ctx>;
/**
 * Create a Valibot route builder with shared defaults.
 *
 * @example
 * ```ts
 * const route = createValibotRouteBuilder({
 *   validateResponse: false,
 *   schema: {
 *     response: {
 *       body: {
 *         400: v.object({message: v.string()}),
 *       },
 *     },
 *   },
 * })
 *
 * router.post('/users/:id', route({
 *   name: 'user.update',
 *   schema: {
 *     request: {
 *       path: v.object({id: v.string()}),
 *     },
 *   },
 *   handler: ({path}) => ({id: 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 createValibotRouteBuilder<BuilderMiddleware extends MiddlewareInput<any>, BuilderCtx extends object = ContextFromMiddlewareInput<BuilderMiddleware>>(defaults: ValibotRouteHelperDefaults<BuilderCtx, BuilderMiddleware> & {
  middleware: BuilderMiddleware;
}): ValibotRouteBuilder<BuilderCtx, BuilderMiddleware>;
declare function createValibotRouteBuilder<BuilderCtx extends object = object, BuilderMiddleware extends MiddlewareInput<BuilderCtx> = undefined>(defaults?: ValibotRouteHelperDefaults<BuilderCtx, BuilderMiddleware>): ValibotRouteBuilder<BuilderCtx, BuilderMiddleware>;
//#endregion
export { ValibotRouteHandler as a, ValibotSchemaMiddlewareOptions as c, ValibotValidationErrorHandler as d, createValibotRouteBuilder as f, ValibotRouteBuilder as i, ValibotValidationError as l, valibotSchemaMiddleware as m, ValibotHandlerContext as n, ValibotRouteHelperDefaults as o, defineValibotMiddleware as p, ValibotHandlerParams as r, ValibotRouteSchemaInput as s, DefineValibotMiddlewareOptions as t, ValibotValidationErrorBody as u };