@orpc/openapi 1.14.5 → 2.0.0-beta.1

package/dist/index.mjs

@@ -1,41 +1,901 @@
-import { c as customOpenAPIOperation } from './shared/openapi.BwdtJjDu.mjs';
-export { C as CompositeSchemaConverter, L as LOGIC_KEYWORDS, O as OpenAPIGenerator, a as applyCustomOpenAPIOperation, p as applySchemaOptionality, h as checkParamsSchema, u as expandArrayableSchema, q as expandUnionSchema, o as filterSchemaBranches, g as getCustomOpenAPIOperation, l as isAnySchema, j as isFileSchema, m as isNeverSchema, k as isObjectSchema, v as isPrimitiveSchema, r as resolveOpenAPIJsonSchemaRef, n 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.BwdtJjDu.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';
+export { B as BracketNotationSerializer } from './shared/openapi.Bt87OzTt.mjs';
+import { createContractCaller, getEventIteratorSchemaDetails } from '@orpc/contract';
+import { g as getOpenAPIMeta } from './shared/openapi.B9PQzqBn.mjs';
+export { o as openapi } from './shared/openapi.B9PQzqBn.mjs';
+import { COMMON_ERROR_STATUS_MAP } from '@orpc/client';
+export { COMMON_ERROR_STATUS_MAP } from '@orpc/client';
+import { DelegatingJsonSchemaConverter, StandardJsonSchemaConverter, combineJsonSchemasWithComposition, isUnconstrainedSchema, extractJsonObjectSchemaEntries, combineJsonObjectSchemaEntries, isJsonPrimitiveSchema, matchArrayableJsonSchema, flattenJsonUnionSchema, ensureJsonSchemaObject, isJsonFileSchema, mapJsonSchemaRefs, encodeJsonPointerSegment, decodeJsonPointerSegment } from '@orpc/json-schema';
+import { walkProcedureContractsAsync, DEFAULT_SUCCESS_STATUS, DEFAULT_ERROR_STATUS } from '@orpc/server';
+import { toArray, clone, value, pathToHttpPath, mergeHttpPath, stringifyJSON, findDeepMatches, isPlainObject, isDeepEqual } from '@orpc/shared';
+import { O as OpenAPISerializer, D as DEFAULT_OPENAPI_METHOD, g as getDynamicPathParams, a as DEFAULT_OPENAPI_INPUT_STRUCTURE, c as DEFAULT_OPENAPI_SUCCESS_DESCRIPTION, b as DEFAULT_OPENAPI_OUTPUT_STRUCTURE } from './shared/openapi.DmAa7YPO.mjs';
+export { d as OpenAPIJsonSerializer } from './shared/openapi.DmAa7YPO.mjs';
+import '@standardserver/core';
 
-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()
-        )
+function createContractJsonifiedCaller(link, options = {}) {
+  return createContractCaller(link, options);
+}
+
+class OpenAPIGeneratorError extends TypeError {
+}
+class OpenAPIGenerator {
+  serializer;
+  converter;
+  constructor(options = {}) {
+    this.serializer = options.serializer ?? new OpenAPISerializer();
+    this.converter = new DelegatingJsonSchemaConverter([
+      ...toArray(options.converters),
+      new StandardJsonSchemaConverter()
+    ]);
+  }
+  async generate(router, options = {}) {
+    const doc = {
+      ...clone(options.base),
+      openapi: options.base?.openapi ?? "3.1.2",
+      info: options.base?.info ?? { title: "API Reference", version: "0.0.0" }
+    };
+    const errors = [];
+    await walkProcedureContractsAsync(router, async (contract, path) => {
+      if (value(options.filter, contract, path) === false) {
+        return;
+      }
+      try {
+        const def = contract["~orpc"];
+        const meta = getOpenAPIMeta(contract);
+        const method = (meta?.method ?? DEFAULT_OPENAPI_METHOD).toLowerCase();
+        const postPath = meta?.path ?? pathToHttpPath(path);
+        const httpPath = meta?.prefix ? mergeHttpPath(meta.prefix, postPath) : postPath;
+        const dynamicPathParams = getDynamicPathParams(httpPath);
+        const openApiPath = toOpenAPIPath(httpPath, dynamicPathParams);
+        let operationRef;
+        if (meta?.spec !== void 0 && typeof meta.spec !== "function") {
+          operationRef = meta.spec;
+        } else {
+          operationRef = {
+            operationId: meta?.operationId ?? path.join("."),
+            summary: meta?.summary,
+            description: meta?.description,
+            deprecated: meta?.deprecated,
+            tags: meta?.tags?.map((tag) => tag)
+          };
+          await this.request(doc, operationRef, def, meta, dynamicPathParams, options, path);
+          await this.successResponse(doc, operationRef, def, meta, options, path);
+          await this.errorResponse(doc, operationRef, def, meta, options);
+        }
+        if (typeof meta?.spec === "function") {
+          operationRef = meta.spec(operationRef);
+        }
+        doc.paths ??= {};
+        doc.paths[openApiPath] ??= {};
+        doc.paths[openApiPath][method] = operationRef;
+      } catch (e) {
+        if (!(e instanceof OpenAPIGeneratorError)) {
+          throw e;
+        }
+        errors.push(
+          `[OpenAPIGenerator] Error occurred while generating OpenAPI for procedure at path: ${path.join(".")}
+${e.message}`
+        );
+      }
+    });
+    if (errors.length) {
+      throw new OpenAPIGeneratorError(
+        `Some error occurred during OpenAPI generation:
+
+${errors.join("\n\n")}`
       );
-    } catch (e) {
-      if (e instanceof ORPCError) {
-        throw createORPCErrorFromJson(serializer.deserialize(
-          serializer.serialize(
-            e.toJSON(),
-            { outputFormat: "plain" }
-          )
-        ));
+    }
+    return this.serializer.serialize(doc, { asFormData: false, useFormDataForBlobFields: false });
+  }
+  async convertSchema(schema, direction) {
+    const [jsonSchema, optional] = await this.converter.convert(schema, direction);
+    return [strip$schemaField(jsonSchema), optional];
+  }
+  async convertSchemas(schemas, direction) {
+    if (!schemas || schemas.length <= 1) {
+      return this.convertSchema(schemas?.[0], direction);
+    }
+    const results = await Promise.all(schemas.map((s) => this.convertSchema(s, direction)));
+    const allOfSchemas = [];
+    let optional = true;
+    for (const [jsonSchema, opt] of results) {
+      allOfSchemas.push(jsonSchema);
+      if (!opt) {
+        optional = false;
+      }
+    }
+    return [combineJsonSchemasWithComposition("allOf", allOfSchemas), optional];
+  }
+  async request(doc, ref, def, meta, dynamicPathParams, options, path) {
+    const method = meta?.method ?? DEFAULT_OPENAPI_METHOD;
+    const inputStructure = meta?.inputStructure ?? DEFAULT_OPENAPI_INPUT_STRUCTURE;
+    const inputSchemas = def.inputSchemas;
+    if (inputStructure === "compact") {
+      const eventIteratorDetails = getEventIteratorDetails(inputSchemas);
+      if (eventIteratorDetails) {
+        const [yieldSchemas, returnSchemas] = eventIteratorDetails;
+        const yieldResult = await this.convertSchemas(yieldSchemas, "input");
+        const returnResult = await this.convertSchemas(returnSchemas, "input");
+        ref.requestBody = {
+          required: true,
+          content: toEventIteratorContent(yieldResult, returnResult, doc, options)
+        };
+        return;
+      }
+    }
+    const dynamicParams = dynamicPathParams?.map((v) => v.parameterName);
+    const [schema, optional] = await this.convertSchemas(inputSchemas, "input");
+    if (isUnconstrainedSchema(schema) && !dynamicParams?.length) {
+      return;
+    }
+    const objectSchemaEntries = extractJsonObjectSchemaEntries(schema);
+    if (!objectSchemaEntries) {
+      if (inputStructure === "detailed") {
+        throw new OpenAPIGeneratorError(
+          `Procedure at path "${path.join(".")}" has inputStructure "detailed" but its input schema is not an object.
+  Expected shape: { params?: Record<string, unknown>, query?: Record<string, unknown>, headers?: Record<string, unknown>, body?: unknown }`
+        );
+      }
+      if (method === "GET") {
+        throw new OpenAPIGeneratorError(
+          `Procedure at path "${path.join(".")}" uses method "GET" but its input schema is not an object.
+  GET procedures map all input fields to query parameters, so the schema must be an object.
+  Expected: Record<string, unknown>`
+        );
+      }
+    }
+    const paramsObjectSchemaEntries = inputStructure === "compact" ? objectSchemaEntries?.filter(([name]) => dynamicParams?.includes(name)) : extractJsonObjectSchemaEntries(objectSchemaEntries?.find(([name]) => name === "params")?.[1] ?? false);
+    const queryObjectSchemaEntries = inputStructure === "compact" ? method === "GET" ? objectSchemaEntries?.filter(([name]) => !dynamicParams?.includes(name)) : void 0 : extractJsonObjectSchemaEntries(objectSchemaEntries?.find(([name]) => name === "query")?.[1] ?? false);
+    const headersObjectSchemaEntries = inputStructure === "compact" ? void 0 : extractJsonObjectSchemaEntries(objectSchemaEntries?.find(([name]) => name === "headers")?.[1] ?? false);
+    const bodySchema = inputStructure === "compact" ? method === "GET" || method === "HEAD" ? void 0 : !dynamicParams?.length ? schema : objectSchemaEntries ? combineJsonObjectSchemaEntries(objectSchemaEntries?.filter(([name]) => !dynamicParams?.includes(name))) : void 0 : objectSchemaEntries?.find(([name]) => name === "body")?.[1];
+    if (dynamicParams?.length) {
+      if (!paramsObjectSchemaEntries) {
+        throw new OpenAPIGeneratorError(
+          `Procedure at path "${path.join(".")}" has dynamic path params (${dynamicParams.map((p) => p).join(", ")}) but its input schema is not an object.
+  Each dynamic param must appear as a required key in the schema.`
+        );
+      }
+      dynamicParams.forEach((name) => {
+        const entry = paramsObjectSchemaEntries.find(([n]) => n === name);
+        if (!entry) {
+          throw new OpenAPIGeneratorError(
+            `Procedure at path "${path.join(".")}" is missing dynamic param "${name}" in its input schema.
+  Route params: ${dynamicParams.map((p) => `{${p}}`).join(", ")}
+  Schema keys:  ${paramsObjectSchemaEntries.map(([n]) => n).join(", ") || "(none)"}`
+          );
+        }
+        if (entry[2]) {
+          throw new OpenAPIGeneratorError(
+            `Procedure at path "${path.join(".")}" has dynamic param "${name}" marked as optional in its input schema, but path params must always be required in OpenAPI.`
+          );
+        }
+        ref.parameters ??= [];
+        ref.parameters.push({
+          in: "path",
+          required: true,
+          name,
+          schema: toOpenAPISchema(entry[1], doc, options)
+        });
+      });
+    }
+    if (queryObjectSchemaEntries) {
+      queryObjectSchemaEntries.forEach(([name, schema2, optional2]) => {
+        const style = meta?.queryStyles?.[name];
+        const parameter = {
+          in: "query",
+          name,
+          schema: toOpenAPISchema(schema2, doc, options),
+          allowEmptyValue: true,
+          allowReserved: true
+        };
+        if (!optional2) {
+          parameter.required = true;
+        }
+        if (style === "comma-delimited-array" || style === "comma-delimited-object") {
+          parameter.explode = false;
+        } else if (style === "pipe-delimited-array" || style === "pipe-delimited-object") {
+          parameter.style = "pipeDelimited";
+        } else if (style === "space-delimited-array" || style === "space-delimited-object") {
+          parameter.style = "spaceDelimited";
+        } else if (style === "json") {
+          parameter.content = {
+            "application/json": { schema: parameter.schema }
+          };
+          delete parameter.schema;
+        } else if (style === void 0) {
+          if (!isJsonPrimitiveSchema(schema2)) {
+            const arrayable = matchArrayableJsonSchema(schema2);
+            if (!arrayable || !isJsonPrimitiveSchema(arrayable[0])) {
+              parameter.style = "deepObject";
+              parameter.explode = true;
+            }
+          }
+        } else ;
+        ref.parameters ??= [];
+        ref.parameters.push(parameter);
+      });
+    }
+    if (headersObjectSchemaEntries) {
+      headersObjectSchemaEntries.forEach(([name, schema2, optional2]) => {
+        ref.parameters ??= [];
+        ref.parameters.push({
+          in: "header",
+          name,
+          required: optional2 ? void 0 : true,
+          schema: toOpenAPISchema(schema2, doc, options)
+        });
+      });
+    }
+    if (bodySchema !== void 0) {
+      const bodyOptional = inputStructure === "compact" ? !dynamicParams?.length ? optional : objectSchemaEntries?.filter(([name]) => !dynamicParams?.includes(name)).every(([, , optional2]) => optional2) : objectSchemaEntries?.find(([name]) => name === "body")?.[2];
+      ref.requestBody = {
+        required: bodyOptional ? void 0 : true,
+        content: toBodyContent(bodySchema, doc, options)
+      };
+    }
+  }
+  async successResponse(doc, ref, def, meta, options, path) {
+    const outputSchemas = def.outputSchemas;
+    const status = meta?.successStatus ?? DEFAULT_SUCCESS_STATUS;
+    const description = meta?.successDescription ?? DEFAULT_OPENAPI_SUCCESS_DESCRIPTION;
+    const outputStructure = meta?.outputStructure ?? DEFAULT_OPENAPI_OUTPUT_STRUCTURE;
+    if (outputStructure === "compact") {
+      const eventDetails = getEventIteratorDetails(outputSchemas);
+      if (eventDetails) {
+        const [yieldSchemas, returnSchemas] = eventDetails;
+        const yieldResult = await this.convertSchemas(yieldSchemas, "output");
+        const returnResult = await this.convertSchemas(returnSchemas, "output");
+        ref.responses ??= {};
+        ref.responses[status] = {
+          description,
+          content: toEventIteratorContent(yieldResult, returnResult, doc, options)
+        };
+        return;
       }
-      throw e;
     }
+    const [schema] = await this.convertSchemas(outputSchemas, "output");
+    if (isUnconstrainedSchema(schema) || outputStructure === "compact") {
+      ref.responses ??= {};
+      ref.responses[status] = {
+        description,
+        content: toBodyContent(schema, doc, options)
+      };
+      return;
+    }
+    const schemasByStatus = /* @__PURE__ */ new Map();
+    for (const item of flattenJsonUnionSchema(schema)) {
+      const objectSchemaEntries = extractJsonObjectSchemaEntries(item);
+      if (!objectSchemaEntries) {
+        throw new OpenAPIGeneratorError(
+          `Procedure at path "${path.join(".")}" has outputStructure "detailed" but its output schema is not an object.
+  Expected shape: { status: number (200-299), headers?: Record<string, unknown>, body?: unknown }`
+        );
+      }
+      const statusSchema = objectSchemaEntries?.find(([name]) => name === "status")?.[1];
+      if (statusSchema !== void 0 && (typeof statusSchema !== "object" || !Number.isInteger(statusSchema.const) || statusSchema.const < 200 || statusSchema.const >= 300)) {
+        throw new OpenAPIGeneratorError(
+          `Procedure at path "${path.join(".")}" has an invalid "status" field in its outputStructure "detailed" schema.
+  Expected: a const integer in the 200-299 range
+  Received: ${stringifyJSON(statusSchema)}`
+        );
+      }
+      const status2 = (statusSchema?.const || void 0) ?? meta?.successStatus ?? DEFAULT_SUCCESS_STATUS;
+      const description2 = statusSchema?.description;
+      const schemas = schemasByStatus.get(status2);
+      const headersSchema = objectSchemaEntries?.find(([name]) => name === "headers")?.[1];
+      const bodySchema = objectSchemaEntries?.find(([name]) => name === "body")?.[1];
+      if (schemas) {
+        schemas.push({ description: description2, headers: headersSchema, body: bodySchema });
+      } else {
+        schemasByStatus.set(status2, [{ description: description2, headers: headersSchema, body: bodySchema }]);
+      }
+    }
+    for (const [status2, schemas] of schemasByStatus.entries()) {
+      const descriptions = schemas.map(({ description: description2 }) => description2).filter((d) => d !== void 0);
+      const responseObject = {
+        description: descriptions.length ? descriptions.join(", ") : description
+      };
+      const bodySchemas = schemas.map(({ body }) => body).filter((b) => b !== void 0);
+      if (bodySchemas.length) {
+        responseObject.content = toBodyContent(combineJsonSchemasWithComposition("anyOf", bodySchemas), doc, options);
+      }
+      const headerSchemas = schemas.map(({ headers }) => headers).filter((b) => b !== void 0);
+      if (headerSchemas.length) {
+        const entries = extractJsonObjectSchemaEntries(combineJsonSchemasWithComposition("anyOf", headerSchemas));
+        entries?.forEach(([name, schema2, optional]) => {
+          responseObject.headers ??= {};
+          responseObject.headers[name] = {
+            required: optional ? void 0 : true,
+            schema: toOpenAPISchema(schema2, doc, options)
+          };
+        });
+      }
+      ref.responses ??= {};
+      ref.responses[status2] = responseObject;
+    }
+  }
+  async errorResponse(doc, ref, def, meta, options) {
+    const errorStatusMap = options.errorStatusMap ?? COMMON_ERROR_STATUS_MAP;
+    const errorMap = def.errorMap;
+    const errorDefinitionsByStatus = /* @__PURE__ */ new Map();
+    for (const code in errorMap) {
+      const config = errorMap[code];
+      if (!config) {
+        continue;
+      }
+      const status = errorStatusMap[code] ?? DEFAULT_ERROR_STATUS;
+      const defaultMessage = config.message;
+      const [dataJsonSchema, dataOptional] = await this.convertSchema(config.data, "output");
+      const definitions = errorDefinitionsByStatus.get(status);
+      if (definitions) {
+        definitions.push({ code, dataJsonSchema, dataOptional, defaultMessage });
+      } else {
+        errorDefinitionsByStatus.set(status, [{ code, dataJsonSchema, dataOptional, defaultMessage }]);
+      }
+    }
+    if (errorDefinitionsByStatus.size) {
+      const undefinedErrorSchema = hoistDefs({
+        $defs: {
+          UndefinedError: {
+            type: "object",
+            properties: {
+              defined: { const: false },
+              inferable: { type: "boolean" },
+              code: { type: "string" },
+              status: { type: "number" },
+              message: { type: "string" },
+              data: {}
+            },
+            required: ["defined", "inferable", "code", "status", "message"]
+          }
+        },
+        $ref: "#/$defs/UndefinedError"
+      }, doc, options);
+      for (const [status, definitions] of errorDefinitionsByStatus.entries()) {
+        const descriptions = definitions.map(({ defaultMessage }) => defaultMessage).filter((m) => m !== void 0);
+        const customBodySchema = value(
+          options.customErrorResponseBodySchema,
+          definitions.map((def2) => ({ ...def2, dataJsonSchema: hoistDefs(def2.dataJsonSchema, doc, options) })),
+          status
+        );
+        const responseSchema = customBodySchema ?? combineJsonSchemasWithComposition("oneOf", [
+          ...definitions.map(({ code, dataJsonSchema, dataOptional, defaultMessage }) => {
+            return combineJsonObjectSchemaEntries([
+              ["defined", { const: true }, false],
+              ["inferable", { type: "boolean" }, false],
+              ["code", { const: code }, false],
+              ["status", { const: status }, false],
+              ["message", { type: "string", default: defaultMessage }, false],
+              ["data", dataJsonSchema, dataOptional]
+            ]);
+          }),
+          undefinedErrorSchema
+        ]);
+        ref.responses ??= {};
+        ref.responses[status] = {
+          description: descriptions.length ? descriptions.join(", ") : status.toString(),
+          content: {
+            "application/json": {
+              schema: toOpenAPISchema(responseSchema, doc, options)
+            }
+          }
+        };
+      }
+    }
+  }
+}
+function toOpenAPISchema(schema, doc, options) {
+  return ensureJsonSchemaObject(hoistDefs(
+    schema,
+    doc,
+    options
+  ));
+}
+function toOpenAPIPath(path, dynamicPathParams) {
+  if (!dynamicPathParams?.length) {
+    return path;
+  }
+  let normalized = "";
+  let currentIndex = 0;
+  for (const param of dynamicPathParams) {
+    normalized += path.slice(currentIndex, param.startIndex);
+    normalized += `{${param.parameterName}}`;
+    currentIndex = param.startIndex + param.segment.length;
+  }
+  normalized += path.slice(currentIndex);
+  return normalized;
+}
+function strip$schemaField(schema) {
+  if (typeof schema !== "object") {
+    return schema;
+  }
+  const { $schema, ...rest } = schema;
+  return rest;
+}
+function getEventIteratorDetails(schemas) {
+  if (!schemas || schemas.length === 0) {
+    return void 0;
+  }
+  const yieldSchemas = [];
+  const returnSchemas = [];
+  for (const s of schemas) {
+    const details = getEventIteratorSchemaDetails(s);
+    if (!details) {
+      return void 0;
+    }
+    yieldSchemas.push(details.yieldSchema);
+    if (details.returnSchema) {
+      returnSchemas.push(details.returnSchema);
+    }
+  }
+  return yieldSchemas.length || returnSchemas.length ? [yieldSchemas, returnSchemas] : void 0;
+}
+function toEventIteratorContent([yieldSchema, yieldOptional], [returnSchema, returnOptional], doc, options) {
+  const schema = combineJsonSchemasWithComposition("oneOf", [
+    combineJsonObjectSchemaEntries([
+      ["event", { const: "message" }, false],
+      ["data", yieldSchema, yieldOptional],
+      ["id", { type: "string" }, true],
+      ["retry", { type: "number" }, true]
+    ]),
+    combineJsonObjectSchemaEntries([
+      ["event", { const: "close" }, false],
+      ["data", returnSchema, returnOptional],
+      ["id", { type: "string" }, true],
+      ["retry", { type: "number" }, true]
+    ]),
+    {
+      type: "object",
+      properties: {
+        event: { const: "error" },
+        data: {},
+        id: { type: "string" },
+        retry: { type: "number" }
+      },
+      required: ["event"]
+    }
+  ]);
+  return {
+    "text/event-stream": {
+      schema: toOpenAPISchema(schema, doc, options)
+    }
+  };
+}
+function toBodyContent(schema, doc, options) {
+  const fileSchemasByMediaType = /* @__PURE__ */ new Map();
+  const rest = flattenJsonUnionSchema(schema).filter((s) => {
+    if (!isJsonFileSchema(s)) {
+      return !isUnconstrainedSchema(s);
+    }
+    const contentMediaType = s.contentMediaType ?? "*/*";
+    const schemas = fileSchemasByMediaType.get(contentMediaType);
+    if (schemas) {
+      schemas.push(s);
+    } else {
+      fileSchemasByMediaType.set(contentMediaType, [s]);
+    }
+    return false;
+  });
+  const content = {};
+  if (rest.length > 0) {
+    const restSchema = fileSchemasByMediaType.size ? combineJsonSchemasWithComposition("anyOf", rest) : schema;
+    const hasNestedFiles = findDeepMatches(
+      (v) => isPlainObject(v) && isJsonFileSchema(v),
+      restSchema
+    ).values.length > 0;
+    const contentType = hasNestedFiles ? "multipart/form-data" : "application/json";
+    const fileSchemas = fileSchemasByMediaType.get(contentType);
+    fileSchemasByMediaType.delete(contentType);
+    content[contentType] = {
+      schema: toOpenAPISchema(combineJsonSchemasWithComposition("anyOf", [restSchema, ...toArray(fileSchemas)]), doc, options)
+    };
+  }
+  for (const [contentType, schemas] of fileSchemasByMediaType.entries()) {
+    content[contentType] = {
+      schema: toOpenAPISchema(combineJsonSchemasWithComposition("anyOf", schemas), doc, options)
+    };
+  }
+  return content;
+}
+function hoistDefs(schema, doc, options) {
+  if (typeof schema !== "object") {
+    return schema;
+  }
+  if (!schema.$defs) {
+    return schema;
+  }
+  const { $defs, ...rest } = schema;
+  const localDefs = {};
+  const hoistedDefs = {};
+  for (const defName of Object.keys($defs)) {
+    const defSchema = $defs[defName];
+    if (defSchema === void 0) {
+      continue;
+    }
+    const normalized = normalizeHoistedDefSchema(defSchema);
+    if (value(options.shouldHoistDef, defName, normalized) !== false) {
+      hoistedDefs[defName] = normalized;
+    } else {
+      localDefs[defName] = normalized;
+    }
+  }
+  hoistReferencedLocalDefs(hoistedDefs, localDefs);
+  if (Object.keys(hoistedDefs).length === 0) {
+    return schema;
+  }
+  doc.components ??= {};
+  doc.components.schemas ??= {};
+  const componentsSchemas = doc.components.schemas;
+  const identityRenameMap = Object.fromEntries(
+    Object.keys(hoistedDefs).map((defName) => [defName, defName])
+  );
+  const renameMap = {};
+  const pendingSchemas = [];
+  for (const defName of Object.keys(hoistedDefs)) {
+    const cleanSchema = hoistedDefs[defName];
+    const existingSchema = componentsSchemas[defName];
+    const candidateSchemas = Object.fromEntries(
+      Object.keys(hoistedDefs).map((currentDefName) => [
+        currentDefName,
+        rewriteComponentSchemaRefs(
+          withReferencedLocalDefs(hoistedDefs[currentDefName], localDefs),
+          {
+            ...identityRenameMap,
+            ...renameMap
+          }
+        )
+      ])
+    );
+    const prelimSchema = candidateSchemas[defName];
+    if (existingSchema !== void 0) {
+      const reusableComponentName = findReusableComponentName(componentsSchemas, defName, prelimSchema, candidateSchemas);
+      if (reusableComponentName !== void 0) {
+        renameMap[defName] = reusableComponentName;
+        continue;
+      }
+      const componentName = findUniqueComponentName(componentsSchemas, defName);
+      renameMap[defName] = componentName;
+      pendingSchemas.push({ cleanSchema, componentName });
+    } else {
+      const reusableComponentName = findReusableComponentName(componentsSchemas, defName, prelimSchema, candidateSchemas);
+      if (reusableComponentName !== void 0) {
+        renameMap[defName] = reusableComponentName;
+        continue;
+      }
+      renameMap[defName] = defName;
+      pendingSchemas.push({ cleanSchema, componentName: defName });
+    }
+  }
+  for (const { cleanSchema, componentName } of pendingSchemas) {
+    componentsSchemas[componentName] = rewriteComponentSchemaRefs(
+      withReferencedLocalDefs(cleanSchema, localDefs),
+      renameMap
+    );
+  }
+  return rewriteComponentSchemaRefs(withReferencedLocalDefs(rest, localDefs), renameMap);
+}
+function normalizeHoistedDefSchema(schema) {
+  let cleanSchema = typeof schema === "boolean" ? schema ? {} : { not: {} } : { ...schema };
+  if (cleanSchema.additionalProperties === false) {
+    const { additionalProperties: _ignored, ...withoutAdditionalProperties } = cleanSchema;
+    cleanSchema = withoutAdditionalProperties;
+  }
+  return cleanSchema;
+}
+function hoistReferencedLocalDefs(hoistedDefs, localDefs) {
+  const queue = Object.values(hoistedDefs);
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (current === void 0) {
+      continue;
+    }
+    visitSchemaRefs(current, (refName) => {
+      const referenced = localDefs[refName];
+      if (referenced === void 0) {
+        return;
+      }
+      hoistedDefs[refName] = referenced;
+      delete localDefs[refName];
+      queue.push(referenced);
+    });
+  }
+}
+function withReferencedLocalDefs(schema, localDefs) {
+  const referencedLocalDefs = collectReferencedLocalDefNames(schema, localDefs);
+  if (referencedLocalDefs.length === 0) {
+    return schema;
+  }
+  const mergedDefs = {
+    ...schema.$defs
+  };
+  for (const defName of referencedLocalDefs) {
+    mergedDefs[defName] = localDefs[defName];
+  }
+  return {
+    ...schema,
+    $defs: mergedDefs
+  };
+}
+function collectReferencedLocalDefNames(schema, localDefs) {
+  if (Object.keys(localDefs).length === 0) {
+    return [];
+  }
+  const referenced = /* @__PURE__ */ new Set();
+  const queued = /* @__PURE__ */ new Set();
+  const queue = [schema];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (current === void 0) {
+      continue;
+    }
+    visitSchemaRefs(current, (refName) => {
+      if (localDefs[refName] === void 0 || referenced.has(refName)) {
+        return;
+      }
+      referenced.add(refName);
+      if (!queued.has(refName)) {
+        queued.add(refName);
+        queue.push(localDefs[refName]);
+      }
+    });
+  }
+  return [...referenced];
+}
+function visitSchemaRefs(schema, onRef, seen = /* @__PURE__ */ new Set()) {
+  if (typeof schema !== "object" || schema === null) {
+    return;
+  }
+  if (seen.has(schema)) {
+    return;
+  }
+  seen.add(schema);
+  if (typeof schema.$ref === "string") {
+    const refName = parseLocalDefRefName(schema.$ref);
+    if (refName !== void 0) {
+      onRef(refName);
+    }
+  }
+  for (const keyword of ["allOf", "anyOf", "oneOf"]) {
+    if (Array.isArray(schema[keyword])) {
+      for (const item of schema[keyword]) {
+        visitSchemaRefs(item, onRef, seen);
+      }
+    }
+  }
+  if (schema.properties) {
+    for (const property of Object.values(schema.properties)) {
+      visitSchemaRefs(property, onRef, seen);
+    }
+  }
+  if (schema.items !== void 0) {
+    visitSchemaRefs(schema.items, onRef, seen);
+  }
+  if (typeof schema.additionalProperties === "object" && schema.additionalProperties !== null) {
+    visitSchemaRefs(schema.additionalProperties, onRef, seen);
+  }
+  if (schema.not !== void 0) {
+    visitSchemaRefs(schema.not, onRef, seen);
+  }
+  if (schema.if !== void 0) {
+    visitSchemaRefs(schema.if, onRef, seen);
+  }
+  if (schema.then !== void 0) {
+    visitSchemaRefs(schema.then, onRef, seen);
+  }
+  if (schema.else !== void 0) {
+    visitSchemaRefs(schema.else, onRef, seen);
+  }
+  if (Array.isArray(schema.prefixItems)) {
+    for (const item of schema.prefixItems) {
+      visitSchemaRefs(item, onRef, seen);
+    }
+  }
+  if (schema.$defs) {
+    for (const def of Object.values(schema.$defs)) {
+      if (def !== void 0) {
+        visitSchemaRefs(def, onRef, seen);
+      }
+    }
+  }
+}
+function findUniqueComponentName(componentsSchemas, baseName) {
+  const candidate = `${baseName}`;
+  if (componentsSchemas[candidate] === void 0)
+    return candidate;
+  let i = 2;
+  while (componentsSchemas[`${baseName}${i}`] !== void 0) {
+    i++;
+  }
+  return `${baseName}${i}`;
+}
+function findReusableComponentName(componentsSchemas, defName, schema, candidateSchemas) {
+  const exactMatch = componentsSchemas[defName];
+  if (exactMatch !== void 0 && areSchemasEquivalentForReuse(
+    schema,
+    exactMatch,
+    schema,
+    exactMatch,
+    candidateSchemas,
+    componentsSchemas,
+    /* @__PURE__ */ new Map([[defName, defName]]),
+    /* @__PURE__ */ new Map([[defName, defName]])
+  )) {
+    return defName;
+  }
+  for (const [componentName, componentSchema] of Object.entries(componentsSchemas)) {
+    if (componentName === defName) {
+      continue;
+    }
+    if (areSchemasEquivalentForReuse(
+      schema,
+      componentSchema,
+      schema,
+      componentSchema,
+      candidateSchemas,
+      componentsSchemas,
+      /* @__PURE__ */ new Map([[defName, componentName]]),
+      /* @__PURE__ */ new Map([[componentName, defName]])
+    )) {
+      return componentName;
+    }
+  }
+  return void 0;
+}
+function areSchemasEquivalentForReuse(candidate, existing, candidateRootSchema, existingRootSchema, candidateSchemas, existingSchemas, candidateToExistingComponentNames, existingToCandidateComponentNames, visited = /* @__PURE__ */ new WeakMap()) {
+  if (candidate === existing) {
+    return true;
+  }
+  if (typeof candidate !== typeof existing) {
+    return false;
+  }
+  if (candidate === null || existing === null) {
+    return candidate === existing;
+  }
+  if (typeof candidate !== "object" || typeof existing !== "object") {
+    return isDeepEqual(candidate, existing);
+  }
+  const seenExisting = visited.get(candidate);
+  if (seenExisting?.has(existing)) {
+    return true;
+  }
+  if (seenExisting) {
+    seenExisting.add(existing);
+  } else {
+    visited.set(candidate, new WeakSet([existing]));
+  }
+  if (Array.isArray(candidate) || Array.isArray(existing)) {
+    if (!Array.isArray(candidate) || !Array.isArray(existing) || candidate.length !== existing.length) {
+      return false;
+    }
+    return candidate.every((item, index) => areSchemasEquivalentForReuse(
+      item,
+      existing[index],
+      candidateRootSchema,
+      existingRootSchema,
+      candidateSchemas,
+      existingSchemas,
+      candidateToExistingComponentNames,
+      existingToCandidateComponentNames,
+      visited
+    ));
+  }
+  const candidateObject = candidate;
+  const existingObject = existing;
+  const candidateKeys = Object.keys(candidateObject).sort();
+  const existingKeys = Object.keys(existingObject).sort();
+  if (!isDeepEqual(candidateKeys, existingKeys)) {
+    return false;
+  }
+  return candidateKeys.every((key) => {
+    const candidateValue = candidateObject[key];
+    const existingValue = existingObject[key];
+    if (key === "$ref" && typeof candidateValue === "string" && typeof existingValue === "string") {
+      return areSchemaRefsEquivalentForReuse(
+        candidateValue,
+        existingValue,
+        candidateRootSchema,
+        existingRootSchema,
+        candidateSchemas,
+        existingSchemas,
+        candidateToExistingComponentNames,
+        existingToCandidateComponentNames,
+        visited
+      );
+    }
+    return areSchemasEquivalentForReuse(
+      candidateValue,
+      existingValue,
+      candidateRootSchema,
+      existingRootSchema,
+      candidateSchemas,
+      existingSchemas,
+      candidateToExistingComponentNames,
+      existingToCandidateComponentNames,
+      visited
+    );
+  });
+}
+function parseComponentRefName(ref) {
+  if (!ref.startsWith("#/components/schemas/")) {
+    return void 0;
+  }
+  return ref.slice("#/components/schemas/".length).split("/").map(decodeJsonPointerSegment).join("/");
+}
+function resolveSchemaComparisonRef(ref, rootSchema, componentsSchemas) {
+  const localDefName = parseLocalDefRefName(ref);
+  if (localDefName !== void 0 && typeof rootSchema === "object" && rootSchema !== null) {
+    const localDef = rootSchema.$defs?.[localDefName];
+    if (localDef !== void 0) {
+      return {
+        schema: localDef,
+        rootSchema
+      };
+    }
+  }
+  const componentName = parseComponentRefName(ref);
+  if (componentName !== void 0) {
+    const componentSchema = componentsSchemas[componentName];
+    if (componentSchema !== void 0) {
+      return {
+        schema: componentSchema,
+        rootSchema: componentSchema
+      };
+    }
+  }
+  return void 0;
+}
+function areSchemaRefsEquivalentForReuse(candidateRef, existingRef, candidateRootSchema, existingRootSchema, candidateSchemas, existingSchemas, candidateToExistingComponentNames, existingToCandidateComponentNames, visited) {
+  const candidateComponentName = parseComponentRefName(candidateRef);
+  const existingComponentName = parseComponentRefName(existingRef);
+  if (candidateComponentName === void 0 !== (existingComponentName === void 0)) {
+    return false;
+  }
+  if (candidateComponentName !== void 0 && existingComponentName !== void 0) {
+    const mappedExisting = candidateToExistingComponentNames.get(candidateComponentName);
+    if (mappedExisting !== void 0 && mappedExisting !== existingComponentName) {
+      return false;
+    }
+    const mappedCandidate = existingToCandidateComponentNames.get(existingComponentName);
+    if (mappedCandidate !== void 0 && mappedCandidate !== candidateComponentName) {
+      return false;
+    }
+    candidateToExistingComponentNames.set(candidateComponentName, existingComponentName);
+    existingToCandidateComponentNames.set(existingComponentName, candidateComponentName);
+  }
+  const resolvedCandidate = resolveSchemaComparisonRef(candidateRef, candidateRootSchema, candidateSchemas);
+  const resolvedExisting = resolveSchemaComparisonRef(existingRef, existingRootSchema, existingSchemas);
+  if (resolvedCandidate === void 0 || resolvedExisting === void 0) {
+    return candidateRef === existingRef;
+  }
+  return areSchemasEquivalentForReuse(
+    resolvedCandidate.schema,
+    resolvedExisting.schema,
+    resolvedCandidate.rootSchema,
+    resolvedExisting.rootSchema,
+    candidateSchemas,
+    existingSchemas,
+    candidateToExistingComponentNames,
+    existingToCandidateComponentNames,
+    visited
+  );
+}
+function parseLocalDefRefName(ref) {
+  if (!ref.startsWith("#/$defs/")) {
+    return void 0;
+  }
+  return ref.slice("#/$defs/".length).split("/").map(decodeJsonPointerSegment).join("/");
+}
+function rewriteComponentSchemaRefs(schema, renameMap) {
+  return mapJsonSchemaRefs(schema, (ref) => {
+    const refName = parseLocalDefRefName(ref);
+    if (refName === void 0) {
+      return ref;
+    }
+    const renamedName = renameMap[refName];
+    if (renamedName === void 0) {
+      return ref;
+    }
+    return `#/components/schemas/${encodeJsonPointerSegment(renamedName)}`;
   });
-  return createRouterClient(router, options);
 }
 
-const oo = {
-  spec: customOpenAPIOperation
-};
-
-export { createJsonifiedRouterClient, customOpenAPIOperation, oo };
+export { OpenAPIGenerator, OpenAPIGeneratorError, OpenAPISerializer, createContractJsonifiedCaller, getDynamicPathParams, getOpenAPIMeta };