@orpc/openapi 0.0.0-next.ea0903c → 0.0.0-next.ea1d4fd

package/dist/index.d.ts

@@ -1,16 +1,23 @@
-import { AnyContractProcedure, AnySchema, AnyContractRouter } from '@orpc/contract';
-import { OpenAPIV3_1 } from 'openapi-types';
-export { OpenAPIV3_1 as OpenAPI } from 'openapi-types';
-import { StandardOpenAPIJsonSerializerOptions } from '@orpc/openapi-client/standard';
-import { AnyRouter } from '@orpc/server';
-import { JSONSchema } from 'json-schema-typed/draft-2020-12';
-export { JSONSchema, Format as JSONSchemaFormat } from 'json-schema-typed/draft-2020-12';
+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.BfNjg7j9.js';
 import { HTTPPath, HTTPMethod } from '@orpc/client';
+import { JSONSchema } from '@orpc/interop/json-schema-typed/draft-2020-12';
+export { JSONSchema, ContentEncoding as JSONSchemaContentEncoding, Format as JSONSchemaFormat, TypeName as JSONSchemaTypeName } from '@orpc/interop/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<OpenAPIV3_1.OperationObject> | ((current: OpenAPIV3_1.OperationObject, procedure: AnyContractProcedure) => OpenAPIV3_1.OperationObject);
+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.unnoq.com/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: OpenAPIV3_1.OperationObject, contract: AnyContractProcedure): OpenAPIV3_1.OperationObject;
+declare function applyCustomOpenAPIOperation(operation: OpenAPI.OperationObject, contract: AnyContractProcedure): OpenAPI.OperationObject;
 
 /**
  * @internal
@@ -30,32 +37,6 @@ type FileSchema = JSONSchema & {
  */
 declare const LOGIC_KEYWORDS: string[];
 
-interface SchemaConvertOptions {
-    strategy: 'input' | 'output';
-}
-interface SchemaConverter {
-    convert(schema: AnySchema | undefined, options: SchemaConvertOptions): [required: boolean, jsonSchema: JSONSchema];
-}
-interface ConditionalSchemaConverter extends SchemaConverter {
-    condition(schema: AnySchema | undefined, options: SchemaConvertOptions): boolean;
-}
-declare class CompositeSchemaConverter implements SchemaConverter {
-    private readonly converters;
-    constructor(converters: ConditionalSchemaConverter[]);
-    convert(schema: AnySchema | undefined, options: SchemaConvertOptions): [required: boolean, jsonSchema: JSONSchema];
-}
-
-interface OpenAPIGeneratorOptions extends StandardOpenAPIJsonSerializerOptions {
-    schemaConverters?: ConditionalSchemaConverter[];
-}
-declare class OpenAPIGenerator {
-    #private;
-    private readonly serializer;
-    private readonly converter;
-    constructor(options?: OpenAPIGeneratorOptions);
-    generate(router: AnyContractRouter | AnyRouter, base: Omit<OpenAPIV3_1.Document, 'openapi'>): Promise<OpenAPIV3_1.Document>;
-}
-
 /**
  * @internal
  */
@@ -67,15 +48,15 @@ declare function toOpenAPIMethod(method: HTTPMethod): Lowercase<HTTPMethod>;
 /**
  * @internal
  */
-declare function toOpenAPIContent(schema: JSONSchema): Record<string, OpenAPIV3_1.MediaTypeObject>;
+declare function toOpenAPIContent(schema: JSONSchema): Record<string, OpenAPI.MediaTypeObject>;
 /**
  * @internal
  */
-declare function toOpenAPIEventIteratorContent([yieldsRequired, yieldsSchema]: [boolean, JSONSchema], [returnsRequired, returnsSchema]: [boolean, JSONSchema]): Record<string, OpenAPIV3_1.MediaTypeObject>;
+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'): OpenAPIV3_1.ParameterObject[];
+declare function toOpenAPIParameters(schema: ObjectSchema, parameterIn: 'path' | 'query' | 'header' | 'cookie'): OpenAPI.ParameterObject[];
 /**
  * @internal
  */
@@ -83,7 +64,16 @@ declare function checkParamsSchema(schema: ObjectSchema, params: string[]): bool
 /**
  * @internal
  */
-declare function toOpenAPISchema(schema: JSONSchema): OpenAPIV3_1.SchemaObject & object;
+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
@@ -105,9 +95,22 @@ declare function separateObjectSchema(schema: ObjectSchema, separatedProperties:
  * @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 { CompositeSchemaConverter, type ConditionalSchemaConverter, type FileSchema, LOGIC_KEYWORDS, type ObjectSchema, OpenAPIGenerator, type OpenAPIGeneratorOptions, type OverrideOperationValue, type SchemaConvertOptions, type SchemaConverter, applyCustomOpenAPIOperation, checkParamsSchema, customOpenAPIOperation, filterSchemaBranches, getCustomOpenAPIOperation, isAnySchema, isFileSchema, isObjectSchema, oo, separateObjectSchema, toOpenAPIContent, toOpenAPIEventIteratorContent, toOpenAPIMethod, toOpenAPIParameters, toOpenAPIPath, toOpenAPISchema };
+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

@@ -1,523 +1,41 @@
-import { isProcedure, resolveContractProcedures } from '@orpc/server';
-import { fallbackORPCErrorStatus, fallbackORPCErrorMessage } from '@orpc/client';
-import { toHttpPath } from '@orpc/client/standard';
-import { fallbackContractConfig, getEventIteratorSchemaDetails } from '@orpc/contract';
-import { standardizeHTTPPath, StandardOpenAPIJsonSerializer, getDynamicParams } from '@orpc/openapi-client/standard';
-import { isObject, findDeepMatches, clone } from '@orpc/shared';
-export { Format as JSONSchemaFormat } from 'json-schema-typed/draft-2020-12';
-
-const OPERATION_EXTENDER_SYMBOL = Symbol("ORPC_OPERATION_EXTENDER");
-function customOpenAPIOperation(o, extend) {
-  return new Proxy(o, {
-    get(target, prop, receiver) {
-      if (prop === OPERATION_EXTENDER_SYMBOL) {
-        return extend;
-      }
-      return Reflect.get(target, prop, receiver);
-    }
-  });
-}
-function getCustomOpenAPIOperation(o) {
-  return o[OPERATION_EXTENDER_SYMBOL];
-}
-function applyCustomOpenAPIOperation(operation, contract) {
-  const operationCustoms = [];
-  for (const errorItem of Object.values(contract["~orpc"].errorMap)) {
-    const maybeExtender = errorItem ? getCustomOpenAPIOperation(errorItem) : void 0;
-    if (maybeExtender) {
-      operationCustoms.push(maybeExtender);
-    }
-  }
-  if (isProcedure(contract)) {
-    for (const middleware of contract["~orpc"].middlewares) {
-      const maybeExtender = getCustomOpenAPIOperation(middleware);
-      if (maybeExtender) {
-        operationCustoms.push(maybeExtender);
-      }
-    }
-  }
-  let currentOperation = operation;
-  for (const custom of operationCustoms) {
-    if (typeof custom === "function") {
-      currentOperation = custom(currentOperation, contract);
-    } else {
-      currentOperation = {
-        ...currentOperation,
-        ...custom
-      };
-    }
-  }
-  return currentOperation;
-}
-
-const LOGIC_KEYWORDS = [
-  "$dynamicRef",
-  "$ref",
-  "additionalItems",
-  "additionalProperties",
-  "allOf",
-  "anyOf",
-  "const",
-  "contains",
-  "contentEncoding",
-  "contentMediaType",
-  "contentSchema",
-  "dependencies",
-  "dependentRequired",
-  "dependentSchemas",
-  "else",
-  "enum",
-  "exclusiveMaximum",
-  "exclusiveMinimum",
-  "format",
-  "if",
-  "items",
-  "maxContains",
-  "maximum",
-  "maxItems",
-  "maxLength",
-  "maxProperties",
-  "minContains",
-  "minimum",
-  "minItems",
-  "minLength",
-  "minProperties",
-  "multipleOf",
-  "not",
-  "oneOf",
-  "pattern",
-  "patternProperties",
-  "prefixItems",
-  "properties",
-  "propertyNames",
-  "required",
-  "then",
-  "type",
-  "unevaluatedItems",
-  "unevaluatedProperties",
-  "uniqueItems"
-];
-
-function isFileSchema(schema) {
-  return isObject(schema) && schema.type === "string" && typeof schema.contentMediaType === "string";
-}
-function isObjectSchema(schema) {
-  return isObject(schema) && schema.type === "object";
-}
-function isAnySchema(schema) {
-  if (schema === true) {
-    return true;
-  }
-  if (Object.keys(schema).every((k) => !LOGIC_KEYWORDS.includes(k))) {
-    return true;
-  }
-  return false;
-}
-function separateObjectSchema(schema, separatedProperties) {
-  if (Object.keys(schema).some((k) => k !== "type" && k !== "properties" && k !== "required" && LOGIC_KEYWORDS.includes(k))) {
-    return [{ type: "object" }, schema];
-  }
-  const matched = { ...schema };
-  const rest = { ...schema };
-  matched.properties = schema.properties && Object.entries(schema.properties).filter(([key]) => separatedProperties.includes(key)).reduce((acc, [key, value]) => {
-    acc[key] = value;
-    return acc;
-  }, {});
-  matched.required = schema.required?.filter((key) => separatedProperties.includes(key));
-  matched.examples = schema.examples?.map((example) => {
-    if (!isObject(example)) {
-      return example;
-    }
-    return Object.entries(example).reduce((acc, [key, value]) => {
-      if (separatedProperties.includes(key)) {
-        acc[key] = value;
-      }
-      return acc;
-    }, {});
-  });
-  rest.properties = schema.properties && Object.entries(schema.properties).filter(([key]) => !separatedProperties.includes(key)).reduce((acc, [key, value]) => {
-    acc[key] = value;
-    return acc;
-  }, {});
-  rest.required = schema.required?.filter((key) => !separatedProperties.includes(key));
-  rest.examples = schema.examples?.map((example) => {
-    if (!isObject(example)) {
-      return example;
-    }
-    return Object.entries(example).reduce((acc, [key, value]) => {
-      if (!separatedProperties.includes(key)) {
-        acc[key] = value;
-      }
-      return acc;
-    }, {});
-  });
-  return [matched, rest];
-}
-function filterSchemaBranches(schema, check, matches = []) {
-  if (check(schema)) {
-    matches.push(schema);
-    return [matches, void 0];
-  }
-  if (isObject(schema)) {
-    for (const keyword of ["anyOf", "oneOf"]) {
-      if (schema[keyword] && Object.keys(schema).every(
-        (k) => k === keyword || !LOGIC_KEYWORDS.includes(k)
-      )) {
-        const rest = schema[keyword].map((s) => filterSchemaBranches(s, check, matches)[1]).filter((v) => !!v);
-        if (rest.length === 1 && typeof rest[0] === "object") {
-          return [matches, { ...schema, [keyword]: void 0, ...rest[0] }];
-        }
-        return [matches, { ...schema, [keyword]: rest }];
-      }
-    }
-  }
-  return [matches, schema];
-}
-
-function toOpenAPIPath(path) {
-  return standardizeHTTPPath(path).replace(/\/\{\+([^}]+)\}/g, "/{$1}");
-}
-function toOpenAPIMethod(method) {
-  return method.toLocaleLowerCase();
-}
-function toOpenAPIContent(schema) {
-  const content = {};
-  const [matches, restSchema] = filterSchemaBranches(schema, isFileSchema);
-  for (const file of matches) {
-    content[file.contentMediaType] = {
-      schema: toOpenAPISchema(file)
-    };
-  }
-  if (restSchema !== void 0) {
-    content["application/json"] = {
-      schema: toOpenAPISchema(restSchema)
-    };
-    const isStillHasFileSchema = findDeepMatches((v) => isObject(v) && isFileSchema(v), restSchema).values.length > 0;
-    if (isStillHasFileSchema) {
-      content["multipart/form-data"] = {
-        schema: toOpenAPISchema(restSchema)
-      };
-    }
-  }
-  return content;
-}
-function toOpenAPIEventIteratorContent([yieldsRequired, yieldsSchema], [returnsRequired, returnsSchema]) {
-  return {
-    "text/event-stream": {
-      schema: toOpenAPISchema({
-        oneOf: [
-          {
-            type: "object",
-            properties: {
-              event: { const: "message" },
-              data: yieldsSchema,
-              id: { type: "string" },
-              retry: { type: "number" }
-            },
-            required: yieldsRequired ? ["event", "data"] : ["event"]
-          },
-          {
-            type: "object",
-            properties: {
-              event: { const: "done" },
-              data: returnsSchema,
-              id: { type: "string" },
-              retry: { type: "number" }
-            },
-            required: returnsRequired ? ["event", "data"] : ["event"]
-          },
-          {
-            type: "object",
-            properties: {
-              event: { const: "error" },
-              data: {},
-              id: { type: "string" },
-              retry: { type: "number" }
-            },
-            required: ["event"]
-          }
-        ]
-      })
-    }
-  };
-}
-function toOpenAPIParameters(schema, parameterIn) {
-  const parameters = [];
-  for (const key in schema.properties) {
-    const keySchema = schema.properties[key];
-    parameters.push({
-      name: key,
-      in: parameterIn,
-      required: schema.required?.includes(key),
-      style: parameterIn === "query" ? "deepObject" : void 0,
-      explode: parameterIn === "query" ? true : void 0,
-      schema: toOpenAPISchema(keySchema)
-    });
-  }
-  return parameters;
-}
-function checkParamsSchema(schema, params) {
-  const properties = Object.keys(schema.properties ?? {});
-  const required = schema.required ?? [];
-  if (properties.length !== params.length || properties.some((v) => !params.includes(v))) {
-    return false;
-  }
-  if (required.length !== params.length || required.some((v) => !params.includes(v))) {
-    return false;
-  }
-  return true;
-}
-function toOpenAPISchema(schema) {
-  return schema === true ? {} : schema === false ? { not: {} } : schema;
-}
-
-class CompositeSchemaConverter {
-  converters;
-  constructor(converters) {
-    this.converters = converters;
-  }
-  convert(schema, options) {
-    for (const converter of this.converters) {
-      if (converter.condition(schema, options)) {
-        return converter.convert(schema, options);
-      }
-    }
-    return [false, {}];
-  }
-}
-
-class OpenAPIGeneratorError extends Error {
-}
-class OpenAPIGenerator {
-  serializer;
-  converter;
-  constructor(options = {}) {
-    this.serializer = new StandardOpenAPIJsonSerializer(options);
-    this.converter = new CompositeSchemaConverter(options.schemaConverters ?? []);
-  }
-  async generate(router, base) {
-    const doc = clone(base);
-    doc.openapi = "3.1.1";
-    const errors = [];
-    await resolveContractProcedures({ path: [], router }, ({ contract, path }) => {
-      const operationId = path.join(".");
-      try {
-        const def = contract["~orpc"];
-        const method = toOpenAPIMethod(fallbackContractConfig("defaultMethod", def.route.method));
-        const httpPath = toOpenAPIPath(def.route.path ?? toHttpPath(path));
-        const operationObjectRef = {
-          operationId,
-          summary: def.route.summary,
-          description: def.route.description,
-          deprecated: def.route.deprecated,
-          tags: def.route.tags?.map((tag) => tag)
-        };
-        this.#request(operationObjectRef, def);
-        this.#successResponse(operationObjectRef, def);
-        this.#errorResponse(operationObjectRef, def);
-        doc.paths ??= {};
-        doc.paths[httpPath] ??= {};
-        doc.paths[httpPath][method] = applyCustomOpenAPIOperation(operationObjectRef, contract);
-      } catch (e) {
-        if (!(e instanceof OpenAPIGeneratorError)) {
-          throw e;
-        }
-        errors.push(
-          `[OpenAPIGenerator] Error occurred while generating OpenAPI for procedure at path: ${operationId}
-${e.message}`
-        );
-      }
-    });
-    if (errors.length) {
-      throw new OpenAPIGeneratorError(
-        `Some error occurred during OpenAPI generation:
-
-${errors.join("\n\n")}`
-      );
-    }
-    return this.serializer.serialize(doc)[0];
-  }
-  #request(ref, def) {
-    const method = fallbackContractConfig("defaultMethod", def.route.method);
-    const details = getEventIteratorSchemaDetails(def.inputSchema);
-    if (details) {
-      ref.requestBody = {
-        required: true,
-        content: toOpenAPIEventIteratorContent(
-          this.converter.convert(details.yields, { strategy: "input" }),
-          this.converter.convert(details.returns, { strategy: "input" })
+import { c as customOpenAPIOperation } from './shared/openapi.CzHcOMxv.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.CzHcOMxv.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 '@orpc/interop/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()
         )
-      };
-      return;
-    }
-    const dynamicParams = getDynamicParams(def.route.path)?.map((v) => v.name);
-    const inputStructure = fallbackContractConfig("defaultInputStructure", def.route.inputStructure);
-    let [required, schema] = this.converter.convert(def.inputSchema, { strategy: "input" });
-    if (isAnySchema(schema) && !dynamicParams?.length) {
-      return;
-    }
-    if (inputStructure === "compact") {
-      if (dynamicParams?.length) {
-        const error2 = new OpenAPIGeneratorError(
-          'When input structure is "compact", and path has dynamic params, input schema must be an object with all dynamic params as required.'
-        );
-        if (!isObjectSchema(schema)) {
-          throw error2;
-        }
-        const [paramsSchema, rest] = separateObjectSchema(schema, dynamicParams);
-        schema = rest;
-        required = rest.required ? rest.required.length !== 0 : false;
-        if (!checkParamsSchema(paramsSchema, dynamicParams)) {
-          throw error2;
-        }
-        ref.parameters ??= [];
-        ref.parameters.push(...toOpenAPIParameters(paramsSchema, "path"));
-      }
-      if (method === "GET") {
-        if (!isObjectSchema(schema)) {
-          throw new OpenAPIGeneratorError(
-            'When method is "GET", input schema must satisfy: object | any | unknown'
-          );
-        }
-        ref.parameters ??= [];
-        ref.parameters.push(...toOpenAPIParameters(schema, "query"));
-      } else {
-        ref.requestBody = {
-          required,
-          content: toOpenAPIContent(schema)
-        };
-      }
-      return;
-    }
-    const error = new OpenAPIGeneratorError(
-      'When input structure is "detailed", input schema must satisfy: { params?: Record<string, unknown>, query?: Record<string, unknown>, headers?: Record<string, unknown>, body?: unknown }'
-    );
-    if (!isObjectSchema(schema)) {
-      throw error;
-    }
-    if (dynamicParams?.length && (schema.properties?.params === void 0 || !isObjectSchema(schema.properties.params) || !checkParamsSchema(schema.properties.params, dynamicParams))) {
-      throw new OpenAPIGeneratorError(
-        'When input structure is "detailed" and path has dynamic params, the "params" schema must be an object with all dynamic params as required.'
       );
-    }
-    for (const from of ["params", "query", "headers"]) {
-      const fromSchema = schema.properties?.[from];
-      if (fromSchema !== void 0) {
-        if (!isObjectSchema(fromSchema)) {
-          throw error;
-        }
-        const parameterIn = from === "params" ? "path" : from === "headers" ? "header" : "query";
-        ref.parameters ??= [];
-        ref.parameters.push(...toOpenAPIParameters(fromSchema, parameterIn));
-      }
-    }
-    if (schema.properties?.body !== void 0) {
-      ref.requestBody = {
-        required: schema.required?.includes("body"),
-        content: toOpenAPIContent(schema.properties.body)
-      };
-    }
-  }
-  #successResponse(ref, def) {
-    const outputSchema = def.outputSchema;
-    const status = fallbackContractConfig("defaultSuccessStatus", def.route.successStatus);
-    const description = fallbackContractConfig("defaultSuccessDescription", def.route?.successDescription);
-    const eventIteratorSchemaDetails = getEventIteratorSchemaDetails(outputSchema);
-    const outputStructure = fallbackContractConfig("defaultOutputStructure", def.route.outputStructure);
-    if (eventIteratorSchemaDetails) {
-      ref.responses ??= {};
-      ref.responses[status] = {
-        description,
-        content: toOpenAPIEventIteratorContent(
-          this.converter.convert(eventIteratorSchemaDetails.yields, { strategy: "output" }),
-          this.converter.convert(eventIteratorSchemaDetails.returns, { strategy: "output" })
-        )
-      };
-      return;
-    }
-    const [_, json] = this.converter.convert(outputSchema, { strategy: "output" });
-    ref.responses ??= {};
-    ref.responses[status] = {
-      description
-    };
-    if (outputStructure === "compact") {
-      ref.responses[status].content = toOpenAPIContent(json);
-      return;
-    }
-    const error = new OpenAPIGeneratorError(
-      'When output structure is "detailed", output schema must satisfy: { headers?: Record<string, unknown>, body?: unknown }'
-    );
-    if (!isObjectSchema(json)) {
-      throw error;
-    }
-    if (json.properties?.headers !== void 0) {
-      if (!isObjectSchema(json.properties.headers)) {
-        throw error;
-      }
-      for (const key in json.properties.headers.properties) {
-        ref.responses[status].headers ??= {};
-        ref.responses[status].headers[key] = {
-          schema: toOpenAPISchema(json.properties.headers.properties[key]),
-          required: json.properties.headers.required?.includes(key)
-        };
-      }
-    }
-    if (json.properties?.body !== void 0) {
-      ref.responses[status].content = toOpenAPIContent(json.properties.body);
-    }
-  }
-  #errorResponse(ref, def) {
-    const errorMap = def.errorMap;
-    const errors = {};
-    for (const code in errorMap) {
-      const config = errorMap[code];
-      if (!config) {
-        continue;
+    } catch (e) {
+      if (e instanceof ORPCError) {
+        throw createORPCErrorFromJson(serializer.deserialize(
+          serializer.serialize(
+            e.toJSON(),
+            { outputFormat: "plain" }
+          )
+        ));
       }
-      const status = fallbackORPCErrorStatus(code, config.status);
-      const message = fallbackORPCErrorMessage(code, config.message);
-      const [dataRequired, dataSchema] = this.converter.convert(config.data, { strategy: "output" });
-      errors[status] ??= [];
-      errors[status].push({
-        type: "object",
-        properties: {
-          defined: { const: true },
-          code: { const: code },
-          status: { const: status },
-          message: { type: "string", default: message },
-          data: dataSchema
-        },
-        required: dataRequired ? ["defined", "code", "status", "message", "data"] : ["defined", "code", "status", "message"]
-      });
+      throw e;
     }
-    ref.responses ??= {};
-    for (const status in errors) {
-      const schemas = errors[status];
-      ref.responses[status] = {
-        description: status,
-        content: toOpenAPIContent({
-          oneOf: [
-            ...schemas,
-            {
-              type: "object",
-              properties: {
-                defined: { const: false },
-                code: { type: "string" },
-                status: { type: "number" },
-                message: { type: "string" },
-                data: {}
-              },
-              required: ["defined", "code", "status", "message"]
-            }
-          ]
-        })
-      };
-    }
-  }
+  });
+  return createRouterClient(router, options);
 }
 
 const oo = {
   spec: customOpenAPIOperation
 };
 
-export { CompositeSchemaConverter, LOGIC_KEYWORDS, OpenAPIGenerator, applyCustomOpenAPIOperation, checkParamsSchema, customOpenAPIOperation, filterSchemaBranches, getCustomOpenAPIOperation, isAnySchema, isFileSchema, isObjectSchema, oo, separateObjectSchema, toOpenAPIContent, toOpenAPIEventIteratorContent, toOpenAPIMethod, toOpenAPIParameters, toOpenAPIPath, toOpenAPISchema };
+export { createJsonifiedRouterClient, customOpenAPIOperation, oo };