@orpc/openapi 0.0.0-next.fea68c1 → 0.0.0-next.ff2168f

package/dist/index.d.ts

@@ -0,0 +1,116 @@
+import { OpenAPI, AnyContractProcedure } from '@orpc/contract';
+export { OpenAPI } from '@orpc/contract';
+export { e as CompositeSchemaConverter, C as ConditionalSchemaConverter, b as OpenAPIGenerator, a as OpenAPIGeneratorGenerateOptions, O as OpenAPIGeneratorOptions, c as SchemaConvertOptions, d as SchemaConverter, S as SchemaConverterComponent } from './shared/openapi.BGy4N6eR.js';
+import { HTTPPath, HTTPMethod } from '@orpc/client';
+import { JSONSchema } from 'json-schema-typed/draft-2020-12';
+export { JSONSchema, ContentEncoding as JSONSchemaContentEncoding, Format as JSONSchemaFormat, TypeName as JSONSchemaTypeName } from 'json-schema-typed/draft-2020-12';
+import { JsonifiedClient } from '@orpc/openapi-client';
+import { AnyRouter, ClientContext, Lazyable, CreateProcedureClientOptions, InferRouterInitialContext, Schema, ErrorMap, Meta, RouterClient } from '@orpc/server';
+import { MaybeOptionalOptions } from '@orpc/shared';
+import '@orpc/openapi-client/standard';
+
+type OverrideOperationValue = Partial<OpenAPI.OperationObject> | ((current: OpenAPI.OperationObject, procedure: AnyContractProcedure) => OpenAPI.OperationObject);
+/**
+ * Customize The Operation Object by proxy an error map item or a middleware.
+ *
+ * @see {@link https://orpc.dev/docs/openapi/openapi-specification#customizing-operation-objects Customizing Operation Objects Docs}
+ */
+declare function customOpenAPIOperation<T extends object>(o: T, extend: OverrideOperationValue): T;
+declare function getCustomOpenAPIOperation(o: object): OverrideOperationValue | undefined;
+declare function applyCustomOpenAPIOperation(operation: OpenAPI.OperationObject, contract: AnyContractProcedure): OpenAPI.OperationObject;
+
+/**
+ * @internal
+ */
+type ObjectSchema = JSONSchema & {
+    type: 'object';
+} & object;
+/**
+ * @internal
+ */
+type FileSchema = JSONSchema & {
+    type: 'string';
+    contentMediaType: string;
+} & object;
+/**
+ * @internal
+ */
+declare const LOGIC_KEYWORDS: string[];
+
+/**
+ * @internal
+ */
+declare function toOpenAPIPath(path: HTTPPath): string;
+/**
+ * @internal
+ */
+declare function toOpenAPIMethod(method: HTTPMethod): Lowercase<HTTPMethod>;
+/**
+ * @internal
+ */
+declare function toOpenAPIContent(schema: JSONSchema): Record<string, OpenAPI.MediaTypeObject>;
+/**
+ * @internal
+ */
+declare function toOpenAPIEventIteratorContent([yieldsRequired, yieldsSchema]: [boolean, JSONSchema], [returnsRequired, returnsSchema]: [boolean, JSONSchema]): Record<string, OpenAPI.MediaTypeObject>;
+/**
+ * @internal
+ */
+declare function toOpenAPIParameters(schema: ObjectSchema, parameterIn: 'path' | 'query' | 'header' | 'cookie'): OpenAPI.ParameterObject[];
+/**
+ * @internal
+ */
+declare function checkParamsSchema(schema: ObjectSchema, params: string[]): boolean;
+/**
+ * @internal
+ */
+declare function toOpenAPISchema(schema: JSONSchema): OpenAPI.SchemaObject & object;
+declare function resolveOpenAPIJsonSchemaRef(doc: OpenAPI.Document, schema: JSONSchema): JSONSchema;
+/**
+ * Simplifies composed object JSON Schemas (using anyOf, oneOf, allOf) by flattening nested compositions
+ *
+ * @warning The result is looser than the original schema and may not fully validate the same data.
+ */
+declare function simplifyComposedObjectJsonSchemasAndRefs(schema: JSONSchema, doc?: OpenAPI.Document): JSONSchema;
+
+declare function createJsonifiedRouterClient<T extends AnyRouter, TClientContext extends ClientContext>(router: Lazyable<T | undefined>, ...rest: MaybeOptionalOptions<CreateProcedureClientOptions<InferRouterInitialContext<T>, Schema<unknown, unknown>, ErrorMap, Meta, TClientContext>>): JsonifiedClient<RouterClient<T, TClientContext>>;
+
+/**
+ *@internal
+ */
+declare function isFileSchema(schema: JSONSchema): schema is FileSchema;
+/**
+ * @internal
+ */
+declare function isObjectSchema(schema: JSONSchema): schema is ObjectSchema;
+/**
+ * @internal
+ */
+declare function isAnySchema(schema: JSONSchema): boolean;
+/**
+ * @internal
+ */
+declare function separateObjectSchema(schema: ObjectSchema, separatedProperties: string[]): [matched: ObjectSchema, rest: ObjectSchema];
+/**
+ * @internal
+ */
+declare function filterSchemaBranches(schema: JSONSchema, check: (schema: JSONSchema) => boolean, matches?: JSONSchema[]): [matches: JSONSchema[], rest: JSONSchema | undefined];
+declare function applySchemaOptionality(required: boolean, schema: JSONSchema): JSONSchema;
+/**
+ * Takes a JSON schema and, if it's primarily a union type (anyOf, oneOf),
+ * recursively expands it into an array of its constituent, non-union base schemas.
+ * If the schema is not a simple union or is a base type, it's returned as a single-element array.
+ */
+declare function expandUnionSchema(schema: JSONSchema): JSONSchema[];
+declare function expandArrayableSchema(schema: JSONSchema): undefined | [items: JSONSchema, array: JSONSchema & {
+    type: 'array';
+    items?: JSONSchema;
+}];
+declare function isPrimitiveSchema(schema: JSONSchema): boolean;
+
+declare const oo: {
+    spec: typeof customOpenAPIOperation;
+};
+
+export { LOGIC_KEYWORDS, applyCustomOpenAPIOperation, applySchemaOptionality, checkParamsSchema, createJsonifiedRouterClient, customOpenAPIOperation, expandArrayableSchema, expandUnionSchema, filterSchemaBranches, getCustomOpenAPIOperation, isAnySchema, isFileSchema, isObjectSchema, isPrimitiveSchema, oo, resolveOpenAPIJsonSchemaRef, separateObjectSchema, simplifyComposedObjectJsonSchemasAndRefs, toOpenAPIContent, toOpenAPIEventIteratorContent, toOpenAPIMethod, toOpenAPIParameters, toOpenAPIPath, toOpenAPISchema };
+export type { FileSchema, ObjectSchema, OverrideOperationValue };

package/dist/index.mjs

@@ -0,0 +1,41 @@
+import { c as customOpenAPIOperation } from './shared/openapi.CoREqFh3.mjs';
+export { C as CompositeSchemaConverter, L as LOGIC_KEYWORDS, O as OpenAPIGenerator, a as applyCustomOpenAPIOperation, o as applySchemaOptionality, h as checkParamsSchema, q as expandArrayableSchema, p as expandUnionSchema, n as filterSchemaBranches, g as getCustomOpenAPIOperation, l as isAnySchema, j as isFileSchema, k as isObjectSchema, u as isPrimitiveSchema, r as resolveOpenAPIJsonSchemaRef, m as separateObjectSchema, s as simplifyComposedObjectJsonSchemasAndRefs, d as toOpenAPIContent, e as toOpenAPIEventIteratorContent, b as toOpenAPIMethod, f as toOpenAPIParameters, t as toOpenAPIPath, i as toOpenAPISchema } from './shared/openapi.CoREqFh3.mjs';
+import { createORPCErrorFromJson } from '@orpc/client';
+import { StandardOpenAPISerializer, StandardOpenAPIJsonSerializer, StandardBracketNotationSerializer } from '@orpc/openapi-client/standard';
+import { ORPCError, createRouterClient } from '@orpc/server';
+import { resolveMaybeOptionalOptions } from '@orpc/shared';
+export { ContentEncoding as JSONSchemaContentEncoding, Format as JSONSchemaFormat, TypeName as JSONSchemaTypeName } from 'json-schema-typed/draft-2020-12';
+import '@orpc/client/standard';
+import '@orpc/contract';
+
+function createJsonifiedRouterClient(router, ...rest) {
+  const options = resolveMaybeOptionalOptions(rest);
+  const serializer = new StandardOpenAPISerializer(new StandardOpenAPIJsonSerializer(), new StandardBracketNotationSerializer());
+  options.interceptors ??= [];
+  options.interceptors.unshift(async (options2) => {
+    try {
+      return serializer.deserialize(
+        serializer.serialize(
+          await options2.next()
+        )
+      );
+    } catch (e) {
+      if (e instanceof ORPCError) {
+        throw createORPCErrorFromJson(serializer.deserialize(
+          serializer.serialize(
+            e.toJSON(),
+            { outputFormat: "plain" }
+          )
+        ));
+      }
+      throw e;
+    }
+  });
+  return createRouterClient(router, options);
+}
+
+const oo = {
+  spec: customOpenAPIOperation
+};
+
+export { createJsonifiedRouterClient, customOpenAPIOperation, oo };

package/dist/plugins/index.d.mts

@@ -0,0 +1,84 @@
+import { OpenAPI } from '@orpc/contract';
+import { Context, HTTPPath, Router } from '@orpc/server';
+import { StandardHandlerInterceptorOptions, StandardHandlerPlugin, StandardHandlerOptions } from '@orpc/server/standard';
+import { Value, Promisable } from '@orpc/shared';
+import { O as OpenAPIGeneratorOptions, a as OpenAPIGeneratorGenerateOptions } from '../shared/openapi.BGy4N6eR.mjs';
+import '@orpc/openapi-client/standard';
+import 'json-schema-typed/draft-2020-12';
+
+interface OpenAPIReferencePluginOptions<T extends Context> extends OpenAPIGeneratorOptions {
+    /**
+     * Options to pass to the OpenAPI generate.
+     *
+     */
+    specGenerateOptions?: Value<Promisable<OpenAPIGeneratorGenerateOptions>, [StandardHandlerInterceptorOptions<T>]>;
+    /**
+     * The URL path at which to serve the OpenAPI JSON.
+     *
+     * @default '/spec.json'
+     */
+    specPath?: HTTPPath;
+    /**
+     * The URL path at which to serve the API reference UI.
+     *
+     * @default '/'
+     */
+    docsPath?: HTTPPath;
+    /**
+     * The document title for the API reference UI.
+     *
+     * @default 'API Reference'
+     */
+    docsTitle?: Value<Promisable<string>, [StandardHandlerInterceptorOptions<T>]>;
+    /**
+     * The UI library to use for rendering the API reference.
+     *
+     * @default 'scalar'
+     */
+    docsProvider?: 'scalar' | 'swagger';
+    /**
+     * Arbitrary configuration object for the UI.
+     */
+    docsConfig?: Value<Promisable<Record<string, unknown>>, [StandardHandlerInterceptorOptions<T>]>;
+    /**
+     * HTML to inject into the <head> of the docs page.
+     *
+     * @default ''
+     */
+    docsHead?: Value<Promisable<string>, [StandardHandlerInterceptorOptions<T>]>;
+    /**
+     * URL of the external script bundle for the reference UI.
+     *
+     * - For Scalar: defaults to 'https://cdn.jsdelivr.net/npm/@scalar/api-reference'
+     * - For Swagger UI: defaults to 'https://unpkg.com/swagger-ui-dist@5.17.14/swagger-ui-bundle.js'
+     */
+    docsScriptUrl?: Value<Promisable<string>, [StandardHandlerInterceptorOptions<T>]>;
+    /**
+     * URL of the external CSS bundle for the reference UI (used by Swagger UI).
+     *
+     * @default 'https://unpkg.com/swagger-ui-dist@5.17.14/swagger-ui.css' (if swagger)
+     */
+    docsCssUrl?: Value<Promisable<string>, [StandardHandlerInterceptorOptions<T>]>;
+    /**
+     * Override function to generate the full HTML for the docs page.
+     */
+    renderDocsHtml?: (specUrl: string, title: string, head: string, scriptUrl: string, config: Record<string, unknown> | undefined, spec: OpenAPI.Document, docsProvider: 'scalar' | 'swagger', cssUrl: string | undefined) => string;
+}
+declare class OpenAPIReferencePlugin<T extends Context> implements StandardHandlerPlugin<T> {
+    private readonly generator;
+    private readonly specGenerateOptions;
+    private readonly specPath;
+    private readonly docsPath;
+    private readonly docsTitle;
+    private readonly docsHead;
+    private readonly docsProvider;
+    private readonly docsScriptUrl;
+    private readonly docsCssUrl;
+    private readonly docsConfig;
+    private readonly renderDocsHtml;
+    constructor(options?: OpenAPIReferencePluginOptions<T>);
+    init(options: StandardHandlerOptions<T>, router: Router<any, T>): void;
+}
+
+export { OpenAPIReferencePlugin };
+export type { OpenAPIReferencePluginOptions };

package/dist/plugins/index.d.ts

@@ -0,0 +1,84 @@
+import { OpenAPI } from '@orpc/contract';
+import { Context, HTTPPath, Router } from '@orpc/server';
+import { StandardHandlerInterceptorOptions, StandardHandlerPlugin, StandardHandlerOptions } from '@orpc/server/standard';
+import { Value, Promisable } from '@orpc/shared';
+import { O as OpenAPIGeneratorOptions, a as OpenAPIGeneratorGenerateOptions } from '../shared/openapi.BGy4N6eR.js';
+import '@orpc/openapi-client/standard';
+import 'json-schema-typed/draft-2020-12';
+
+interface OpenAPIReferencePluginOptions<T extends Context> extends OpenAPIGeneratorOptions {
+    /**
+     * Options to pass to the OpenAPI generate.
+     *
+     */
+    specGenerateOptions?: Value<Promisable<OpenAPIGeneratorGenerateOptions>, [StandardHandlerInterceptorOptions<T>]>;
+    /**
+     * The URL path at which to serve the OpenAPI JSON.
+     *
+     * @default '/spec.json'
+     */
+    specPath?: HTTPPath;
+    /**
+     * The URL path at which to serve the API reference UI.
+     *
+     * @default '/'
+     */
+    docsPath?: HTTPPath;
+    /**
+     * The document title for the API reference UI.
+     *
+     * @default 'API Reference'
+     */
+    docsTitle?: Value<Promisable<string>, [StandardHandlerInterceptorOptions<T>]>;
+    /**
+     * The UI library to use for rendering the API reference.
+     *
+     * @default 'scalar'
+     */
+    docsProvider?: 'scalar' | 'swagger';
+    /**
+     * Arbitrary configuration object for the UI.
+     */
+    docsConfig?: Value<Promisable<Record<string, unknown>>, [StandardHandlerInterceptorOptions<T>]>;
+    /**
+     * HTML to inject into the <head> of the docs page.
+     *
+     * @default ''
+     */
+    docsHead?: Value<Promisable<string>, [StandardHandlerInterceptorOptions<T>]>;
+    /**
+     * URL of the external script bundle for the reference UI.
+     *
+     * - For Scalar: defaults to 'https://cdn.jsdelivr.net/npm/@scalar/api-reference'
+     * - For Swagger UI: defaults to 'https://unpkg.com/swagger-ui-dist@5.17.14/swagger-ui-bundle.js'
+     */
+    docsScriptUrl?: Value<Promisable<string>, [StandardHandlerInterceptorOptions<T>]>;
+    /**
+     * URL of the external CSS bundle for the reference UI (used by Swagger UI).
+     *
+     * @default 'https://unpkg.com/swagger-ui-dist@5.17.14/swagger-ui.css' (if swagger)
+     */
+    docsCssUrl?: Value<Promisable<string>, [StandardHandlerInterceptorOptions<T>]>;
+    /**
+     * Override function to generate the full HTML for the docs page.
+     */
+    renderDocsHtml?: (specUrl: string, title: string, head: string, scriptUrl: string, config: Record<string, unknown> | undefined, spec: OpenAPI.Document, docsProvider: 'scalar' | 'swagger', cssUrl: string | undefined) => string;
+}
+declare class OpenAPIReferencePlugin<T extends Context> implements StandardHandlerPlugin<T> {
+    private readonly generator;
+    private readonly specGenerateOptions;
+    private readonly specPath;
+    private readonly docsPath;
+    private readonly docsTitle;
+    private readonly docsHead;
+    private readonly docsProvider;
+    private readonly docsScriptUrl;
+    private readonly docsCssUrl;
+    private readonly docsConfig;
+    private readonly renderDocsHtml;
+    constructor(options?: OpenAPIReferencePluginOptions<T>);
+    init(options: StandardHandlerOptions<T>, router: Router<any, T>): void;
+}
+
+export { OpenAPIReferencePlugin };
+export type { OpenAPIReferencePluginOptions };

package/dist/plugins/index.mjs

@@ -0,0 +1,148 @@
+import { stringifyJSON, once, value } from '@orpc/shared';
+import { O as OpenAPIGenerator } from '../shared/openapi.CoREqFh3.mjs';
+import '@orpc/client';
+import '@orpc/client/standard';
+import '@orpc/contract';
+import '@orpc/openapi-client/standard';
+import '@orpc/server';
+import 'json-schema-typed/draft-2020-12';
+
+class OpenAPIReferencePlugin {
+  generator;
+  specGenerateOptions;
+  specPath;
+  docsPath;
+  docsTitle;
+  docsHead;
+  docsProvider;
+  docsScriptUrl;
+  docsCssUrl;
+  docsConfig;
+  renderDocsHtml;
+  constructor(options = {}) {
+    this.specGenerateOptions = options.specGenerateOptions;
+    this.docsPath = options.docsPath ?? "/";
+    this.docsTitle = options.docsTitle ?? "API Reference";
+    this.docsConfig = options.docsConfig ?? void 0;
+    this.docsProvider = options.docsProvider ?? "scalar";
+    this.docsScriptUrl = options.docsScriptUrl ?? (this.docsProvider === "swagger" ? "https://unpkg.com/swagger-ui-dist/swagger-ui-bundle.js" : "https://cdn.jsdelivr.net/npm/@scalar/api-reference");
+    this.docsCssUrl = options.docsCssUrl ?? (this.docsProvider === "swagger" ? "https://unpkg.com/swagger-ui-dist/swagger-ui.css" : void 0);
+    this.docsHead = options.docsHead ?? "";
+    this.specPath = options.specPath ?? "/spec.json";
+    this.generator = new OpenAPIGenerator(options);
+    const esc = (s) => s.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+    this.renderDocsHtml = options.renderDocsHtml ?? ((specUrl, title, head, scriptUrl, config, spec, docsProvider, cssUrl) => {
+      let body;
+      if (docsProvider === "swagger") {
+        const swaggerConfig = {
+          dom_id: "#app",
+          spec,
+          deepLinking: true,
+          presets: [
+            "SwaggerUIBundle.presets.apis",
+            "SwaggerUIBundle.presets.standalone"
+          ],
+          plugins: [
+            "SwaggerUIBundle.plugins.DownloadUrl"
+          ],
+          ...config
+        };
+        body = `
+        <body>
+          <div id="app"></div>
+
+          <script src="${esc(scriptUrl)}"><\/script>
+
+          <script>
+            window.onload = () => {
+              window.ui = SwaggerUIBundle(${stringifyJSON(swaggerConfig).replace(/"(SwaggerUIBundle\.[^"]+)"/g, "$1")})
+            }
+          <\/script>
+        </body>
+        `;
+      } else {
+        const scalarConfig = {
+          content: stringifyJSON(spec),
+          ...config
+        };
+        body = `
+        <body>
+          <div id="app" data-config="${esc(stringifyJSON(scalarConfig))}"></div>
+
+          <script src="${esc(scriptUrl)}"><\/script>
+
+          <script>
+            Scalar.createApiReference('#app', JSON.parse(document.getElementById('app').dataset.config))
+          <\/script>
+        </body>
+        `;
+      }
+      return `
+        <!doctype html>
+        <html>
+          <head>
+            <meta charset="utf-8" />
+            <meta name="viewport" content="width=device-width, initial-scale=1" />
+            <title>${esc(title)}</title>
+            ${cssUrl ? `<link rel="stylesheet" type="text/css" href="${esc(cssUrl)}" />` : ""}
+            ${head}
+          </head>
+          ${body}
+        </html>
+        `;
+    });
+  }
+  init(options, router) {
+    options.interceptors ??= [];
+    options.interceptors.push(async (options2) => {
+      const res = await options2.next();
+      if (res.matched || options2.request.method !== "GET") {
+        return res;
+      }
+      const prefix = options2.prefix ?? "";
+      const requestPathname = options2.request.url.pathname.replace(/\/$/, "") || "/";
+      const docsUrl = new URL(`${prefix}${this.docsPath}`.replace(/\/$/, ""), options2.request.url.origin);
+      const specUrl = new URL(`${prefix}${this.specPath}`.replace(/\/$/, ""), options2.request.url.origin);
+      const generateSpec = once(async () => {
+        return await this.generator.generate(router, {
+          servers: [{ url: new URL(prefix, options2.request.url.origin).toString() }],
+          ...await value(this.specGenerateOptions, options2)
+        });
+      });
+      if (requestPathname === specUrl.pathname) {
+        const spec = await generateSpec();
+        return {
+          matched: true,
+          response: {
+            status: 200,
+            headers: {},
+            body: new File([stringifyJSON(spec)], "spec.json", { type: "application/json" })
+          }
+        };
+      }
+      if (requestPathname === docsUrl.pathname) {
+        const html = this.renderDocsHtml(
+          specUrl.toString(),
+          await value(this.docsTitle, options2),
+          await value(this.docsHead, options2),
+          await value(this.docsScriptUrl, options2),
+          await value(this.docsConfig, options2),
+          await generateSpec(),
+          this.docsProvider,
+          await value(this.docsCssUrl, options2)
+        );
+        return {
+          matched: true,
+          response: {
+            status: 200,
+            headers: {},
+            body: new File([html], "api-reference.html", { type: "text/html" })
+          }
+        };
+      }
+      return res;
+    });
+  }
+}
+
+export { OpenAPIReferencePlugin };

package/dist/shared/openapi.BGy4N6eR.d.mts

@@ -0,0 +1,120 @@
+import { AnySchema, OpenAPI, AnyContractProcedure, AnyContractRouter } from '@orpc/contract';
+import { StandardOpenAPIJsonSerializerOptions } from '@orpc/openapi-client/standard';
+import { AnyProcedure, TraverseContractProcedureCallbackOptions, AnyRouter } from '@orpc/server';
+import { Promisable, Value } from '@orpc/shared';
+import { JSONSchema } from 'json-schema-typed/draft-2020-12';
+
+interface SchemaConverterComponent {
+    allowedStrategies: readonly SchemaConvertOptions['strategy'][];
+    schema: AnySchema;
+    required: boolean;
+    ref: string;
+}
+interface SchemaConvertOptions {
+    strategy: 'input' | 'output';
+    /**
+     * Common components should use `$ref` to represent themselves if matched.
+     */
+    components?: readonly SchemaConverterComponent[];
+    /**
+     * Minimum schema structure depth required before using `$ref` for components.
+     *
+     * For example, if set to 2, `$ref` will only be used for schemas nested at depth 2 or greater.
+     *
+     * @default 0 - No depth limit;
+     */
+    minStructureDepthForRef?: number;
+}
+interface SchemaConverter {
+    convert(schema: AnySchema | undefined, options: SchemaConvertOptions): Promisable<[required: boolean, jsonSchema: JSONSchema]>;
+}
+interface ConditionalSchemaConverter extends SchemaConverter {
+    condition(schema: AnySchema | undefined, options: SchemaConvertOptions): Promisable<boolean>;
+}
+declare class CompositeSchemaConverter implements SchemaConverter {
+    private readonly converters;
+    constructor(converters: readonly ConditionalSchemaConverter[]);
+    convert(schema: AnySchema | undefined, options: SchemaConvertOptions): Promise<[required: boolean, jsonSchema: JSONSchema]>;
+}
+
+interface OpenAPIGeneratorOptions extends StandardOpenAPIJsonSerializerOptions {
+    schemaConverters?: ConditionalSchemaConverter[];
+}
+interface OpenAPIGeneratorGenerateOptions extends Partial<Omit<OpenAPI.Document, 'openapi'>> {
+    /**
+     * Exclude procedures from the OpenAPI specification.
+     *
+     * @deprecated Use `filter` option instead.
+     * @default () => false
+     */
+    exclude?: (procedure: AnyProcedure | AnyContractProcedure, path: readonly string[]) => boolean;
+    /**
+     * Filter procedures. Return `false` to exclude a procedure from the OpenAPI specification.
+     *
+     * @default true
+     */
+    filter?: Value<boolean, [options: TraverseContractProcedureCallbackOptions]>;
+    /**
+     * Common schemas to be used for $ref resolution.
+     */
+    commonSchemas?: Record<string, {
+        /**
+         * Determines which schema definition to use when input and output schemas differ.
+         * This is needed because some schemas transform data differently between input and output,
+         * making it impossible to use a single $ref for both cases.
+         *
+         * @example
+         * ```ts
+         * // This schema transforms a string input into a number output
+         * const Schema = z.string()
+         *   .transform(v => Number(v))
+         *   .pipe(z.number())
+         *
+         * // Input schema:  { type: 'string' }
+         * // Output schema: { type: 'number' }
+         * ```
+         *
+         * When schemas differ between input and output, you must explicitly choose
+         * which version to use for the OpenAPI specification.
+         *
+         * @default 'input' - Uses the input schema definition by default
+         */
+        strategy?: SchemaConvertOptions['strategy'];
+        schema: AnySchema;
+    } | {
+        error: 'UndefinedError';
+        schema?: never;
+    }>;
+    /**
+     * Define a custom JSON schema for the error response body when using
+     * type-safe errors. Helps align ORPC error formatting with existing API
+     * response standards or conventions.
+     *
+     * @remarks
+     * - Return `null | undefined` to use the default error response body shaper.
+     */
+    customErrorResponseBodySchema?: Value<JSONSchema | undefined | null, [
+        definedErrors: [code: string, defaultMessage: string, dataRequired: boolean, dataSchema: JSONSchema][],
+        status: number
+    ]>;
+}
+/**
+ * The generator that converts oRPC routers/contracts to OpenAPI specifications.
+ *
+ * @see {@link https://orpc.dev/docs/openapi/openapi-specification OpenAPI Specification Docs}
+ */
+declare class OpenAPIGenerator {
+    #private;
+    private readonly serializer;
+    private readonly converter;
+    constructor(options?: OpenAPIGeneratorOptions);
+    /**
+     * Generates OpenAPI specifications from oRPC routers/contracts.
+     *
+     * @see {@link https://orpc.dev/docs/openapi/openapi-specification OpenAPI Specification Docs}
+     */
+    generate(router: AnyContractRouter | AnyRouter, { customErrorResponseBodySchema, commonSchemas, filter: baseFilter, exclude, ...baseDoc }?: OpenAPIGeneratorGenerateOptions): Promise<OpenAPI.Document>;
+}
+
+export { OpenAPIGenerator as b, CompositeSchemaConverter as e };
+export type { ConditionalSchemaConverter as C, OpenAPIGeneratorOptions as O, SchemaConverterComponent as S, OpenAPIGeneratorGenerateOptions as a, SchemaConvertOptions as c, SchemaConverter as d };