@orpc/openapi 0.0.0-next.eb37cbe → 0.0.0-next.ed15210

package/dist/index.js

@@ -3,7 +3,7 @@ import {
   forEachAllContractProcedure,
   forEachContractProcedure,
   standardizeHTTPPath
-} from "./chunk-KNYXLM77.js";
+} from "./chunk-DSYVLQK3.js";
 
 // src/openapi.ts
 import { OpenApiBuilder } from "openapi3-ts/oas31";
@@ -35,8 +35,156 @@ var OpenAPIContentBuilder = class {
   }
 };
 
+// src/openapi-generator.ts
+import { fallbackContractConfig as fallbackContractConfig2, fallbackORPCErrorStatus } from "@orpc/contract";
+import { group } from "@orpc/shared";
+
+// src/openapi-error.ts
+var OpenAPIError = class extends Error {
+};
+
+// src/openapi-input-structure-parser.ts
+import { fallbackContractConfig } from "@orpc/contract";
+var OpenAPIInputStructureParser = class {
+  constructor(schemaConverter, schemaUtils, pathParser) {
+    this.schemaConverter = schemaConverter;
+    this.schemaUtils = schemaUtils;
+    this.pathParser = pathParser;
+  }
+  parse(contract, structure) {
+    const inputSchema = this.schemaConverter.convert(contract["~orpc"].InputSchema, { strategy: "input" });
+    const method = fallbackContractConfig("defaultMethod", contract["~orpc"].route?.method);
+    const httpPath = contract["~orpc"].route?.path;
+    if (this.schemaUtils.isAnySchema(inputSchema)) {
+      return {
+        paramsSchema: void 0,
+        querySchema: void 0,
+        headersSchema: void 0,
+        bodySchema: void 0
+      };
+    }
+    if (structure === "detailed") {
+      return this.parseDetailedSchema(inputSchema);
+    } else {
+      return this.parseCompactSchema(inputSchema, method, httpPath);
+    }
+  }
+  parseDetailedSchema(inputSchema) {
+    if (!this.schemaUtils.isObjectSchema(inputSchema)) {
+      throw new OpenAPIError(`When input structure is 'detailed', input schema must be an object.`);
+    }
+    if (inputSchema.properties && Object.keys(inputSchema.properties).some((key) => !["params", "query", "headers", "body"].includes(key))) {
+      throw new OpenAPIError(`When input structure is 'detailed', input schema must be only can contain 'params', 'query', 'headers' and 'body' properties.`);
+    }
+    let paramsSchema = inputSchema.properties?.params;
+    let querySchema = inputSchema.properties?.query;
+    let headersSchema = inputSchema.properties?.headers;
+    const bodySchema = inputSchema.properties?.body;
+    if (paramsSchema !== void 0 && this.schemaUtils.isAnySchema(paramsSchema)) {
+      paramsSchema = void 0;
+    }
+    if (paramsSchema !== void 0 && !this.schemaUtils.isObjectSchema(paramsSchema)) {
+      throw new OpenAPIError(`When input structure is 'detailed', params schema in input schema must be an object.`);
+    }
+    if (querySchema !== void 0 && this.schemaUtils.isAnySchema(querySchema)) {
+      querySchema = void 0;
+    }
+    if (querySchema !== void 0 && !this.schemaUtils.isObjectSchema(querySchema)) {
+      throw new OpenAPIError(`When input structure is 'detailed', query schema in input schema must be an object.`);
+    }
+    if (headersSchema !== void 0 && this.schemaUtils.isAnySchema(headersSchema)) {
+      headersSchema = void 0;
+    }
+    if (headersSchema !== void 0 && !this.schemaUtils.isObjectSchema(headersSchema)) {
+      throw new OpenAPIError(`When input structure is 'detailed', headers schema in input schema must be an object.`);
+    }
+    return { paramsSchema, querySchema, headersSchema, bodySchema };
+  }
+  parseCompactSchema(inputSchema, method, httpPath) {
+    const dynamic = httpPath ? this.pathParser.parseDynamicParams(httpPath) : [];
+    if (dynamic.length === 0) {
+      if (method === "GET") {
+        let querySchema = inputSchema;
+        if (querySchema !== void 0 && this.schemaUtils.isAnySchema(querySchema)) {
+          querySchema = void 0;
+        }
+        if (querySchema !== void 0 && !this.schemaUtils.isObjectSchema(querySchema)) {
+          throw new OpenAPIError(`When input structure is 'compact' and method is 'GET', input schema must be an object.`);
+        }
+        return {
+          paramsSchema: void 0,
+          querySchema,
+          headersSchema: void 0,
+          bodySchema: void 0
+        };
+      }
+      return {
+        paramsSchema: void 0,
+        querySchema: void 0,
+        headersSchema: void 0,
+        bodySchema: inputSchema
+      };
+    }
+    if (!this.schemaUtils.isObjectSchema(inputSchema)) {
+      throw new OpenAPIError(`When input structure is 'compact' and path has dynamic parameters, input schema must be an object.`);
+    }
+    const [params, rest] = this.schemaUtils.separateObjectSchema(inputSchema, dynamic.map((v) => v.name));
+    return {
+      paramsSchema: params,
+      querySchema: method === "GET" ? rest : void 0,
+      headersSchema: void 0,
+      bodySchema: method !== "GET" ? rest : void 0
+    };
+  }
+};
+
+// src/openapi-output-structure-parser.ts
+var OpenAPIOutputStructureParser = class {
+  constructor(schemaConverter, schemaUtils) {
+    this.schemaConverter = schemaConverter;
+    this.schemaUtils = schemaUtils;
+  }
+  parse(contract, structure) {
+    const outputSchema = this.schemaConverter.convert(contract["~orpc"].OutputSchema, { strategy: "output" });
+    if (this.schemaUtils.isAnySchema(outputSchema)) {
+      return {
+        headersSchema: void 0,
+        bodySchema: void 0
+      };
+    }
+    if (structure === "detailed") {
+      return this.parseDetailedSchema(outputSchema);
+    } else {
+      return this.parseCompactSchema(outputSchema);
+    }
+  }
+  parseDetailedSchema(outputSchema) {
+    if (!this.schemaUtils.isObjectSchema(outputSchema)) {
+      throw new OpenAPIError(`When output structure is 'detailed', output schema must be an object.`);
+    }
+    if (outputSchema.properties && Object.keys(outputSchema.properties).some((key) => !["headers", "body"].includes(key))) {
+      throw new OpenAPIError(`When output structure is 'detailed', output schema must be only can contain 'headers' and 'body' properties.`);
+    }
+    let headersSchema = outputSchema.properties?.headers;
+    const bodySchema = outputSchema.properties?.body;
+    if (headersSchema !== void 0 && this.schemaUtils.isAnySchema(headersSchema)) {
+      headersSchema = void 0;
+    }
+    if (headersSchema !== void 0 && !this.schemaUtils.isObjectSchema(headersSchema)) {
+      throw new OpenAPIError(`When output structure is 'detailed', headers schema in output schema must be an object.`);
+    }
+    return { headersSchema, bodySchema };
+  }
+  parseCompactSchema(outputSchema) {
+    return {
+      headersSchema: void 0,
+      bodySchema: outputSchema
+    };
+  }
+};
+
 // src/openapi-parameters-builder.ts
-import { get, isPlainObject } from "@orpc/shared";
+import { get, isPlainObject, omit } from "@orpc/shared";
 var OpenAPIParametersBuilder = class {
   build(paramIn, jsonSchema, options) {
     const parameters = [];
@@ -63,6 +211,14 @@ var OpenAPIParametersBuilder = class {
     }
     return parameters;
   }
+  buildHeadersObject(jsonSchema, options) {
+    const parameters = this.build("header", jsonSchema, options);
+    const headersObject = {};
+    for (const param of parameters) {
+      headersObject[param.name] = omit(param, ["name", "in"]);
+    }
+    return headersObject;
+  }
 };
 
 // src/openapi-path-parser.ts
@@ -138,14 +294,14 @@ var SchemaUtils = class {
     return typeof schema === "object" && schema.type === "object";
   }
   isAnySchema(schema) {
-    return schema === true || Object.keys(schema).length === 0;
+    return schema === true || Object.keys(schema).filter((key) => !NON_LOGIC_KEYWORDS.includes(key)).length === 0;
   }
   isUndefinableSchema(schema) {
     const [matches] = this.filterSchemaBranches(schema, (schema2) => {
       if (typeof schema2 === "boolean") {
         return schema2;
       }
-      return Object.keys(schema2).length === 0;
+      return Object.keys(schema2).filter((key) => !NON_LOGIC_KEYWORDS.includes(key)).length === 0;
     });
     return matches.length > 0;
   }
@@ -218,21 +374,32 @@ var SchemaUtils = class {
 
 // src/openapi-generator.ts
 var OpenAPIGenerator = class {
+  contentBuilder;
+  parametersBuilder;
+  schemaConverter;
+  schemaUtils;
+  jsonSerializer;
+  pathParser;
+  inputStructureParser;
+  outputStructureParser;
+  errorHandlerStrategy;
+  ignoreUndefinedPathProcedures;
+  considerMissingTagDefinitionAsError;
+  strictErrorResponses;
   constructor(options) {
-    this.options = options;
     this.parametersBuilder = options?.parametersBuilder ?? new OpenAPIParametersBuilder();
     this.schemaConverter = new CompositeSchemaConverter(options?.schemaConverters ?? []);
     this.schemaUtils = options?.schemaUtils ?? new SchemaUtils();
     this.jsonSerializer = options?.jsonSerializer ?? new JSONSerializer();
     this.contentBuilder = options?.contentBuilder ?? new OpenAPIContentBuilder(this.schemaUtils);
     this.pathParser = new OpenAPIPathParser();
+    this.inputStructureParser = options?.inputStructureParser ?? new OpenAPIInputStructureParser(this.schemaConverter, this.schemaUtils, this.pathParser);
+    this.outputStructureParser = options?.outputStructureParser ?? new OpenAPIOutputStructureParser(this.schemaConverter, this.schemaUtils);
+    this.errorHandlerStrategy = options?.errorHandlerStrategy ?? "throw";
+    this.ignoreUndefinedPathProcedures = options?.ignoreUndefinedPathProcedures ?? false;
+    this.considerMissingTagDefinitionAsError = options?.considerMissingTagDefinitionAsError ?? false;
+    this.strictErrorResponses = options?.strictErrorResponses ?? true;
   }
-  contentBuilder;
-  parametersBuilder;
-  schemaConverter;
-  schemaUtils;
-  jsonSerializer;
-  pathParser;
   async generate(router, doc) {
     const builder = new OpenApiBuilder({
       ...doc,
@@ -240,108 +407,129 @@ var OpenAPIGenerator = class {
     });
     const rootTags = doc.tags?.map((tag) => tag.name) ?? [];
     await forEachAllContractProcedure(router, ({ contract, path }) => {
-      const def = contract["~orpc"];
-      if (this.options?.ignoreUndefinedPathProcedures && def.route?.path === void 0) {
-        return;
-      }
-      const method = def.route?.method ?? "POST";
-      const httpPath = def.route?.path ? standardizeHTTPPath(def.route?.path) : `/${path.map(encodeURIComponent).join("/")}`;
-      let inputSchema = this.schemaConverter.convert(def.InputSchema, { strategy: "input" });
-      const outputSchema = this.schemaConverter.convert(def.OutputSchema, { strategy: "output" });
-      const params = (() => {
-        const dynamic = this.pathParser.parseDynamicParams(httpPath);
-        if (!dynamic.length) {
-          return void 0;
-        }
-        if (this.schemaUtils.isAnySchema(inputSchema)) {
-          return void 0;
-        }
-        if (!this.schemaUtils.isObjectSchema(inputSchema)) {
-          this.handleError(
-            new Error(
-              `When path has parameters, input schema must be an object [${path.join(".")}]`
-            )
-          );
-          return void 0;
+      try {
+        const def = contract["~orpc"];
+        if (this.ignoreUndefinedPathProcedures && def.route?.path === void 0) {
+          return;
         }
-        const [matched, rest] = this.schemaUtils.separateObjectSchema(inputSchema, dynamic.map((v) => v.name));
-        inputSchema = rest;
-        return this.parametersBuilder.build("path", matched, {
-          example: def.inputExample,
+        const method = fallbackContractConfig2("defaultMethod", def.route?.method);
+        const httpPath = def.route?.path ? standardizeHTTPPath(def.route?.path) : `/${path.map(encodeURIComponent).join("/")}`;
+        const inputStructure = fallbackContractConfig2("defaultInputStructure", def.route?.inputStructure);
+        const outputStructure = fallbackContractConfig2("defaultOutputStructure", def.route?.outputStructure);
+        const { paramsSchema, querySchema, headersSchema, bodySchema } = this.inputStructureParser.parse(contract, inputStructure);
+        const { headersSchema: resHeadersSchema, bodySchema: resBodySchema } = this.outputStructureParser.parse(contract, outputStructure);
+        const params = paramsSchema ? this.parametersBuilder.build("path", paramsSchema, {
           required: true
-        });
-      })();
-      const query = (() => {
-        if (method !== "GET" || Object.keys(inputSchema).length === 0) {
-          return void 0;
-        }
-        if (this.schemaUtils.isAnySchema(inputSchema)) {
-          return void 0;
-        }
-        if (!this.schemaUtils.isObjectSchema(inputSchema)) {
-          this.handleError(
-            new Error(
-              `When method is GET, input schema must be an object [${path.join(".")}]`
-            )
-          );
-          return void 0;
+        }) : [];
+        const query = querySchema ? this.parametersBuilder.build("query", querySchema) : [];
+        const headers = headersSchema ? this.parametersBuilder.build("header", headersSchema) : [];
+        const parameters = [...params, ...query, ...headers];
+        const requestBody = bodySchema !== void 0 ? {
+          required: this.schemaUtils.isUndefinableSchema(bodySchema),
+          content: this.contentBuilder.build(bodySchema)
+        } : void 0;
+        const responses = {};
+        responses[fallbackContractConfig2("defaultSuccessStatus", def.route?.successStatus)] = {
+          description: fallbackContractConfig2("defaultSuccessDescription", def.route?.successDescription),
+          content: resBodySchema !== void 0 ? this.contentBuilder.build(resBodySchema, {
+            example: def.outputExample
+          }) : void 0,
+          headers: resHeadersSchema !== void 0 ? this.parametersBuilder.buildHeadersObject(resHeadersSchema, {
+            example: def.outputExample
+          }) : void 0
+        };
+        const errors = group(Object.entries(def.errorMap ?? {}).filter(([_, config]) => config).map(([code, config]) => ({
+          ...config,
+          code,
+          status: fallbackORPCErrorStatus(code, config?.status)
+        })), (error) => error.status);
+        for (const status in errors) {
+          const configs = errors[status];
+          if (!configs || configs.length === 0) {
+            continue;
+          }
+          const schemas = configs.map(({ data, code, message }) => {
+            const json = {
+              type: "object",
+              properties: {
+                defined: { const: true },
+                code: { const: code },
+                status: { const: Number(status) },
+                message: { type: "string", default: message },
+                data: {}
+              },
+              required: ["defined", "code", "status", "message"]
+            };
+            if (data) {
+              const dataJson = this.schemaConverter.convert(data, { strategy: "output" });
+              json.properties.data = dataJson;
+              if (!this.schemaUtils.isUndefinableSchema(dataJson)) {
+                json.required.push("data");
+              }
+            }
+            return json;
+          });
+          if (this.strictErrorResponses) {
+            schemas.push({
+              type: "object",
+              properties: {
+                defined: { const: false },
+                code: { type: "string" },
+                status: { type: "number" },
+                message: { type: "string" },
+                data: {}
+              },
+              required: ["defined", "code", "status", "message"]
+            });
+          }
+          const contentSchema = schemas.length === 1 ? schemas[0] : {
+            oneOf: schemas
+          };
+          responses[status] = {
+            description: status,
+            content: this.contentBuilder.build(contentSchema)
+          };
         }
-        return this.parametersBuilder.build("query", inputSchema, {
-          example: def.inputExample
-        });
-      })();
-      const parameters = [...params ?? [], ...query ?? []];
-      const requestBody = (() => {
-        if (method === "GET") {
-          return void 0;
+        if (this.considerMissingTagDefinitionAsError && def.route?.tags) {
+          const missingTag = def.route?.tags.find((tag) => !rootTags.includes(tag));
+          if (missingTag !== void 0) {
+            throw new OpenAPIError(
+              `Tag "${missingTag}" is missing definition. Please define it in OpenAPI root tags object`
+            );
+          }
         }
-        return {
-          required: this.schemaUtils.isUndefinableSchema(inputSchema),
-          content: this.contentBuilder.build(inputSchema, {
-            example: def.inputExample
-          })
+        const operation = {
+          summary: def.route?.summary,
+          description: def.route?.description,
+          deprecated: def.route?.deprecated,
+          tags: def.route?.tags ? [...def.route.tags] : void 0,
+          operationId: path.join("."),
+          parameters: parameters.length ? parameters : void 0,
+          requestBody,
+          responses
         };
-      })();
-      const successResponse = {
-        description: "OK",
-        content: this.contentBuilder.build(outputSchema, {
-          example: def.outputExample
-        })
-      };
-      if (this.options?.considerMissingTagDefinitionAsError && def.route?.tags) {
-        const missingTag = def.route?.tags.find((tag) => !rootTags.includes(tag));
-        if (missingTag !== void 0) {
-          this.handleError(
-            new Error(
-              `Tag "${missingTag}" is missing definition. Please define it in OpenAPI root tags object. [${path.join(".")}]`
-            )
-          );
+        builder.addPath(httpPath, {
+          [method.toLocaleLowerCase()]: operation
+        });
+      } catch (e) {
+        if (e instanceof OpenAPIError) {
+          const error = new OpenAPIError(`
+            Generate OpenAPI Error: ${e.message}
+            Happened at path: ${path.join(".")}
+          `, { cause: e });
+          if (this.errorHandlerStrategy === "throw") {
+            throw error;
+          }
+          if (this.errorHandlerStrategy === "log") {
+            console.error(error);
+          }
+        } else {
+          throw e;
         }
       }
-      const operation = {
-        summary: def.route?.summary,
-        description: def.route?.description,
-        deprecated: def.route?.deprecated,
-        tags: def.route?.tags ? [...def.route.tags] : void 0,
-        operationId: path.join("."),
-        parameters: parameters.length ? parameters : void 0,
-        requestBody,
-        responses: {
-          [def.route?.successStatus ?? 200]: successResponse
-        }
-      };
-      builder.addPath(httpPath, {
-        [method.toLocaleLowerCase()]: operation
-      });
     });
     return this.jsonSerializer.serialize(builder.getSpec());
   }
-  handleError(error) {
-    if (this.options?.throwOnError) {
-      throw error;
-    }
-    console.error(error);
-  }
 };
 export {
   CompositeSchemaConverter,

package/dist/next.js

@@ -0,0 +1,34 @@
+import {
+  OpenAPIServerHandler,
+  OpenAPIServerlessHandler
+} from "./chunk-7MA7YRRY.js";
+import {
+  CompositeSchemaCoercer,
+  InputStructureCompact,
+  InputStructureDetailed,
+  OpenAPIHandler,
+  OpenAPIPayloadCodec,
+  OpenAPIProcedureMatcher,
+  deserialize,
+  escapeSegment,
+  parsePath,
+  serialize,
+  stringifyPath
+} from "./chunk-BUMQYADN.js";
+import "./chunk-DSYVLQK3.js";
+export {
+  CompositeSchemaCoercer,
+  InputStructureCompact,
+  InputStructureDetailed,
+  OpenAPIHandler,
+  OpenAPIPayloadCodec,
+  OpenAPIProcedureMatcher,
+  OpenAPIServerHandler,
+  OpenAPIServerlessHandler,
+  deserialize,
+  escapeSegment,
+  parsePath,
+  serialize,
+  stringifyPath
+};
+//# sourceMappingURL=next.js.map

package/dist/node.js

@@ -0,0 +1,46 @@
+import {
+  OpenAPIHandler
+} from "./chunk-BUMQYADN.js";
+import "./chunk-DSYVLQK3.js";
+
+// src/adapters/node/openapi-handler.ts
+import { createRequest, sendResponse } from "@orpc/server/node";
+var OpenAPIHandler2 = class {
+  openapiFetchHandler;
+  constructor(hono, router, options) {
+    this.openapiFetchHandler = new OpenAPIHandler(hono, router, options);
+  }
+  async handle(req, res, ...[options]) {
+    const request = createRequest(req, res);
+    const castedOptions = options ?? {};
+    const result = await this.openapiFetchHandler.handle(request, castedOptions);
+    if (result.matched === false) {
+      return { matched: false };
+    }
+    await options?.beforeSend?.(result.response, castedOptions.context);
+    await sendResponse(res, result.response);
+    return { matched: true };
+  }
+};
+
+// src/adapters/node/openapi-handler-server.ts
+import { TrieRouter } from "hono/router/trie-router";
+var OpenAPIServerHandler = class extends OpenAPIHandler2 {
+  constructor(router, options) {
+    super(new TrieRouter(), router, options);
+  }
+};
+
+// src/adapters/node/openapi-handler-serverless.ts
+import { LinearRouter } from "hono/router/linear-router";
+var OpenAPIServerlessHandler = class extends OpenAPIHandler2 {
+  constructor(router, options) {
+    super(new LinearRouter(), router, options);
+  }
+};
+export {
+  OpenAPIHandler2 as OpenAPIHandler,
+  OpenAPIServerHandler,
+  OpenAPIServerlessHandler
+};
+//# sourceMappingURL=node.js.map

package/dist/src/{fetch → adapters/fetch}/index.d.ts

@@ -1,6 +1,6 @@
 export * from './bracket-notation';
-export * from './input-builder-full';
-export * from './input-builder-simple';
+export * from './input-structure-compact';
+export * from './input-structure-detailed';
 export * from './openapi-handler';
 export * from './openapi-handler-server';
 export * from './openapi-handler-serverless';

package/dist/src/adapters/fetch/input-structure-compact.d.ts

@@ -0,0 +1,6 @@
+import type { Params } from 'hono/router';
+export declare class InputStructureCompact {
+    build(params: Params, payload: unknown): unknown;
+}
+export type PublicInputStructureCompact = Pick<InputStructureCompact, keyof InputStructureCompact>;
+//# sourceMappingURL=input-structure-compact.d.ts.map

package/dist/src/{fetch/input-builder-full.d.ts → adapters/fetch/input-structure-detailed.d.ts}

@@ -1,5 +1,5 @@
 import type { Params } from 'hono/router';
-export declare class InputBuilderFull {
+export declare class InputStructureDetailed {
     build(params: Params, query: unknown, headers: unknown, body: unknown): {
         params: Params;
         query: unknown;
@@ -7,5 +7,5 @@ export declare class InputBuilderFull {
         body: unknown;
     };
 }
-export type PublicInputBuilderFull = Pick<InputBuilderFull, keyof InputBuilderFull>;
-//# sourceMappingURL=input-builder-full.d.ts.map
+export type PublicInputStructureDetailed = Pick<InputStructureDetailed, keyof InputStructureDetailed>;
+//# sourceMappingURL=input-structure-detailed.d.ts.map

package/dist/src/{fetch → adapters/fetch}/openapi-handler.d.ts

@@ -1,30 +1,32 @@
-import type { ConditionalFetchHandler, FetchOptions } from '@orpc/server/fetch';
-import type { PublicInputBuilderSimple } from './input-builder-simple';
-import { type Context, type Router, type WithSignal } from '@orpc/server';
+import type { Context, Router, WithSignal } from '@orpc/server';
+import type { FetchHandler, FetchHandleRest, FetchHandleResult } from '@orpc/server/fetch';
+import type { PublicInputStructureCompact } from './input-structure-compact';
 import { type Hooks } from '@orpc/shared';
-import { type PublicJSONSerializer } from '../json-serializer';
-import { type PublicInputBuilderFull } from './input-builder-full';
+import { type PublicJSONSerializer } from '../../json-serializer';
+import { type PublicInputStructureDetailed } from './input-structure-detailed';
 import { type PublicOpenAPIPayloadCodec } from './openapi-payload-codec';
 import { type Hono, type PublicOpenAPIProcedureMatcher } from './openapi-procedure-matcher';
 import { type SchemaCoercer } from './schema-coercer';
-export type OpenAPIHandlerOptions<T extends Context> = Hooks<Request, Response, T, WithSignal> & {
+export type OpenAPIHandlerOptions<T extends Context> = Hooks<Request, FetchHandleResult, T, WithSignal> & {
     jsonSerializer?: PublicJSONSerializer;
     procedureMatcher?: PublicOpenAPIProcedureMatcher;
     payloadCodec?: PublicOpenAPIPayloadCodec;
-    inputBuilderSimple?: PublicInputBuilderSimple;
-    inputBuilderFull?: PublicInputBuilderFull;
+    inputBuilderSimple?: PublicInputStructureCompact;
+    inputBuilderFull?: PublicInputStructureDetailed;
     schemaCoercers?: SchemaCoercer[];
 };
-export declare class OpenAPIHandler<T extends Context> implements ConditionalFetchHandler<T> {
+export declare class OpenAPIHandler<T extends Context> implements FetchHandler<T> {
     private readonly options?;
     private readonly procedureMatcher;
     private readonly payloadCodec;
-    private readonly inputBuilderSimple;
-    private readonly inputBuilderFull;
+    private readonly inputStructureCompact;
+    private readonly inputStructureDetailed;
     private readonly compositeSchemaCoercer;
     constructor(hono: Hono, router: Router<T, any>, options?: NoInfer<OpenAPIHandlerOptions<T>> | undefined);
-    condition(request: Request): boolean;
-    fetch(request: Request, ...[options]: [options: FetchOptions<T>] | (undefined extends T ? [] : never)): Promise<Response>;
+    handle(request: Request, ...[options]: FetchHandleRest<T>): Promise<FetchHandleResult>;
+    private decodeInput;
+    private encodeOutput;
+    private assertDetailedOutput;
     private convertToORPCError;
 }
 //# sourceMappingURL=openapi-handler.d.ts.map

package/dist/src/{fetch → adapters/fetch}/openapi-payload-codec.d.ts

@@ -1,8 +1,8 @@
-import type { PublicJSONSerializer } from '../json-serializer';
+import type { PublicJSONSerializer } from '../../json-serializer';
 export declare class OpenAPIPayloadCodec {
     private readonly jsonSerializer;
     constructor(jsonSerializer: PublicJSONSerializer);
-    encode(payload: unknown, accept?: string): {
+    encode(payload: unknown, accept: string | undefined): {
         body: FormData | Blob | string | undefined;
         headers?: Headers;
     };

package/dist/src/adapters/hono/index.d.ts

@@ -0,0 +1,2 @@
+export * from '../fetch';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/adapters/next/index.d.ts

@@ -0,0 +1,2 @@
+export * from '../fetch';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/adapters/node/index.d.ts

@@ -0,0 +1,5 @@
+export * from './openapi-handler';
+export * from './openapi-handler-server';
+export * from './openapi-handler-serverless';
+export * from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/adapters/node/openapi-handler-server.d.ts

@@ -0,0 +1,7 @@
+import type { Context, Router } from '@orpc/server';
+import type { OpenAPIHandlerOptions } from '../fetch/openapi-handler';
+import { OpenAPIHandler } from './openapi-handler';
+export declare class OpenAPIServerHandler<T extends Context> extends OpenAPIHandler<T> {
+    constructor(router: Router<T, any>, options?: NoInfer<OpenAPIHandlerOptions<T>>);
+}
+//# sourceMappingURL=openapi-handler-server.d.ts.map

package/dist/src/adapters/node/openapi-handler-serverless.d.ts

@@ -0,0 +1,7 @@
+import type { Context, Router } from '@orpc/server';
+import type { OpenAPIHandlerOptions } from '../fetch/openapi-handler';
+import { OpenAPIHandler } from './openapi-handler';
+export declare class OpenAPIServerlessHandler<T extends Context> extends OpenAPIHandler<T> {
+    constructor(router: Router<T, any>, options?: NoInfer<OpenAPIHandlerOptions<T>>);
+}
+//# sourceMappingURL=openapi-handler-serverless.d.ts.map