@orpc/openapi 0.0.0-next.9588d75 → 0.0.0-next.9914009

package/dist/next.js

@@ -0,0 +1,34 @@
+import {
+  OpenAPIServerHandler,
+  OpenAPIServerlessHandler
+} from "./chunk-EVWWILO6.js";
+import {
+  CompositeSchemaCoercer,
+  InputStructureCompact,
+  InputStructureDetailed,
+  OpenAPIHandler,
+  OpenAPIPayloadCodec,
+  OpenAPIProcedureMatcher,
+  deserialize,
+  escapeSegment,
+  parsePath,
+  serialize,
+  stringifyPath
+} from "./chunk-X2HG5K4J.js";
+import "./chunk-KNYXLM77.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-X2HG5K4J.js";
+import "./chunk-KNYXLM77.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/adapters/fetch/openapi-handler.d.ts

@@ -0,0 +1,32 @@
+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 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, FetchHandleResult, T, WithSignal> & {
+    jsonSerializer?: PublicJSONSerializer;
+    procedureMatcher?: PublicOpenAPIProcedureMatcher;
+    payloadCodec?: PublicOpenAPIPayloadCodec;
+    inputBuilderSimple?: PublicInputStructureCompact;
+    inputBuilderFull?: PublicInputStructureDetailed;
+    schemaCoercers?: SchemaCoercer[];
+};
+export declare class OpenAPIHandler<T extends Context> implements FetchHandler<T> {
+    private readonly options?;
+    private readonly procedureMatcher;
+    private readonly payloadCodec;
+    private readonly inputStructureCompact;
+    private readonly inputStructureDetailed;
+    private readonly compositeSchemaCoercer;
+    constructor(hono: Hono, router: Router<T, any>, options?: NoInfer<OpenAPIHandlerOptions<T>> | undefined);
+    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,12 +1,14 @@
+import type { PublicJSONSerializer } from '../../json-serializer';
 export declare class OpenAPIPayloadCodec {
-    encode(payload: unknown, accept?: string): {
+    private readonly jsonSerializer;
+    constructor(jsonSerializer: PublicJSONSerializer);
+    encode(payload: unknown, accept: string | undefined): {
         body: FormData | Blob | string | undefined;
         headers?: Headers;
     };
     private encodeAsJSON;
     private encodeAsFormData;
     private encodeAsURLSearchParams;
-    serialize(payload: unknown): unknown;
     decode(re: Request | Response | Headers | URLSearchParams | FormData): Promise<unknown>;
 }
 export type PublicOpenAPIPayloadCodec = Pick<OpenAPIPayloadCodec, keyof OpenAPIPayloadCodec>;

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

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

@@ -0,0 +1,11 @@
+import type { Context, Router } from '@orpc/server';
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { OpenAPIHandlerOptions } from '../fetch/openapi-handler';
+import type { Hono } from '../fetch/openapi-procedure-matcher';
+import { type RequestHandler, type RequestHandleRest, type RequestHandleResult } from '@orpc/server/node';
+export declare class OpenAPIHandler<T extends Context> implements RequestHandler<T> {
+    private readonly openapiFetchHandler;
+    constructor(hono: Hono, router: Router<T, any>, options?: NoInfer<OpenAPIHandlerOptions<T>>);
+    handle(req: IncomingMessage, res: ServerResponse, ...[options]: RequestHandleRest<T>): Promise<RequestHandleResult>;
+}
+//# sourceMappingURL=openapi-handler.d.ts.map

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/src/index.d.ts

@@ -1,3 +1,12 @@
 /** unnoq */
-export * from './generator';
+export * from './json-serializer';
+export * from './openapi';
+export * from './openapi-content-builder';
+export * from './openapi-generator';
+export * from './openapi-parameters-builder';
+export * from './openapi-path-parser';
+export * from './schema';
+export * from './schema-converter';
+export * from './schema-utils';
+export * from './utils';
 //# sourceMappingURL=index.d.ts.map

package/dist/src/json-serializer.d.ts

@@ -0,0 +1,5 @@
+export declare class JSONSerializer {
+    serialize(payload: unknown): unknown;
+}
+export type PublicJSONSerializer = Pick<JSONSerializer, keyof JSONSerializer>;
+//# sourceMappingURL=json-serializer.d.ts.map

package/dist/src/openapi-content-builder.d.ts

@@ -0,0 +1,10 @@
+import type { OpenAPI } from './openapi';
+import type { JSONSchema } from './schema';
+import type { PublicSchemaUtils } from './schema-utils';
+export declare class OpenAPIContentBuilder {
+    private readonly schemaUtils;
+    constructor(schemaUtils: PublicSchemaUtils);
+    build(jsonSchema: JSONSchema.JSONSchema, options?: Partial<OpenAPI.MediaTypeObject>): OpenAPI.ContentObject;
+}
+export type PublicOpenAPIContentBuilder = Pick<OpenAPIContentBuilder, keyof OpenAPIContentBuilder>;
+//# sourceMappingURL=openapi-content-builder.d.ts.map

package/dist/src/openapi-error.d.ts

@@ -0,0 +1,3 @@
+export declare class OpenAPIError extends Error {
+}
+//# sourceMappingURL=openapi-error.d.ts.map

package/dist/src/openapi-generator.d.ts

@@ -0,0 +1,67 @@
+import type { ANY_ROUTER } from '@orpc/server';
+import type { PublicOpenAPIInputStructureParser } from './openapi-input-structure-parser';
+import type { PublicOpenAPIOutputStructureParser } from './openapi-output-structure-parser';
+import type { PublicOpenAPIPathParser } from './openapi-path-parser';
+import type { SchemaConverter } from './schema-converter';
+import { type ContractRouter } from '@orpc/contract';
+import { type PublicJSONSerializer } from './json-serializer';
+import { type OpenAPI } from './openapi';
+import { type PublicOpenAPIContentBuilder } from './openapi-content-builder';
+import { type PublicOpenAPIParametersBuilder } from './openapi-parameters-builder';
+import { type PublicSchemaUtils } from './schema-utils';
+type ErrorHandlerStrategy = 'throw' | 'log' | 'ignore';
+export interface OpenAPIGeneratorOptions {
+    contentBuilder?: PublicOpenAPIContentBuilder;
+    parametersBuilder?: PublicOpenAPIParametersBuilder;
+    schemaConverters?: SchemaConverter[];
+    schemaUtils?: PublicSchemaUtils;
+    jsonSerializer?: PublicJSONSerializer;
+    pathParser?: PublicOpenAPIPathParser;
+    inputStructureParser?: PublicOpenAPIInputStructureParser;
+    outputStructureParser?: PublicOpenAPIOutputStructureParser;
+    /**
+     * Throw error when you missing define tag definition on OpenAPI root tags
+     *
+     * Example: if procedure has tags ['foo', 'bar'], and OpenAPI root tags is ['foo'], then error will be thrown
+     * Because OpenAPI root tags is missing 'bar' tag
+     *
+     * @default false
+     */
+    considerMissingTagDefinitionAsError?: boolean;
+    /**
+     * Weather ignore procedures that has no path defined.
+     *
+     * @default false
+     */
+    ignoreUndefinedPathProcedures?: boolean;
+    /**
+     * What to do when we found an error with our router
+     *
+     * @default 'throw'
+     */
+    errorHandlerStrategy?: ErrorHandlerStrategy;
+    /**
+     * Strict error response
+     *
+     * @default true
+     */
+    strictErrorResponses?: boolean;
+}
+export declare class OpenAPIGenerator {
+    private readonly contentBuilder;
+    private readonly parametersBuilder;
+    private readonly schemaConverter;
+    private readonly schemaUtils;
+    private readonly jsonSerializer;
+    private readonly pathParser;
+    private readonly inputStructureParser;
+    private readonly outputStructureParser;
+    private readonly errorHandlerStrategy;
+    private readonly ignoreUndefinedPathProcedures;
+    private readonly considerMissingTagDefinitionAsError;
+    private readonly strictErrorResponses;
+    constructor(options?: OpenAPIGeneratorOptions);
+    generate(router: ContractRouter | ANY_ROUTER, doc: Omit<OpenAPI.OpenAPIObject, 'openapi'>): Promise<OpenAPI.OpenAPIObject>;
+}
+export {};
+//# sourceMappingURL=openapi-generator.d.ts.map

package/dist/src/openapi-input-structure-parser.d.ts

@@ -0,0 +1,22 @@
+import type { PublicOpenAPIPathParser } from './openapi-path-parser';
+import type { JSONSchema, ObjectSchema } from './schema';
+import type { SchemaConverter } from './schema-converter';
+import type { PublicSchemaUtils } from './schema-utils';
+import { type ANY_CONTRACT_PROCEDURE } from '@orpc/contract';
+export interface OpenAPIInputStructureParseResult {
+    paramsSchema: ObjectSchema | undefined;
+    querySchema: ObjectSchema | undefined;
+    headersSchema: ObjectSchema | undefined;
+    bodySchema: JSONSchema.JSONSchema | undefined;
+}
+export declare class OpenAPIInputStructureParser {
+    private readonly schemaConverter;
+    private readonly schemaUtils;
+    private readonly pathParser;
+    constructor(schemaConverter: SchemaConverter, schemaUtils: PublicSchemaUtils, pathParser: PublicOpenAPIPathParser);
+    parse(contract: ANY_CONTRACT_PROCEDURE, structure: 'compact' | 'detailed'): OpenAPIInputStructureParseResult;
+    private parseDetailedSchema;
+    private parseCompactSchema;
+}
+export type PublicOpenAPIInputStructureParser = Pick<OpenAPIInputStructureParser, keyof OpenAPIInputStructureParser>;
+//# sourceMappingURL=openapi-input-structure-parser.d.ts.map

package/dist/src/openapi-output-structure-parser.d.ts

@@ -0,0 +1,18 @@
+import type { ANY_CONTRACT_PROCEDURE } from '@orpc/contract';
+import type { JSONSchema, ObjectSchema } from './schema';
+import type { SchemaConverter } from './schema-converter';
+import type { PublicSchemaUtils } from './schema-utils';
+export interface OpenAPIOutputStructureParseResult {
+    headersSchema: ObjectSchema | undefined;
+    bodySchema: JSONSchema.JSONSchema | undefined;
+}
+export declare class OpenAPIOutputStructureParser {
+    private readonly schemaConverter;
+    private readonly schemaUtils;
+    constructor(schemaConverter: SchemaConverter, schemaUtils: PublicSchemaUtils);
+    parse(contract: ANY_CONTRACT_PROCEDURE, structure: 'compact' | 'detailed'): OpenAPIOutputStructureParseResult;
+    private parseDetailedSchema;
+    private parseCompactSchema;
+}
+export type PublicOpenAPIOutputStructureParser = Pick<OpenAPIOutputStructureParser, keyof OpenAPIOutputStructureParser>;
+//# sourceMappingURL=openapi-output-structure-parser.d.ts.map

package/dist/src/openapi-parameters-builder.d.ts

@@ -0,0 +1,12 @@
+import type { OpenAPI } from './openapi';
+import type { JSONSchema } from './schema';
+export declare class OpenAPIParametersBuilder {
+    build(paramIn: OpenAPI.ParameterObject['in'], jsonSchema: JSONSchema.JSONSchema & {
+        type: 'object';
+    } & object, options?: Pick<OpenAPI.ParameterObject, 'example' | 'style' | 'required'>): OpenAPI.ParameterObject[];
+    buildHeadersObject(jsonSchema: JSONSchema.JSONSchema & {
+        type: 'object';
+    } & object, options?: Pick<OpenAPI.ParameterObject, 'example' | 'style' | 'required'>): OpenAPI.HeadersObject;
+}
+export type PublicOpenAPIParametersBuilder = Pick<OpenAPIParametersBuilder, keyof OpenAPIParametersBuilder>;
+//# sourceMappingURL=openapi-parameters-builder.d.ts.map

package/dist/src/openapi-path-parser.d.ts

@@ -0,0 +1,8 @@
+export declare class OpenAPIPathParser {
+    parseDynamicParams(path: string): {
+        name: string;
+        raw: string;
+    }[];
+}
+export type PublicOpenAPIPathParser = Pick<OpenAPIPathParser, keyof OpenAPIPathParser>;
+//# sourceMappingURL=openapi-path-parser.d.ts.map

package/dist/src/openapi.d.ts

@@ -0,0 +1,3 @@
+export { OpenApiBuilder } from 'openapi3-ts/oas31';
+export type * as OpenAPI from 'openapi3-ts/oas31';
+//# sourceMappingURL=openapi.d.ts.map

package/dist/src/schema-converter.d.ts

@@ -0,0 +1,16 @@
+import type { Schema } from '@orpc/contract';
+import type { JSONSchema } from './schema';
+export interface SchemaConvertOptions {
+    strategy: 'input' | 'output';
+}
+export interface SchemaConverter {
+    condition: (schema: Schema, options: SchemaConvertOptions) => boolean;
+    convert: (schema: Schema, options: SchemaConvertOptions) => JSONSchema.JSONSchema;
+}
+export declare class CompositeSchemaConverter implements SchemaConverter {
+    private readonly converters;
+    constructor(converters: SchemaConverter[]);
+    condition(): boolean;
+    convert(schema: Schema, options: SchemaConvertOptions): JSONSchema.JSONSchema;
+}
+//# sourceMappingURL=schema-converter.d.ts.map

package/dist/src/schema-utils.d.ts

@@ -0,0 +1,11 @@
+import { type FileSchema, type JSONSchema, type ObjectSchema } from './schema';
+export declare class SchemaUtils {
+    isFileSchema(schema: JSONSchema.JSONSchema): schema is FileSchema;
+    isObjectSchema(schema: JSONSchema.JSONSchema): schema is ObjectSchema;
+    isAnySchema(schema: JSONSchema.JSONSchema): boolean;
+    isUndefinableSchema(schema: JSONSchema.JSONSchema): boolean;
+    separateObjectSchema(schema: ObjectSchema, separatedProperties: string[]): [matched: ObjectSchema, rest: ObjectSchema];
+    filterSchemaBranches(schema: JSONSchema.JSONSchema, check: (schema: JSONSchema.JSONSchema) => boolean, matches?: JSONSchema.JSONSchema[]): [matches: JSONSchema.JSONSchema[], rest: JSONSchema.JSONSchema | undefined];
+}
+export type PublicSchemaUtils = Pick<SchemaUtils, keyof SchemaUtils>;
+//# sourceMappingURL=schema-utils.d.ts.map

package/dist/src/schema.d.ts

@@ -0,0 +1,12 @@
+import * as JSONSchema from 'json-schema-typed/draft-2020-12';
+export { Format as JSONSchemaFormat } from 'json-schema-typed/draft-2020-12';
+export { JSONSchema };
+export type ObjectSchema = JSONSchema.JSONSchema & {
+    type: 'object';
+} & object;
+export type FileSchema = JSONSchema.JSONSchema & {
+    type: 'string';
+    contentMediaType: string;
+} & object;
+export declare const NON_LOGIC_KEYWORDS: string[];
+//# sourceMappingURL=schema.d.ts.map

package/dist/src/utils.d.ts

@@ -13,5 +13,6 @@ export interface EachContractLeafResultItem {
     path: string[];
 }
 export declare function forEachContractProcedure(options: EachLeafOptions, callback: (options: EachLeafCallbackOptions) => void, result?: EachContractLeafResultItem[], isCurrentRouterContract?: boolean): EachContractLeafResultItem[];
+export declare function forEachAllContractProcedure(router: ContractRouter | ANY_ROUTER, callback: (options: EachLeafCallbackOptions) => void): Promise<void>;
 export declare function standardizeHTTPPath(path: HTTPPath): HTTPPath;
 //# sourceMappingURL=utils.d.ts.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/openapi",
   "type": "module",
-  "version": "0.0.0-next.9588d75",
+  "version": "0.0.0-next.9914009",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -20,10 +20,25 @@
       "default": "./dist/index.js"
     },
     "./fetch": {
-      "types": "./dist/src/fetch/index.d.ts",
+      "types": "./dist/src/adapters/fetch/index.d.ts",
       "import": "./dist/fetch.js",
       "default": "./dist/fetch.js"
     },
+    "./hono": {
+      "types": "./dist/src/adapters/hono/index.d.ts",
+      "import": "./dist/hono.js",
+      "default": "./dist/hono.js"
+    },
+    "./next": {
+      "types": "./dist/src/adapters/next/index.d.ts",
+      "import": "./dist/next.js",
+      "default": "./dist/next.js"
+    },
+    "./node": {
+      "types": "./dist/src/adapters/node/index.d.ts",
+      "import": "./dist/node.js",
+      "default": "./dist/node.js"
+    },
     "./🔒/*": {
       "types": "./dist/src/*.d.ts"
     }
@@ -43,16 +58,16 @@
     "json-schema-typed": "^8.0.1",
     "openapi3-ts": "^4.4.0",
     "wildcard-match": "^5.1.3",
-    "@orpc/contract": "0.0.0-next.9588d75",
-    "@orpc/shared": "0.0.0-next.9588d75",
-    "@orpc/server": "0.0.0-next.9588d75"
+    "@orpc/server": "0.0.0-next.9914009",
+    "@orpc/shared": "0.0.0-next.9914009",
+    "@orpc/contract": "0.0.0-next.9914009"
   },
   "devDependencies": {
     "@readme/openapi-parser": "^2.6.0",
     "zod": "^3.24.1"
   },
   "scripts": {
-    "build": "tsup --clean --sourcemap --entry.index=src/index.ts --entry.fetch=src/fetch/index.ts --format=esm --onSuccess='tsc -b --noCheck'",
+    "build": "tsup --onSuccess='tsc -b --noCheck'",
     "build:watch": "pnpm run build --watch",
     "type:check": "tsc -b"
   }

package/dist/src/fetch/input-builder-simple.d.ts

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

package/dist/src/fetch/openapi-handler.d.ts

@@ -1,28 +0,0 @@
-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 Hooks } from '@orpc/shared';
-import { type PublicInputBuilderFull } from './input-builder-full';
-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> & {
-    procedureMatcher?: PublicOpenAPIProcedureMatcher;
-    payloadCodec?: PublicOpenAPIPayloadCodec;
-    inputBuilderSimple?: PublicInputBuilderSimple;
-    inputBuilderFull?: PublicInputBuilderFull;
-    schemaCoercers?: SchemaCoercer[];
-};
-export declare class OpenAPIHandler<T extends Context> implements ConditionalFetchHandler<T> {
-    private readonly options?;
-    private readonly procedureMatcher;
-    private readonly payloadCodec;
-    private readonly inputBuilderSimple;
-    private readonly inputBuilderFull;
-    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>;
-    private convertToORPCError;
-}
-//# sourceMappingURL=openapi-handler.d.ts.map

package/dist/src/generator.d.ts

@@ -1,26 +0,0 @@
-import type { PublicOpenAPIPayloadCodec } from './fetch';
-import { type ContractRouter } from '@orpc/contract';
-import { type ANY_ROUTER } from '@orpc/server';
-import { type OpenAPIObject } from 'openapi3-ts/oas31';
-export interface GenerateOpenAPIOptions {
-    /**
-     * Throw error when you missing define tag definition on OpenAPI root tags
-     *
-     * Example: if procedure has tags ['foo', 'bar'], and OpenAPI root tags is ['foo'], then error will be thrown
-     * Because OpenAPI root tags is missing 'bar' tag
-     *
-     * @default false
-     */
-    throwOnMissingTagDefinition?: boolean;
-    /**
-     * Weather ignore procedures that has no path defined.
-     *
-     * @default false
-     */
-    ignoreUndefinedPathProcedures?: boolean;
-    payloadCodec?: PublicOpenAPIPayloadCodec;
-}
-export declare function generateOpenAPI(opts: {
-    router: ContractRouter | ANY_ROUTER;
-} & Omit<OpenAPIObject, 'openapi'>, options?: GenerateOpenAPIOptions): Promise<OpenAPIObject>;
-//# sourceMappingURL=generator.d.ts.map

package/dist/src/zod-to-json-schema.d.ts

@@ -1,43 +0,0 @@
-import type { StandardSchemaV1 } from '@standard-schema/spec';
-import { type JSONSchema } from 'json-schema-typed/draft-2020-12';
-export declare const NON_LOGIC_KEYWORDS: ("$anchor" | "$comment" | "$defs" | "$dynamicAnchor" | "$dynamicRef" | "$id" | "$schema" | "$vocabulary" | "contentEncoding" | "contentMediaType" | "default" | "definitions" | "deprecated" | "description" | "examples" | "format" | "readOnly" | "title" | "writeOnly")[];
-export declare const UNSUPPORTED_JSON_SCHEMA: {
-    not: {};
-};
-export declare const UNDEFINED_JSON_SCHEMA: {
-    const: string;
-};
-export interface ZodToJsonSchemaOptions {
-    /**
-     * Max depth of lazy type, if it exceeds.
-     *
-     * Used `{}` when reach max depth
-     *
-     * @default 5
-     */
-    maxLazyDepth?: number;
-    /**
-     * The length used to track the depth of lazy type
-     *
-     * @internal
-     */
-    lazyDepth?: number;
-    /**
-     * The expected json schema for input or output zod schema
-     *
-     * @default input
-     */
-    mode?: 'input' | 'output';
-    /**
-     * Track if current level schema is handled custom json schema to prevent recursive
-     *
-     * @internal
-     */
-    isHandledCustomJSONSchema?: boolean;
-}
-export declare function zodToJsonSchema(schema: StandardSchemaV1, options?: ZodToJsonSchemaOptions): Exclude<JSONSchema, boolean>;
-export declare function extractJSONSchema(schema: JSONSchema, check: (schema: JSONSchema) => boolean, matches?: JSONSchema[]): {
-    schema: JSONSchema | undefined;
-    matches: JSONSchema[];
-};
-//# sourceMappingURL=zod-to-json-schema.d.ts.map