import { HonoBase } from "hono/hono-base";
import { Hono } from "hono";
import { ClientResponse, InferRequestType, hc } from "hono/client";
import { ExtractSchema, Schema as Schema$1 } from "hono/types";
//#region src/types/openapi.d.ts
type ConvertPath<P extends string> = P extends `${infer A}{${infer Param}}${infer B}` ? `${A}:${Param}${ConvertPath<B>}` : P;
type HttpMethod = "get" | "query" | "put" | "post" | "delete" | "options" | "head" | "patch" | "trace";
declare const optionalResponseStatuses: unique symbol;
type WithOptionalResponseStatuses<Paths, Status extends number> = Paths & {
  readonly [optionalResponseStatuses]?: Status;
};
type ExtractOptionalResponseStatuses<Paths> = Paths extends {
  readonly [optionalResponseStatuses]?: infer Status;
} ? Extract<Status, number> : never;
type NormalizeBasePathInner<BasePath extends string> = BasePath extends `${infer Prefix}/` ? NormalizeBasePathInner<Prefix> : BasePath;
type NormalizeBasePath<BasePath extends string> = BasePath extends "" | "/" ? "" : NormalizeBasePathInner<BasePath>;
type StripBasePath<Path extends string, BasePath extends string> = NormalizeBasePath<BasePath> extends (infer NormalizedBasePath extends string) ? NormalizedBasePath extends "" ? Path : Path extends NormalizedBasePath ? "/" : Path extends `${NormalizedBasePath}/${infer Rest}` ? `/${Rest}` : never : never;
type ParameterLocation = "path" | "query" | "header" | "cookie";
type ExtractParameterRecord<Source, Location extends ParameterLocation> = Source extends {
  parameters: infer Parameters extends object;
} ? Location extends keyof Parameters ? NonNullable<Parameters[Location]> extends object ? NonNullable<Parameters[Location]> : never : never : never;
type ExtractMergedParameterRecord<PathItem, Op, Location extends ParameterLocation> = [ExtractParameterRecord<Op, Location>] extends [never] ? ExtractParameterRecord<PathItem, Location> : ExtractParameterRecord<Op, Location>;
type ExtractRequestBodyContent<Op, ContentType extends string> = Op extends {
  requestBody: {
    content: infer Content extends object;
  };
} ? ContentType extends keyof Content ? Content[ContentType] : never : never;
type ExtractParam<PathItem, Op> = ExtractMergedParameterRecord<PathItem, Op, "path">;
type ExtractQuery<PathItem, Op> = ExtractMergedParameterRecord<PathItem, Op, "query">;
type ExtractHeader<PathItem, Op> = ExtractMergedParameterRecord<PathItem, Op, "header">;
type ExtractCookie<PathItem, Op> = ExtractMergedParameterRecord<PathItem, Op, "cookie">;
type ExtractJsonBody<Op> = ExtractRequestBodyContent<Op, "application/json">;
type ExtractFormBody<Op> = ExtractRequestBodyContent<Op, "multipart/form-data"> | ExtractRequestBodyContent<Op, "application/x-www-form-urlencoded">;
type HttpStatusFromKey<Key> = Key extends number ? Key : Key extends `${infer Status extends number}` ? Status : never;
type ExtractResponseContent<Response> = Response extends {
  content: infer Content;
} ? NonNullable<Content> extends object ? NonNullable<Content> : never : Response extends {
  content?: infer Content;
} ? NonNullable<Content> extends object ? NonNullable<Content> : never : never;
type OutputFormatForContentType<ContentType extends string> = ContentType extends "application/json" | `${string}+json` ? "json" : ContentType extends "text/plain" ? "text" : "body";
type IntoHonoInput<PathItem, Op> = ([ExtractParam<PathItem, Op>] extends [never] ? object : {
  param: ExtractParam<PathItem, Op>;
}) & ([ExtractQuery<PathItem, Op>] extends [never] ? object : {
  query: ExtractQuery<PathItem, Op>;
}) & ([ExtractHeader<PathItem, Op>] extends [never] ? object : {
  header: ExtractHeader<PathItem, Op>;
}) & ([ExtractCookie<PathItem, Op>] extends [never] ? object : {
  cookie: ExtractCookie<PathItem, Op>;
}) & ([ExtractJsonBody<Op>] extends [never] ? object : {
  json: ExtractJsonBody<Op>;
}) & ([ExtractFormBody<Op>] extends [never] ? object : {
  form: ExtractFormBody<Op>;
});
type IntoHonoResponseWithContent<PathItem, Op, Status extends number, Content extends object> = { [ContentType in keyof Content & string]: {
  input: IntoHonoInput<PathItem, Op>;
  output: Content[ContentType];
  outputFormat: OutputFormatForContentType<ContentType>;
  status: Status;
  responseLabel: `${Status} ${ContentType}`;
}; }[keyof Content & string];
type IntoHonoEmptyResponse<PathItem, Op, Status extends number> = {
  input: IntoHonoInput<PathItem, Op>;
  output: null;
  outputFormat: "body";
  status: Status;
  responseLabel: `${Status} no content`;
};
type IntoHonoResponse<PathItem, Op, ResponseKey, Response> = HttpStatusFromKey<ResponseKey> extends (infer Status) ? [Status] extends [never] ? never : Status extends number ? [ExtractResponseContent<Response>] extends [never] ? IntoHonoEmptyResponse<PathItem, Op, Status> : ExtractResponseContent<Response> extends (infer Content extends object) ? IntoHonoResponseWithContent<PathItem, Op, Status, Content> : never : never : never;
type IntoHonoMethod<PathItem, Op> = Op extends {
  responses: infer Responses extends object;
} ? { [ResponseKey in keyof Responses]: IntoHonoResponse<PathItem, Op, ResponseKey, Responses[ResponseKey]>; }[keyof Responses] : {
  input: IntoHonoInput<PathItem, Op>;
};
type IntoHonoMethodOrInputOnly<PathItem, Op> = [IntoHonoMethod<PathItem, Op>] extends [never] ? {
  input: IntoHonoInput<PathItem, Op>;
} : IntoHonoMethod<PathItem, Op>;
type IntoHonoEndpoint<PathItem, Op> = IntoHonoMethodOrInputOnly<PathItem, Op>;
type IntoSchemaMethod<PathItem, Op> = IntoHonoEndpoint<PathItem, Op>;
type IntoSchema<Paths, BasePath extends string = ""> = { [P in keyof Paths as [StripBasePath<P & string, BasePath>] extends [never] ? never : ConvertPath<StripBasePath<P & string, BasePath> & string>]: { [M in keyof Paths[P] & HttpMethod as [NonNullable<Paths[P][M]>] extends [never] ? never : `$${M}`]: IntoSchemaMethod<Paths[P], NonNullable<Paths[P][M]>>; }; };
//#endregion
//#region src/types/utility.d.ts
type PrettyMethod<Method extends string> = Method extends `$${infer Raw}` ? Uppercase<Raw> : Uppercase<Method>;
type UnionToIntersection<Union> = (Union extends unknown ? (arg: Union) => void : never) extends ((arg: infer Intersection) => void) ? Intersection : never;
type NormalizeReason<ReasonUnion> = [ReasonUnion] extends [never] ? unknown : UnionToIntersection<ReasonUnion>;
//#endregion
//#region src/types/hono.d.ts
type AnyHono = HonoBase<any, any, any, any>;
type SchemaPathEntry = {
  path: string;
  methods: Record<string, unknown>;
};
type SchemaEntries<Schema> = Schema extends Record<string, unknown> ? { [Path in keyof Schema & string]: {
  path: Path;
  methods: Schema[Path];
}; }[keyof Schema & string] : never;
type NormalizeSchemaEntries<Schema> = SchemaEntries<Schema> extends (infer Entry) ? Entry extends SchemaPathEntry ? {
  path: Entry["path"];
  methods: Entry["methods"];
} : never : never;
type ExpectedEntries<Paths, BasePath extends string = ""> = NormalizeSchemaEntries<IntoSchema<Paths, BasePath>>;
type HonoClientReservedKey = "$path" | "$url" | "$ws";
type HonoClientForSchemaPath<App extends AnyHono, Schema extends Schema$1, Path extends keyof Schema & string> = App extends HonoBase<infer Env, any, infer BasePath, any> ? ReturnType<typeof hc<Hono<Env, Pick<Schema, Path>, BasePath>, "">> : never;
type EndpointFromClientResponse<Response, Input> = Response extends ClientResponse<infer Output, infer Status, infer Format> ? {
  input: Input;
  output: Output;
  outputFormat: Format;
  status: Status;
} : never;
type EndpointFromClientMethod<Method> = Method extends ((...args: any[]) => Promise<infer Response>) ? EndpointFromClientResponse<Response, InferRequestType<Method>> : never;
type ClientEndpointMethods<Client> = { [Method in keyof Client & string as Method extends `$${string}` ? Method extends HonoClientReservedKey ? never : [EndpointFromClientMethod<Client[Method]>] extends [never] ? never : Method : never]: EndpointFromClientMethod<Client[Method]>; };
type TrimClientPathStartSlash<Path extends string> = Path extends `/${infer Rest}` ? TrimClientPathStartSlash<Rest> : Path;
type ClientNodeAtPathSegments<Client, Segments extends string> = Segments extends "" ? Client extends {
  index: infer Node;
} ? Node : never : Segments extends `${infer Head}/${infer Rest}` ? Head extends keyof Client ? ClientNodeAtPathSegments<Client[Head], Rest> : never : Segments extends keyof Client ? Client[Segments] : never;
type ClientNodeAtPath<Client, Path extends string> = ClientNodeAtPathSegments<Client, TrimClientPathStartSlash<Path>>;
type ActualEntryFromSchemaPath<App extends AnyHono, Schema extends Schema$1, Path extends keyof Schema & string> = ClientEndpointMethods<ClientNodeAtPath<HonoClientForSchemaPath<App, Schema, Path>, Path>> extends (infer Methods extends Record<string, unknown>) ? [keyof Methods] extends [never] ? never : {
  path: Path;
  methods: Methods;
} : never;
type ActualEntries<App extends AnyHono> = ExtractSchema<App> extends (infer Schema extends Schema$1) ? { [Path in keyof Schema & string]: ActualEntryFromSchemaPath<App, Schema, Path>; }[keyof Schema & string] : never;
type PathMethodTableFromEntries<Entries> = UnionToIntersection<Entries extends {
  path: infer Path extends string;
  methods: infer Methods extends Record<string, unknown>;
} ? { [Key in Path]: Methods; } : never>;
type ActualMethodTable<App extends AnyHono> = PathMethodTableFromEntries<ActualEntries<App>>;
type FindActualMethodsForPath<App extends AnyHono, Path extends string> = Path extends keyof ActualMethodTable<App> ? ActualMethodTable<App>[Path] : never;
type BasePathScopeReason<BasePath extends string> = { [Key in `Base path ${NormalizeBasePath<BasePath>} has no matching OpenAPI paths`]: never; };
type CheckBasePathScope<Paths, BasePath extends string> = NormalizeBasePath<BasePath> extends "" ? never : [ExpectedEntries<Paths, BasePath>] extends [never] ? BasePathScopeReason<BasePath> : never;
type InputTarget = "param" | "query" | "header" | "cookie" | "json" | "form";
type ExpectedInputTargets<ExpectedInput> = keyof ExpectedInput & InputTarget;
type PrettyInputTarget<Target extends InputTarget> = Target extends "param" ? "Path" : Target extends "json" ? "JSON" : Capitalize<Target>;
type InputMismatchReason<Target extends InputTarget, Path extends string, Method extends string> = { [Key in `${PrettyInputTarget<Target>} input mismatch at ${PrettyMethod<Method>} ${Path}`]: never; };
type InputTargetValue<Input, Target extends InputTarget> = Target extends keyof Input ? Input[Target] : never;
type NarrowStringInput<Value> = [Exclude<Value, undefined>] extends [string] ? string extends Exclude<Value, undefined> ? never : Exclude<Value, undefined> : never;
type HasArrayInput<Value> = [Extract<Exclude<Value, undefined>, readonly unknown[] | unknown[]>] extends [never] ? false : true;
type IsStringInputCompatible<ExpectedValue, ActualValue> = [NarrowStringInput<ExpectedValue>] extends [never] ? string extends ActualValue ? true : false : NarrowStringInput<ExpectedValue> extends ActualValue ? true : false;
type IsQueryInputCompatible<ExpectedValue, ActualValue> = HasArrayInput<ExpectedValue> extends true ? string[] extends ActualValue ? true : false : IsStringInputCompatible<ExpectedValue, ActualValue>;
type IsFormInputCompatible<ExpectedValue, ActualValue> = HasArrayInput<ExpectedValue> extends true ? string[] extends ActualValue ? true : false : IsStringInputCompatible<ExpectedValue, ActualValue>;
type AreTargetPropertiesCompatible<Target extends Exclude<InputTarget, "json">, ExpectedTargetInput extends object, ActualTargetInput extends object> = [keyof ExpectedTargetInput] extends [never] ? true : false extends { [Key in keyof ExpectedTargetInput]-?: Key extends keyof ActualTargetInput ? Target extends "query" ? IsQueryInputCompatible<ExpectedTargetInput[Key], ActualTargetInput[Key]> : Target extends "form" ? IsFormInputCompatible<ExpectedTargetInput[Key], ActualTargetInput[Key]> : IsStringInputCompatible<ExpectedTargetInput[Key], ActualTargetInput[Key]> : false; }[keyof ExpectedTargetInput] ? false : true;
type IsInputTargetCompatible<ActualInput extends object, ExpectedInput extends object, Target extends ExpectedInputTargets<ExpectedInput>> = Target extends keyof ActualInput ? Target extends "json" ? [InputTargetValue<ExpectedInput, Target>] extends [InputTargetValue<ActualInput, Target>] ? true : false : InputTargetValue<ExpectedInput, Target> extends object ? InputTargetValue<ActualInput, Target> extends object ? AreTargetPropertiesCompatible<Exclude<Target, "json">, InputTargetValue<ExpectedInput, Target>, InputTargetValue<ActualInput, Target>> : false : false : false;
type CheckMethodInputTargetCompatibility<ActualMethod, ExpectedInput extends object, Path extends string, Method extends string, Target extends ExpectedInputTargets<ExpectedInput>> = [ActualMethod extends unknown ? ActualMethod extends {
  input: infer ActualInput extends object;
} ? IsInputTargetCompatible<ActualInput, ExpectedInput, Target> extends true ? ActualInput : never : never : never] extends [never] ? InputMismatchReason<Target, Path, Method> : never;
type CheckMethodInputCompatibility<ActualMethod, ExpectedMethod, Path extends string, Method extends string> = ExpectedMethod extends {
  input: infer ExpectedInput extends object;
} ? [ExpectedInputTargets<ExpectedInput>] extends [never] ? never : { [Target in ExpectedInputTargets<ExpectedInput>]: CheckMethodInputTargetCompatibility<ActualMethod, ExpectedInput, Path, Method, Target>; }[ExpectedInputTargets<ExpectedInput>] : never;
type OutputMismatchReason<Label extends string, Path extends string, Method extends string> = { [Key in `Output mismatch at ${PrettyMethod<Method>} ${Path} for ${Label}`]: never; };
type IsBroadContentfulStatus<Status> = [200] extends [Status] ? [201] extends [Status] ? [400] extends [Status] ? [404] extends [Status] ? [500] extends [Status] ? [204] extends [Status] ? false : true : false : false : false : false : false;
type IsBroadStatus<Status> = [200] extends [Status] ? [201] extends [Status] ? [204] extends [Status] ? [304] extends [Status] ? [400] extends [Status] ? [500] extends [Status] ? true : false : false : false : false : false : false;
type NormalizeActualStatus<Status> = IsBroadStatus<Status> extends true ? 200 : IsBroadContentfulStatus<Status> extends true ? 200 : Status;
type IsOutputFormatCompatible<ActualFormat extends string, ExpectedFormat extends string> = [ActualFormat] extends [ExpectedFormat] ? [ExpectedFormat] extends [ActualFormat] ? true : false : false;
type IsOpaqueOutputFormat<ActualFormat extends string> = string extends ActualFormat ? true : false;
type IsStatusCompatible<ActualStatus extends number, ExpectedStatus extends number> = [NormalizeActualStatus<ActualStatus>] extends [ExpectedStatus] ? [ExpectedStatus] extends [NormalizeActualStatus<ActualStatus>] ? true : false : false;
type HasActualStatus<ActualMethod, ExpectedStatus extends number> = [ActualMethod extends unknown ? ActualMethod extends {
  status: infer ActualStatus extends number;
} ? IsStatusCompatible<ActualStatus, ExpectedStatus> extends true ? ActualMethod : never : never : never] extends [never] ? false : true;
type CheckMethodOutputCompatibility<ActualMethod, ExpectedMethod, Path extends string, Method extends string, OptionalStatuses extends number = never> = ExpectedMethod extends {
  output: infer Expected;
  outputFormat: infer ExpectedFormat extends string;
  status: infer ExpectedStatus extends number;
  responseLabel: infer ExpectedLabel extends string;
} ? [ActualMethod extends unknown ? ActualMethod extends {
  outputFormat: infer ActualFormat extends string;
  output: infer Candidate;
  status: infer ActualStatus extends number;
} ? IsOpaqueOutputFormat<ActualFormat> extends true ? Candidate : IsOutputFormatCompatible<ActualFormat, ExpectedFormat> extends true ? IsStatusCompatible<ActualStatus, ExpectedStatus> extends true ? [Candidate] extends [Expected] ? Candidate : never : never : never : never : never] extends [never] ? ExpectedStatus extends OptionalStatuses ? HasActualStatus<ActualMethod, ExpectedStatus> extends true ? OutputMismatchReason<ExpectedLabel, Path, Method> : never : OutputMismatchReason<ExpectedLabel, Path, Method> : never : never;
type CheckMethodInNormalizedSchema<ActualMethods, ExpectedMethods, Path extends string, Method extends keyof ExpectedMethods & string, OptionalStatuses extends number = never> = Method extends keyof ActualMethods ? CheckMethodInputCompatibility<ActualMethods[Method], ExpectedMethods[Method], Path, Method> | CheckMethodOutputCompatibility<ActualMethods[Method], ExpectedMethods[Method], Path, Method, OptionalStatuses> : { [Key in `${PrettyMethod<Method>} ${Path} is missing`]: never; };
type CheckNormalizedSchema<App extends AnyHono, Paths, BasePath extends string = ""> = NormalizeReason<CheckBasePathScope<Paths, BasePath> | (ExpectedEntries<Paths, BasePath> extends (infer Entry) ? Entry extends {
  path: infer Path extends string;
  methods: infer Methods extends Record<string, unknown>;
} ? { [Method in keyof Methods & string]: CheckMethodInNormalizedSchema<FindActualMethodsForPath<App, Path>, Methods, Path, Method, ExtractOptionalResponseStatuses<Paths>>; }[keyof Methods & string] : never : never)>;
type DefineAppCheckNormalizedSchema<App extends AnyHono, Paths, BasePath extends string = ""> = CheckNormalizedSchema<App, Paths, BasePath>;
//#endregion
//#region src/define-app.d.ts
/**
 * Validates a Hono app against an OpenAPI-derived `paths` type.
 *
 * The function is curried so callers can specify `Paths` explicitly while keeping
 * the concrete `App` type inferred from the provided Hono instance.
 * Missing routes/methods and output mismatches are reported as type errors.
 *
 * This implementation normalizes both expected and actual schemas into
 * `{ path, methods }` entries before comparison, and then builds a path-indexed
 * lookup table for actual methods. This works with flat route definitions as
 * well as `basePath()` and `route()` composition.
 *
 * @example
 * ```ts
 * import { Hono } from "hono";
 * import { defineApp } from "openapi-ts-hono";
 * import type { paths } from "./generated/schema";
 *
 * const app = defineApp<paths>()(
 *   new Hono().get("/users/:userId", (c) => {
 *     const userId = c.req.param("userId");
 *     return c.json({ id: userId, name: "Alice" });
 *   }),
 * );
 * ```
 *
 * @example
 * ```ts
 * const users = new Hono().get("/users/:id", (c) => {
 *   return c.json({ id: c.req.param("id") });
 * });
 *
 * const app = defineApp<{
 *   "/api/users/{id}": {
 *     get: {
 *       responses: {
 *         200: {
 *           content: {
 *             "application/json": { id: string };
 *           };
 *         };
 *       };
 *     };
 *   };
 * }>()(new Hono().route("/api", users));
 * ```
 *
 * @example
 * ```ts
 * const userApp = defineApp<paths, "/users">()(
 *   new Hono().get("/:id", (c) => {
 *     return c.json({ id: c.req.param("id") });
 *   }),
 * );
 *
 * const app = defineApp<paths>()(new Hono().route("/users", userApp));
 * ```
 */
declare function defineApp<Paths, BasePath extends string = "">(): <App extends HonoBase<any, any, any, any>>(app: App & DefineAppCheckNormalizedSchema<App, Paths, BasePath>) => App;
//#endregion
export { type WithOptionalResponseStatuses, defineApp };