@orpc/openapi 1.14.6 → 2.0.0-beta.10

package/dist/adapters/standard/index.d.ts

@@ -1,20 +1,50 @@
-export { a as StandardOpenAPICodec, S as StandardOpenAPICodecOptions, c as StandardOpenAPIHandler, b as StandardOpenAPIHandlerOptions, e as StandardOpenAPIMatcher, d as StandardOpenAPIMatcherOptions } from '../../shared/openapi.DwaweYRb.js';
-import { HTTPPath } from '@orpc/client';
-import '@orpc/openapi-client/standard';
+export { a as OpenAPIHandlerCodec, b as OpenAPIHandlerCodecCore, c as OpenAPIHandlerCodecCoreOptions, O as OpenAPIHandlerCodecOptions, d as OpenAPIMatcher, e as OpenAPIMatcherOptions } from '../../shared/openapi.7vgmPxca.js';
+import { ClientContext, ClientOptions, AnyORPCError } from '@orpc/client';
+import { StandardLinkCodec, StandardLinkCodecDecodedResponse } from '@orpc/client/standard';
+import { RouterContract } from '@orpc/contract';
+import { Value, Promisable } from '@orpc/shared';
+import { StandardUrl, StandardHeaders, StandardLazyResponse, StandardRequest } from '@standardserver/core';
+import { O as OpenAPISerializer } from '../../shared/openapi.C7m7NAmH.js';
 import '@orpc/server';
 import '@orpc/server/standard';
-import '@orpc/standard-server';
-import '@orpc/shared';
 
-/**
- * {@link https://github.com/unjs/rou3}
- *
- * @internal
- */
-declare function toRou3Pattern(path: HTTPPath): string;
-/**
- * @internal
- */
-declare function decodeParams(params: Record<string, string>): Record<string, string>;
+declare class OpenAPILinkCodecError extends TypeError {
+}
+interface OpenAPILinkCodecOptions<T extends ClientContext> {
+    /**
+     * Base URL for all requests, without origin. Should match the OpenAPI handler mount path.
+     *
+     * @example '/api'
+     * @default '/'
+     */
+    url?: Value<Promisable<StandardUrl>, [options: ClientOptions<T>, path: string[], input: unknown]>;
+    /**
+     * Inject headers into the request.
+     */
+    headers?: Value<Promisable<StandardHeaders | Headers>, [options: ClientOptions<T>, path: string[], input: unknown]>;
+    /**
+     * Override the default OpenAPI serializer.
+     */
+    serializer?: Pick<OpenAPISerializer, keyof OpenAPISerializer>;
+    /**
+     * Customize how an error response body is converted into an ORPC error.
+     * Return `null` or `undefined` to fall back to the default decoding behavior.
+     */
+    customErrorResponseBodyDecoder?: (deserializedBody: unknown, response: StandardLazyResponse) => AnyORPCError | null | undefined;
+}
+declare class OpenAPILinkCodec<T extends ClientContext> implements StandardLinkCodec<T> {
+    private readonly router;
+    private readonly baseUrl;
+    private readonly headers;
+    private readonly serializer;
+    private readonly customErrorResponseBodyDecoder;
+    constructor(router: RouterContract, options?: OpenAPILinkCodecOptions<T>);
+    encodeInput(input: unknown, path: string[], options: ClientOptions<T>): Promise<StandardRequest>;
+    private encodePathParam;
+    private serializeQueryString;
+    decodeResponse(response: StandardLazyResponse, path: string[], _options: ClientOptions<T>): Promise<StandardLinkCodecDecodedResponse>;
+    private resolveProcedure;
+}
 
-export { decodeParams, toRou3Pattern };
+export { OpenAPILinkCodec, OpenAPILinkCodecError };
+export type { OpenAPILinkCodecOptions };

package/dist/adapters/standard/index.mjs

@@ -1,9 +1,12 @@
-export { S as StandardOpenAPICodec, a as StandardOpenAPIHandler, b as StandardOpenAPIMatcher, d as decodeParams, t as toRou3Pattern } from '../../shared/openapi.BB-W-NKv.mjs';
-import '@orpc/openapi-client/standard';
-import '@orpc/server/standard';
+export { O as OpenAPIHandlerCodec, a as OpenAPIHandlerCodecCore, b as OpenAPIMatcher } from '../../shared/openapi.CTlpLuKN.mjs';
+export { O as OpenAPILinkCodec, a as OpenAPILinkCodecError } from '../../shared/openapi.B2SK0ZAr.mjs';
 import '@orpc/client';
-import '@orpc/contract';
-import '@orpc/shared';
-import '@orpc/client/standard';
 import '@orpc/server';
+import '@orpc/shared';
+import '@standardserver/core';
+import '../../shared/openapi.DmAa7YPO.mjs';
+import '../../shared/openapi.Bt87OzTt.mjs';
+import '../../shared/openapi.B9PQzqBn.mjs';
 import 'rou3';
+import '@orpc/contract';
+import '@standardserver/fetch';

package/dist/extensions/route.d.mts

@@ -0,0 +1,43 @@
+import { AnyORPCError } from '@orpc/client';
+import { ErrorMap, AnySchema } from '@orpc/contract';
+import { Context } from '@orpc/server';
+import { O as OpenAPIMeta } from '../shared/openapi.BcEtAxQj.mjs';
+import '@orpc/shared';
+import '@standardserver/core';
+import '../shared/openapi.CYgMBSUF.mjs';
+import '@hey-api/spec-types';
+
+declare module '@orpc/contract' {
+    interface ContractBuilder<TErrorMap extends ErrorMap> {
+        route(meta: OpenAPIMeta): ContractBuilder<TErrorMap>;
+    }
+    interface ProcedureContractBuilderWithInput<TInputSchema extends AnySchema, TErrorMap extends ErrorMap> {
+        route(meta: OpenAPIMeta): ProcedureContractBuilderWithInput<TInputSchema, TErrorMap>;
+    }
+    interface ProcedureContractBuilderWithOutput<TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> {
+        route(meta: OpenAPIMeta): ProcedureContractBuilderWithOutput<TOutputSchema, TErrorMap>;
+    }
+    interface ProcedureContractBuilderWithInputOutput<TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> {
+        route(meta: OpenAPIMeta): ProcedureContractBuilderWithInputOutput<TInputSchema, TOutputSchema, TErrorMap>;
+    }
+}
+declare module '@orpc/server' {
+    interface Builder<TInitialContext extends Context, TErrorMap extends ErrorMap> {
+        route(meta: OpenAPIMeta): Builder<TInitialContext, TErrorMap>;
+    }
+    interface BuilderWithMiddlewares<TInitialContext extends Context, TInjectedContext extends Context, TErrorMap extends ErrorMap> {
+        route(meta: OpenAPIMeta): BuilderWithMiddlewares<TInitialContext, TInjectedContext, TErrorMap>;
+    }
+    interface BuilderWithInput<TInitialContext extends Context, TInjectedContext extends Context, TInputSchema extends AnySchema, TErrorMap extends ErrorMap> {
+        route(meta: OpenAPIMeta): BuilderWithInput<TInitialContext, TInjectedContext, TInputSchema, TErrorMap>;
+    }
+    interface BuilderWithOutput<TInitialContext extends Context, TInjectedContext extends Context, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> {
+        route(meta: OpenAPIMeta): BuilderWithOutput<TInitialContext, TInjectedContext, TOutputSchema, TErrorMap>;
+    }
+    interface BuilderWithInputOutput<TInitialContext extends Context, TInjectedContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> {
+        route(meta: OpenAPIMeta): BuilderWithInputOutput<TInitialContext, TInjectedContext, TInputSchema, TOutputSchema, TErrorMap>;
+    }
+    interface DecoratedProcedure<TInitialContext extends Context, TInjectedContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TReturnedError extends AnyORPCError> {
+        route(meta: OpenAPIMeta): DecoratedProcedure<TInitialContext, TInjectedContext, TInputSchema, TOutputSchema, TErrorMap, TReturnedError>;
+    }
+}

package/dist/extensions/route.d.ts

@@ -0,0 +1,43 @@
+import { AnyORPCError } from '@orpc/client';
+import { ErrorMap, AnySchema } from '@orpc/contract';
+import { Context } from '@orpc/server';
+import { O as OpenAPIMeta } from '../shared/openapi.BQzzr4-4.js';
+import '@orpc/shared';
+import '@standardserver/core';
+import '../shared/openapi.CYgMBSUF.js';
+import '@hey-api/spec-types';
+
+declare module '@orpc/contract' {
+    interface ContractBuilder<TErrorMap extends ErrorMap> {
+        route(meta: OpenAPIMeta): ContractBuilder<TErrorMap>;
+    }
+    interface ProcedureContractBuilderWithInput<TInputSchema extends AnySchema, TErrorMap extends ErrorMap> {
+        route(meta: OpenAPIMeta): ProcedureContractBuilderWithInput<TInputSchema, TErrorMap>;
+    }
+    interface ProcedureContractBuilderWithOutput<TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> {
+        route(meta: OpenAPIMeta): ProcedureContractBuilderWithOutput<TOutputSchema, TErrorMap>;
+    }
+    interface ProcedureContractBuilderWithInputOutput<TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> {
+        route(meta: OpenAPIMeta): ProcedureContractBuilderWithInputOutput<TInputSchema, TOutputSchema, TErrorMap>;
+    }
+}
+declare module '@orpc/server' {
+    interface Builder<TInitialContext extends Context, TErrorMap extends ErrorMap> {
+        route(meta: OpenAPIMeta): Builder<TInitialContext, TErrorMap>;
+    }
+    interface BuilderWithMiddlewares<TInitialContext extends Context, TInjectedContext extends Context, TErrorMap extends ErrorMap> {
+        route(meta: OpenAPIMeta): BuilderWithMiddlewares<TInitialContext, TInjectedContext, TErrorMap>;
+    }
+    interface BuilderWithInput<TInitialContext extends Context, TInjectedContext extends Context, TInputSchema extends AnySchema, TErrorMap extends ErrorMap> {
+        route(meta: OpenAPIMeta): BuilderWithInput<TInitialContext, TInjectedContext, TInputSchema, TErrorMap>;
+    }
+    interface BuilderWithOutput<TInitialContext extends Context, TInjectedContext extends Context, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> {
+        route(meta: OpenAPIMeta): BuilderWithOutput<TInitialContext, TInjectedContext, TOutputSchema, TErrorMap>;
+    }
+    interface BuilderWithInputOutput<TInitialContext extends Context, TInjectedContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> {
+        route(meta: OpenAPIMeta): BuilderWithInputOutput<TInitialContext, TInjectedContext, TInputSchema, TOutputSchema, TErrorMap>;
+    }
+    interface DecoratedProcedure<TInitialContext extends Context, TInjectedContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TReturnedError extends AnyORPCError> {
+        route(meta: OpenAPIMeta): DecoratedProcedure<TInitialContext, TInjectedContext, TInputSchema, TOutputSchema, TErrorMap, TReturnedError>;
+    }
+}

package/dist/extensions/route.mjs

@@ -0,0 +1,14 @@
+import { ContractBuilder } from '@orpc/contract';
+import { Builder, DecoratedProcedure } from '@orpc/server';
+import { o as openapi } from '../shared/openapi.B9PQzqBn.mjs';
+import '@orpc/shared';
+
+ContractBuilder.prototype.route = function route(meta) {
+  return this.meta(openapi(meta));
+};
+Builder.prototype.route = function route2(meta) {
+  return this.meta(openapi(meta));
+};
+DecoratedProcedure.prototype.route = function route3(meta) {
+  return this.meta(openapi(meta));
+};

package/dist/helpers/index.d.mts

@@ -0,0 +1,51 @@
+/**
+ * Parse a form data with [bracket notation](https://orpc.dev/docs/openapi/bracket-notation) syntax
+ *
+ * @example
+ * ```ts
+ * const form = new FormData()
+ * form.append('a', '1')
+ * form.append('user[name]', 'John')
+ * form.append('user[age]', '20')
+ * form.append('user[friends][]', 'Bob')
+ * form.append('user[friends][]', 'Alice')
+ * form.append('user[friends][]', 'Charlie')
+ * form.append('thumb', new Blob(['hello']), 'thumb.png')
+ *
+ * parseFormData(form)
+ * // {
+ * //   a: '1',
+ * //   user: {
+ * //     name: 'John',
+ * //     age: '20',
+ * //     friends: ['Bob', 'Alice', 'Charlie'],
+ * //   },
+ * //   thumb: form.get('thumb'),
+ * // }
+ * ```
+ */
+declare function parseFormData(form: FormData): any;
+/**
+ * Get the issue message from the error.
+ *
+ * @example
+ * ```tsx
+ * const { error, data, execute } = useServerAction(someAction)
+ *
+ * return <form action={(form) => execute(parseFormData(form))}>
+ *   <input name="user[name]" type="text" />
+ *   <p>{getIssueMessage(error, 'user[name]')}</p>
+ *
+ *   <input name="user[age]" type="number" />
+ *   <p>{getIssueMessage(error, 'user[age]')}</p>
+ *
+ *   <input name="images[]" type="file" />
+ *   <p>{getIssueMessage(error, 'images[]')}</p>
+ * </form>
+ *
+ * @param error - The error (can be anything) can contain `data.issues` (standard schema issues)
+ * @param path - The path of the field that has the issue follow [bracket notation](https://orpc.dev/docs/openapi/bracket-notation)
+ */
+declare function getIssueMessage(error: unknown, path: string): string | undefined;
+
+export { getIssueMessage, parseFormData };

package/dist/helpers/index.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Parse a form data with [bracket notation](https://orpc.dev/docs/openapi/bracket-notation) syntax
+ *
+ * @example
+ * ```ts
+ * const form = new FormData()
+ * form.append('a', '1')
+ * form.append('user[name]', 'John')
+ * form.append('user[age]', '20')
+ * form.append('user[friends][]', 'Bob')
+ * form.append('user[friends][]', 'Alice')
+ * form.append('user[friends][]', 'Charlie')
+ * form.append('thumb', new Blob(['hello']), 'thumb.png')
+ *
+ * parseFormData(form)
+ * // {
+ * //   a: '1',
+ * //   user: {
+ * //     name: 'John',
+ * //     age: '20',
+ * //     friends: ['Bob', 'Alice', 'Charlie'],
+ * //   },
+ * //   thumb: form.get('thumb'),
+ * // }
+ * ```
+ */
+declare function parseFormData(form: FormData): any;
+/**
+ * Get the issue message from the error.
+ *
+ * @example
+ * ```tsx
+ * const { error, data, execute } = useServerAction(someAction)
+ *
+ * return <form action={(form) => execute(parseFormData(form))}>
+ *   <input name="user[name]" type="text" />
+ *   <p>{getIssueMessage(error, 'user[name]')}</p>
+ *
+ *   <input name="user[age]" type="number" />
+ *   <p>{getIssueMessage(error, 'user[age]')}</p>
+ *
+ *   <input name="images[]" type="file" />
+ *   <p>{getIssueMessage(error, 'images[]')}</p>
+ * </form>
+ *
+ * @param error - The error (can be anything) can contain `data.issues` (standard schema issues)
+ * @param path - The path of the field that has the issue follow [bracket notation](https://orpc.dev/docs/openapi/bracket-notation)
+ */
+declare function getIssueMessage(error: unknown, path: string): string | undefined;
+
+export { getIssueMessage, parseFormData };

package/dist/helpers/index.mjs

@@ -0,0 +1,39 @@
+import { isSchemaIssue } from '@orpc/contract';
+import { isTypescriptObject } from '@orpc/shared';
+import { B as BracketNotationSerializer } from '../shared/openapi.Bt87OzTt.mjs';
+
+function parseFormData(form) {
+  const serializer = new BracketNotationSerializer();
+  return serializer.deserialize(Array.from(form.entries()));
+}
+function getIssueMessage(error, path) {
+  if (!isTypescriptObject(error) || !isTypescriptObject(error.data) || !Array.isArray(error.data.issues)) {
+    return void 0;
+  }
+  const serializer = new BracketNotationSerializer();
+  for (const issue of error.data.issues) {
+    if (!isSchemaIssue(issue)) {
+      continue;
+    }
+    if (issue.path === void 0) {
+      if (path === "") {
+        return issue.message;
+      }
+      continue;
+    }
+    const issuePath = serializer.stringifyPath(
+      issue.path.map((segment) => typeof segment === "object" ? segment.key.toString() : segment.toString())
+    );
+    if (issuePath === path) {
+      return issue.message;
+    }
+    if (path.endsWith("[]") && issuePath.replace(/\[(?:0|[1-9]\d*)\]$/, "[]") === path) {
+      return issue.message;
+    }
+    if (path === "" && /(?:0|[1-9]\d*)$/.test(issuePath)) {
+      return issue.message;
+    }
+  }
+}
+
+export { getIssueMessage, parseFormData };

package/dist/index.d.mts

@@ -1,117 +1,120 @@
-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.mjs';
-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';
+import { O as OpenAPISerializer } from './shared/openapi.C7m7NAmH.mjs';
+export { B as BracketNotationSerializeResult, a as BracketNotationSerializer, b as BracketNotationSerializerOptions, c as OpenAPIJsonSerialization, d as OpenAPIJsonSerializer, e as OpenAPIJsonSerializerHandler, f as OpenAPIJsonSerializerOptions, g as OpenAPISerializerOptions, h as OpenAPISerializerSerializeOptions } from './shared/openapi.C7m7NAmH.mjs';
+import { ClientContext, ClientRest, ThrowableError, ORPCClientOptions, ClientLink } from '@orpc/client';
+export { COMMON_ERROR_STATUS_MAP } from '@orpc/client';
+import { AnySchema, ErrorMap, ProcedureContract, InferSchemaInput, InferSchemaOutput, ORPCErrorFromErrorMap, RouterContractClient, RouterContract, AnyProcedureContract } from '@orpc/contract';
+import { PromiseWithError, Value } from '@orpc/shared';
+import { J as JsonifiedValue, b as JsonifiedClientError, c as JsonifiedClient, a as OpenAPIDocument } from './shared/openapi.CYgMBSUF.mjs';
+export { d as JsonifiedArray, O as OpenAPIOperationObject } from './shared/openapi.CYgMBSUF.mjs';
+export { a as OpenAPIFunction, O as OpenAPIMeta, b as OpenAPIMetaPlugin, c as OpenAPIMethodMetaPlugin, d as OpenAPIPathMetaPlugin, e as OpenAPIPrefixMetaPlugin, f as OpenAPISpecMetaPlugin, g as getOpenAPIMeta, o as openapi } from './shared/openapi.BcEtAxQj.mjs';
+import { JsonSchemaConverter, JsonSchema } from '@orpc/json-schema';
+import { AnyRouter, AnyProcedure } from '@orpc/server';
+export { StandardBodyHint } from '@standardserver/core';
+import '@hey-api/spec-types';
 
-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;
+interface ContractJsonifiedCaller<TClientContext extends ClientContext> {
+    <TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap>(procedure: ProcedureContract<TInputSchema, TOutputSchema, TErrorMap>, ...rest: ClientRest<TClientContext, InferSchemaInput<TInputSchema>>): PromiseWithError<JsonifiedValue<InferSchemaOutput<TOutputSchema>>, JsonifiedClientError<ORPCErrorFromErrorMap<TErrorMap> | ThrowableError>>;
+}
+interface ContractJsonifiedCallerOptions<TClientContext extends ClientContext> extends Pick<ORPCClientOptions<JsonifiedClient<RouterContractClient<RouterContract, TClientContext>>>, 'interceptors' | 'scoped'> {
+    /**
+     * An optional reference to the root router-contract.
+     * When provided, the caller will automatically register the called procedure-contract
+     * into the router at the path defined by `meta.path`.
+     */
+    contractRef?: undefined | RouterContract;
+}
+declare function createContractJsonifiedCaller<TClientContext extends ClientContext>(link: ClientLink<TClientContext>, options?: ContractJsonifiedCallerOptions<TClientContext>): ContractJsonifiedCaller<TClientContext>;
 
-/**
- * @internal
- */
-type ObjectSchema = JSONSchema & {
-    type: 'object';
-} & object;
-/**
- * @internal
- */
-type FileSchema = JSONSchema & {
-    type: 'string';
-    contentMediaType: string;
-} & object;
-/**
- * @internal
- */
-declare const LOGIC_KEYWORDS: string[];
+declare const DEFAULT_OPENAPI_METHOD = "POST";
+declare const DEFAULT_OPENAPI_SUCCESS_DESCRIPTION = "OK";
+declare const DEFAULT_OPENAPI_INPUT_STRUCTURE = "compact";
+declare const DEFAULT_OPENAPI_OUTPUT_STRUCTURE = "compact";
 
-/**
- * @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
+declare class OpenAPIGeneratorError extends TypeError {
+}
+interface OpenAPIGeneratorOptions {
+    converters?: JsonSchemaConverter[] | undefined;
+    /**
+     * The serializer used to serialize the generated OpenAPI documentation
+     */
+    serializer?: Pick<OpenAPISerializer, keyof OpenAPISerializer> | undefined;
+}
+interface OpenAPIGeneratorGenerateOptions {
+    base?: Partial<OpenAPIDocument> | undefined;
+    /**
+     * Controls whether a generated json schema `$defs` at root-level should be moved into `components.schemas`.
+     *
+     * @default true
+     */
+    shouldHoistDef?: Value<boolean, [defName: string, defSchema: JsonSchema]>;
+    /**
+     * Filter procedures. Return `false` to exclude a procedure from the OpenAPI specification.
+     *
+     * @default true
+     */
+    filter?: Value<boolean, [contract: AnyProcedureContract | AnyProcedure, path: string[]]>;
+    /**
+     * 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 | undefined;
+            dataOptional: boolean;
+            dataJsonSchema: JsonSchema;
+        }[],
+        status: number
+    ]>;
+    /**
+     * Mapping ORPCError Code -> HTTP Status Code
+     *
+     * @default COMMON_ERROR_STATUS_MAP, DEFAULT_ERROR_STATUS
+     */
+    errorStatusMap?: Record<string, number> | undefined;
+}
+declare class OpenAPIGenerator {
+    private readonly serializer;
+    private readonly converter;
+    constructor(options?: OpenAPIGeneratorOptions);
+    generate(router: RouterContract | AnyRouter, options?: OpenAPIGeneratorGenerateOptions): Promise<OpenAPIDocument>;
+    private convertSchema;
+    private convertSchemas;
+    private request;
+    private successResponse;
+    private errorResponse;
+}
+
+type PopulatedContractRouterOpenAPIPaths<T extends RouterContract> = T extends ProcedureContract<infer UInputSchema, infer UOutputSchema, infer UErrors> ? ProcedureContract<UInputSchema, UOutputSchema, UErrors> : {
+    [K in keyof T]: T[K] extends RouterContract ? PopulatedContractRouterOpenAPIPaths<T[K]> : never;
+};
+interface PopulateRouterContractOpenAPIPathsOptions {
+    /**
+     * Base path segments.
+     */
+    path?: undefined | string[];
+}
+/**
+ * Automatically populates missing openapi.path using router structure.
  *
- * @warning The result is looser than the original schema and may not fully validate the same data.
+ * Builds paths by joining router keys with `/`.
+ * Useful when you want to ensure all contracts define openapi.path, such as for NestJS integration requirements.
  */
-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>>;
+declare function populateRouterContractOpenAPIPaths<T extends RouterContract>(router: T, options?: PopulateRouterContractOpenAPIPathsOptions): PopulatedContractRouterOpenAPIPaths<T>;
 
 /**
- *@internal
+ * Dynamic parameters are always returned in path order.
  */
-declare function isFileSchema(schema: JSONSchema): schema is FileSchema;
-/**
- * @internal
- */
-declare function isObjectSchema(schema: JSONSchema): schema is ObjectSchema;
-/**
- * @internal
- */
-declare function isAnySchema(schema: JSONSchema): boolean;
-declare function isNeverSchema(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;
-};
+declare function getDynamicPathParams(path: `/${string}`): {
+    segment: string;
+    startIndex: number;
+    parameterName: string;
+    allowsSlash: boolean;
+}[] | undefined;
 
-export { LOGIC_KEYWORDS, applyCustomOpenAPIOperation, applySchemaOptionality, checkParamsSchema, createJsonifiedRouterClient, customOpenAPIOperation, expandArrayableSchema, expandUnionSchema, filterSchemaBranches, getCustomOpenAPIOperation, isAnySchema, isFileSchema, isNeverSchema, isObjectSchema, isPrimitiveSchema, oo, resolveOpenAPIJsonSchemaRef, separateObjectSchema, simplifyComposedObjectJsonSchemasAndRefs, toOpenAPIContent, toOpenAPIEventIteratorContent, toOpenAPIMethod, toOpenAPIParameters, toOpenAPIPath, toOpenAPISchema };
-export type { FileSchema, ObjectSchema, OverrideOperationValue };
+export { DEFAULT_OPENAPI_INPUT_STRUCTURE, DEFAULT_OPENAPI_METHOD, DEFAULT_OPENAPI_OUTPUT_STRUCTURE, DEFAULT_OPENAPI_SUCCESS_DESCRIPTION, JsonifiedClient, JsonifiedClientError, JsonifiedValue, OpenAPIDocument, OpenAPIGenerator, OpenAPIGeneratorError, OpenAPISerializer, createContractJsonifiedCaller, getDynamicPathParams, populateRouterContractOpenAPIPaths };
+export type { ContractJsonifiedCaller, ContractJsonifiedCallerOptions, OpenAPIGeneratorGenerateOptions, OpenAPIGeneratorOptions, PopulateRouterContractOpenAPIPathsOptions, PopulatedContractRouterOpenAPIPaths };