zod-openapi 5.0.0-beta.18 → 5.0.0-beta.2

package/dist/components.chunk.cjs

@@ -0,0 +1,1085 @@
+"use strict";
+const core = require("zod/v4/core");
+const v4 = require("zod/v4");
+const isAnyZodType = (schema) => typeof schema === "object" && schema !== null && "_zod" in schema;
+const unwrapZodObject = (zodType, io, path) => {
+  const def = zodType._zod.def;
+  switch (def.type) {
+    case "object": {
+      return zodType;
+    }
+    case "lazy": {
+      return unwrapZodObject(def.getter(), io, path);
+    }
+    case "pipe": {
+      if (io === "input") {
+        return unwrapZodObject(def.in, io, path);
+      }
+      return unwrapZodObject(def.out, io, path);
+    }
+  }
+  throw new Error(
+    `Failed to unwrap ZodObject from type: ${zodType._zod.def.type} at ${path.join(" > ")}`
+  );
+};
+const isRequired = (zodType, io) => {
+  if (io === "input") {
+    return zodType._zod.optin === void 0;
+  }
+  return zodType._zod.optout === void 0;
+};
+const createParameter = (parameter, location, ctx, path) => {
+  var _a, _b;
+  const seenParameter = ctx.registry.parameters.seen.get(parameter);
+  if (seenParameter) {
+    return seenParameter;
+  }
+  const meta = v4.globalRegistry.get(parameter);
+  const name = (location == null ? void 0 : location.name) ?? ((_a = meta == null ? void 0 : meta.param) == null ? void 0 : _a.name);
+  const inLocation = (location == null ? void 0 : location.in) ?? ((_b = meta == null ? void 0 : meta.param) == null ? void 0 : _b.in);
+  if (!name || !inLocation) {
+    throw new Error(
+      `Parameter at ${path.join(" > ")} is missing \`.meta({ param: { name, in } })\` information`
+    );
+  }
+  const computedPath = [...path, inLocation, name].join(" > ");
+  const schemaObject = ctx.registry.schemas.setSchema(
+    computedPath,
+    parameter,
+    ctx.io
+  );
+  const { id, ...rest } = (meta == null ? void 0 : meta.param) ?? {};
+  const parameterObject = {
+    ...rest,
+    name,
+    in: inLocation,
+    schema: schemaObject
+  };
+  if (isRequired(parameter, ctx.io)) {
+    parameterObject.required = true;
+  }
+  if (!parameterObject.description && (meta == null ? void 0 : meta.description)) {
+    parameterObject.description = meta.description;
+  }
+  if (id) {
+    const ref = {
+      $ref: `#/components/parameters/${id}`
+    };
+    ctx.registry.parameters.seen.set(parameter, ref);
+    ctx.registry.parameters.ids.set(id, parameterObject);
+    return ref;
+  }
+  ctx.registry.parameters.seen.set(parameter, parameterObject);
+  return parameterObject;
+};
+const createManualParameters = (parameters, ctx, path) => {
+  if (!parameters) {
+    return void 0;
+  }
+  const parameterObjects = [];
+  for (const parameter of parameters) {
+    if (isAnyZodType(parameter)) {
+      const seenParameter = ctx.registry.parameters.seen.get(parameter);
+      if (seenParameter) {
+        parameterObjects.push(seenParameter);
+        continue;
+      }
+      const paramObject = createParameter(parameter, void 0, ctx, [
+        ...path,
+        "parameters"
+      ]);
+      parameterObjects.push(paramObject);
+      continue;
+    }
+    parameterObjects.push(parameter);
+  }
+  return parameterObjects;
+};
+const createParameters = (requestParams, ctx, path) => {
+  if (!requestParams) {
+    return void 0;
+  }
+  const parameterObjects = [];
+  for (const [location, schema] of Object.entries(requestParams ?? {})) {
+    if (!schema) {
+      continue;
+    }
+    const zodObject = unwrapZodObject(schema, ctx.io, path);
+    for (const [name, zodSchema] of Object.entries(zodObject._zod.def.shape)) {
+      const seenParameter = ctx.registry.parameters.seen.get(zodSchema);
+      if (seenParameter) {
+        parameterObjects.push(seenParameter);
+        continue;
+      }
+      const paramObject = createParameter(
+        zodSchema,
+        {
+          in: location,
+          name
+        },
+        ctx,
+        [...path, location, name]
+      );
+      parameterObjects.push(paramObject);
+    }
+  }
+  return parameterObjects;
+};
+const createMediaTypeObject = (mediaTypeObject, ctx, path) => {
+  const computedPath = path.join(" > ");
+  if (isAnyZodType(mediaTypeObject.schema)) {
+    const schemaObject = ctx.registry.schemas.setSchema(
+      computedPath,
+      mediaTypeObject.schema,
+      ctx.io
+    );
+    return {
+      ...mediaTypeObject,
+      schema: schemaObject
+    };
+  }
+  return mediaTypeObject;
+};
+const createContent = (content, ctx, path) => {
+  const contentObject = {};
+  for (const [mediaType, mediaTypeObject] of Object.entries(content)) {
+    if (mediaTypeObject) {
+      contentObject[mediaType] = createMediaTypeObject(mediaTypeObject, ctx, [
+        ...path,
+        mediaType
+      ]);
+    }
+  }
+  return contentObject;
+};
+const createRequestBody = (requestBody, ctx, path) => {
+  if (!requestBody) {
+    return void 0;
+  }
+  const seenRequestBody = ctx.registry.requestBodies.seen.get(requestBody);
+  if (seenRequestBody) {
+    return seenRequestBody;
+  }
+  const { content, id, ...rest } = requestBody;
+  const requestBodyObject = {
+    ...rest,
+    content: createContent(content, ctx, [...path, "content"])
+  };
+  if (id) {
+    const ref = {
+      $ref: `#/components/requestBodies/${id}`
+    };
+    ctx.registry.requestBodies.ids.set(id, requestBodyObject);
+    ctx.registry.requestBodies.seen.set(requestBody, ref);
+    return ref;
+  }
+  ctx.registry.requestBodies.seen.set(requestBody, requestBodyObject);
+  return requestBodyObject;
+};
+const createHeader = (header, ctx, path) => {
+  const seenHeader = ctx.registry.headers.seen.get(header);
+  if (seenHeader) {
+    return seenHeader;
+  }
+  const meta = v4.globalRegistry.get(header);
+  const { id, ...rest } = (meta == null ? void 0 : meta.header) ?? {};
+  const headerObject = rest;
+  if (isRequired(header, ctx.io)) {
+    headerObject.required = true;
+  }
+  if (!headerObject.description && (meta == null ? void 0 : meta.description)) {
+    headerObject.description = meta.description;
+  }
+  const computedPath = path.join(" > ");
+  headerObject.schema = ctx.registry.schemas.setSchema(
+    computedPath,
+    header,
+    ctx.io
+  );
+  if (id) {
+    const ref = {
+      $ref: `#/components/headers/${id}`
+    };
+    ctx.registry.headers.ids.set(id, headerObject);
+    ctx.registry.headers.seen.set(header, ref);
+    return ref;
+  }
+  ctx.registry.headers.seen.set(header, headerObject);
+  return headerObject;
+};
+const createHeaders = (headers, ctx, path) => {
+  if (!headers) {
+    return void 0;
+  }
+  if (isAnyZodType(headers)) {
+    const zodObject = unwrapZodObject(headers, ctx.io, path);
+    const headersObject = {};
+    for (const [key, zodSchema] of Object.entries(zodObject._zod.def.shape)) {
+      const header = createHeader(zodSchema, ctx, [...path, key]);
+      headersObject[key] = header;
+    }
+    return headersObject;
+  }
+  return headers;
+};
+const isISpecificationExtension = (key) => key.startsWith("x-");
+const createResponse = (response, ctx, path) => {
+  const seenResponse = ctx.registry.responses.seen.get(response);
+  if (seenResponse) {
+    return seenResponse;
+  }
+  const { content, headers, id, ...rest } = response;
+  const responseObject = rest;
+  const maybeHeaders = createHeaders(headers, ctx, [...path, "headers"]);
+  if (maybeHeaders) {
+    responseObject.headers = maybeHeaders;
+  }
+  if (content) {
+    responseObject.content = createContent(content, ctx, [...path, "content"]);
+  }
+  if (id) {
+    const ref = {
+      $ref: `#/components/responses/${id}`
+    };
+    ctx.registry.responses.ids.set(id, responseObject);
+    ctx.registry.responses.seen.set(response, ref);
+    return ref;
+  }
+  ctx.registry.responses.seen.set(response, responseObject);
+  return responseObject;
+};
+const createResponses = (responses, ctx, path) => {
+  if (!responses) {
+    return void 0;
+  }
+  const responsesObject = {};
+  for (const [statusCode, response] of Object.entries(responses)) {
+    if (!response) {
+      continue;
+    }
+    if (isISpecificationExtension(statusCode)) {
+      responsesObject[statusCode] = response;
+      continue;
+    }
+    if ("$ref" in response) {
+      responsesObject[statusCode] = response;
+      continue;
+    }
+    const responseObject = createResponse(
+      response,
+      ctx,
+      [...path, statusCode]
+    );
+    responsesObject[statusCode] = responseObject;
+  }
+  return responsesObject;
+};
+const createOperation = (operationObject, registry, path) => {
+  const {
+    parameters,
+    requestParams,
+    requestBody,
+    responses,
+    callbacks,
+    ...rest
+  } = operationObject;
+  const operation = rest;
+  const maybeManualParameters = createManualParameters(
+    parameters,
+    {
+      registry,
+      io: "input"
+    },
+    [...path, "parameters"]
+  );
+  const maybeRequestParams = createParameters(
+    requestParams,
+    {
+      registry,
+      io: "input"
+    },
+    [...path, "requestParams"]
+  );
+  if (maybeRequestParams || maybeManualParameters) {
+    operation.parameters = [
+      ...maybeRequestParams ?? [],
+      ...maybeManualParameters ?? []
+    ];
+  }
+  const maybeRequestBody = createRequestBody(
+    requestBody,
+    {
+      registry,
+      io: "input"
+    },
+    [...path, "requestBody"]
+  );
+  if (maybeRequestBody) {
+    operation.requestBody = maybeRequestBody;
+  }
+  const maybeResponses = createResponses(
+    responses,
+    {
+      registry,
+      io: "output"
+    },
+    [...path, "responses"]
+  );
+  if (maybeResponses) {
+    operation.responses = maybeResponses;
+  }
+  const maybeCallbacks = createCallbacks(callbacks, registry, [
+    ...path,
+    "callbacks"
+  ]);
+  if (maybeCallbacks) {
+    operation.callbacks = maybeCallbacks;
+  }
+  return operation;
+};
+const createPathItem = (pathItem, registry, path) => {
+  const pathItemObject = {};
+  const { id, ...rest } = pathItem;
+  for (const [key, value] of Object.entries(rest)) {
+    if (key === "get" || key === "put" || key === "post" || key === "delete" || key === "options" || key === "head" || key === "patch" || key === "trace") {
+      pathItemObject[key] = createOperation(
+        value,
+        registry,
+        [...path, key]
+      );
+      continue;
+    }
+    if (key === "parameters") {
+      pathItemObject[key] = createManualParameters(
+        value,
+        {
+          registry,
+          io: "input"
+        },
+        [...path, key]
+      );
+      continue;
+    }
+    pathItemObject[key] = value;
+  }
+  if (id) {
+    const ref = {
+      $ref: `#/components/pathItems/${id}`
+    };
+    registry.pathItems.ids.set(id, pathItemObject);
+    registry.pathItems.seen.set(pathItem, ref);
+    return ref;
+  }
+  registry.pathItems.seen.set(pathItem, pathItemObject);
+  return pathItemObject;
+};
+const createPaths = (paths, registry, path) => {
+  if (!paths) {
+    return void 0;
+  }
+  const pathsObject = {};
+  for (const [singlePath, pathItemObject] of Object.entries(paths)) {
+    if (isISpecificationExtension(singlePath)) {
+      pathsObject[singlePath] = pathItemObject;
+      continue;
+    }
+    pathsObject[singlePath] = createPathItem(pathItemObject, registry, [
+      ...path,
+      singlePath
+    ]);
+  }
+  return pathsObject;
+};
+const createCallback = (callbackObject, registry, path) => {
+  const seenCallback = registry.callbacks.seen.get(callbackObject);
+  if (seenCallback) {
+    return seenCallback;
+  }
+  const { id, ...rest } = callbackObject;
+  const callback = {};
+  for (const [name, pathItem] of Object.entries(rest)) {
+    if (isISpecificationExtension(name)) {
+      callback[name] = pathItem;
+      continue;
+    }
+    callback[name] = createPathItem(
+      pathItem,
+      registry,
+      [...path, name]
+    );
+  }
+  if (id) {
+    const ref = {
+      $ref: `#/components/callbacks/${id}`
+    };
+    registry.callbacks.ids.set(id, callback);
+    registry.callbacks.seen.set(callbackObject, ref);
+    return ref;
+  }
+  registry.callbacks.seen.set(callbackObject, callback);
+  return callback;
+};
+const createCallbacks = (callbacks, registry, path) => {
+  if (!callbacks) {
+    return void 0;
+  }
+  const callbacksObject = {};
+  for (const [name, value] of Object.entries(callbacks)) {
+    if (isISpecificationExtension(name)) {
+      callbacksObject[name] = value;
+      continue;
+    }
+    callbacksObject[name] = createCallback(
+      value,
+      registry,
+      [...path, name]
+    );
+  }
+  return callbacksObject;
+};
+const override = (ctx) => {
+  var _a;
+  const def = ctx.zodSchema._zod.def;
+  switch (def.type) {
+    case "bigint": {
+      ctx.jsonSchema.type = "integer";
+      ctx.jsonSchema.format = "int64";
+      break;
+    }
+    case "union": {
+      if ("discriminator" in def && typeof def.discriminator === "string") {
+        ctx.jsonSchema.oneOf = ctx.jsonSchema.anyOf;
+        delete ctx.jsonSchema.anyOf;
+        ctx.jsonSchema.type = "object";
+        ctx.jsonSchema.discriminator = {
+          propertyName: def.discriminator
+        };
+        const mapping = {};
+        for (const [index, obj] of Object.entries(
+          ctx.jsonSchema.oneOf
+        )) {
+          const ref = obj.$ref;
+          if (!ref) {
+            return;
+          }
+          const discriminatorValues = (_a = def.options[Number(index)]._zod.propValues) == null ? void 0 : _a[def.discriminator];
+          if (!(discriminatorValues == null ? void 0 : discriminatorValues.size)) {
+            return;
+          }
+          for (const value of [...discriminatorValues ?? []]) {
+            if (typeof value !== "string") {
+              return;
+            }
+            mapping[value] = ref;
+          }
+        }
+        ctx.jsonSchema.discriminator.mapping = mapping;
+      }
+      const meta = ctx.zodSchema.meta();
+      if (typeof (meta == null ? void 0 : meta.unionOneOf) === "boolean") {
+        if (meta.unionOneOf) {
+          ctx.jsonSchema.oneOf = ctx.jsonSchema.anyOf;
+          delete ctx.jsonSchema.anyOf;
+        }
+        delete ctx.jsonSchema.unionOneOf;
+      }
+      break;
+    }
+    case "date": {
+      ctx.jsonSchema.type = "string";
+      break;
+    }
+    case "literal": {
+      if (def.values.includes(void 0)) {
+        break;
+      }
+      break;
+    }
+  }
+};
+const validate = (ctx, opts) => {
+  var _a;
+  if (Object.keys(ctx.jsonSchema).length) {
+    return;
+  }
+  const def = ctx.zodSchema._zod.def;
+  if ((_a = opts.allowEmptySchema) == null ? void 0 : _a[def.type]) {
+    return;
+  }
+  switch (def.type) {
+    case "any": {
+      return;
+    }
+    case "unknown": {
+      return;
+    }
+    case "pipe": {
+      if (ctx.io === "output") {
+        throw new Error(
+          "Zod transform schemas are not supported in output schemas. Please use `.overwrite()` or wrap the schema in a `.pipe()`"
+        );
+      }
+      return;
+    }
+    case "transform": {
+      if (ctx.io === "output") {
+        return;
+      }
+      break;
+    }
+    case "literal": {
+      if (def.values.includes(void 0)) {
+        throw new Error(
+          "Zod literal schemas cannot include `undefined` as a value. Please use `z.undefined()` or `.optional()` instead."
+        );
+      }
+      return;
+    }
+  }
+  throw new Error(
+    `Zod schema of type \`${def.type}\` cannot be represented in OpenAPI. Please assign it metadata with \`.meta()\``
+  );
+};
+const renameComponents = (components, outputIds, ctx) => {
+  const componentsToRename = /* @__PURE__ */ new Map();
+  const componentDependencies = /* @__PURE__ */ new Map();
+  const stringifiedComponents = /* @__PURE__ */ new Map();
+  for (const [key, value] of Object.entries(components)) {
+    const stringified = JSON.stringify(value);
+    const matches = stringified.matchAll(/"#\/components\/schemas\/([^"]+)"/g);
+    const dependencies = /* @__PURE__ */ new Set();
+    for (const match of matches) {
+      const dep = match[1];
+      if (dep !== key) {
+        dependencies.add(dep);
+      }
+    }
+    stringifiedComponents.set(key, stringified);
+    componentDependencies.set(key, {
+      dependencies
+    });
+  }
+  for (const [key] of stringifiedComponents) {
+    const registeredComponent = ctx.registry.schemas.ids.get(key);
+    if (!registeredComponent) {
+      continue;
+    }
+    if (isDependencyPure(
+      componentDependencies,
+      stringifiedComponents,
+      ctx.registry,
+      key
+    )) {
+      continue;
+    }
+    const newName = outputIds.get(key) ?? `${key}Output`;
+    componentsToRename.set(key, newName);
+    components[newName] = components[key];
+    delete components[key];
+    continue;
+  }
+  return componentsToRename;
+};
+const isDependencyPure = (componentDependencies, stringifiedComponents, registry, key, visited = /* @__PURE__ */ new Set()) => {
+  if (visited.has(key)) {
+    return true;
+  }
+  const dependencies = componentDependencies.get(key);
+  if (dependencies.pure !== void 0) {
+    return dependencies.pure;
+  }
+  const stringified = stringifiedComponents.get(key);
+  const component = registry.schemas.ids.get(key);
+  if (component && stringified !== JSON.stringify(component)) {
+    dependencies.pure = false;
+    return false;
+  }
+  visited.add(key);
+  const result = [...dependencies.dependencies].every(
+    (dep) => isDependencyPure(
+      componentDependencies,
+      stringifiedComponents,
+      registry,
+      dep,
+      new Set(visited)
+    )
+  );
+  dependencies.pure = result;
+  return result;
+};
+const deleteZodOpenApiMeta = (jsonSchema) => {
+  delete jsonSchema.param;
+  delete jsonSchema.header;
+  delete jsonSchema.unusedIO;
+  delete jsonSchema.override;
+  delete jsonSchema.outputId;
+};
+const createSchema = (schema, ctx = {
+  registry: createRegistry(),
+  io: "output",
+  opts: {}
+}) => {
+  ctx.registry ?? (ctx.registry = createRegistry());
+  ctx.opts ?? (ctx.opts = {});
+  ctx.io ?? (ctx.io = "output");
+  const registrySchemas = Object.fromEntries(
+    ctx.registry.schemas[ctx.io].schemas
+  );
+  const schemas = {
+    zodOpenApiCreateSchema: { zodType: schema }
+  };
+  Object.assign(schemas, registrySchemas);
+  const jsonSchemas = createSchemas(schemas, {
+    registry: ctx.registry,
+    io: ctx.io,
+    opts: ctx.opts
+  });
+  return {
+    schema: jsonSchemas.schemas.zodOpenApiCreateSchema,
+    components: jsonSchemas.components
+  };
+};
+const createSchemas = (schemas, {
+  registry,
+  io,
+  opts
+}) => {
+  var _a, _b, _c, _d, _e, _f;
+  const schemaRegistry = v4.registry();
+  const globalsInSchemas = /* @__PURE__ */ new Map();
+  for (const [name, { zodType }] of Object.entries(schemas)) {
+    const id = (_a = v4.globalRegistry.get(zodType)) == null ? void 0 : _a.id;
+    if (id) {
+      globalsInSchemas.set(name, id);
+    }
+    schemaRegistry.add(zodType, { id: name });
+  }
+  const outputIds = /* @__PURE__ */ new Map();
+  const jsonSchema = v4.toJSONSchema(schemaRegistry, {
+    override(ctx) {
+      const meta = ctx.zodSchema.meta();
+      if ((meta == null ? void 0 : meta.outputId) && (meta == null ? void 0 : meta.id)) {
+        outputIds.set(meta.id, meta.outputId);
+      }
+      if (ctx.jsonSchema.$ref) {
+        return;
+      }
+      const enrichedContext = { ...ctx, io };
+      override(enrichedContext);
+      if (typeof opts.override === "function") {
+        opts.override(enrichedContext);
+      }
+      if (typeof (meta == null ? void 0 : meta.override) === "function") {
+        meta.override(enrichedContext);
+        delete ctx.jsonSchema.override;
+      }
+      if (typeof (meta == null ? void 0 : meta.override) === "object" && meta.override !== null) {
+        Object.assign(ctx.jsonSchema, meta.override);
+        delete ctx.jsonSchema.override;
+      }
+      delete ctx.jsonSchema.$schema;
+      delete ctx.jsonSchema.id;
+      deleteZodOpenApiMeta(ctx.jsonSchema);
+      validate(enrichedContext, opts);
+    },
+    io,
+    unrepresentable: "any",
+    uri: (id) => `#/components/schemas/${id}`
+  });
+  const sharedDefs = ((_b = jsonSchema.schemas.__shared) == null ? void 0 : _b.$defs) ?? {};
+  (_c = jsonSchema.schemas).__shared ?? (_c.__shared = { $defs: sharedDefs });
+  const componentsToReplace = /* @__PURE__ */ new Map();
+  for (const [key, value] of Object.entries(sharedDefs)) {
+    if (/^schema\d+$/.exec(key)) {
+      const componentName = `__schema${registry.schemas.dynamicSchemaCount++}`;
+      componentsToReplace.set(`__shared#/$defs/${key}`, componentName);
+      delete sharedDefs[key];
+      sharedDefs[componentName] = value;
+      continue;
+    }
+    componentsToReplace.set(`__shared#/$defs/${key}`, key);
+  }
+  for (const value of Object.values(jsonSchema.schemas)) {
+    delete value.$schema;
+    delete value.id;
+  }
+  const dynamicComponent = /* @__PURE__ */ new Map();
+  const patched = JSON.stringify(jsonSchema).replace(
+    /"#\/components\/schemas\/([^"]+)"/g,
+    (_, match) => {
+      const replacement = componentsToReplace.get(match);
+      if (replacement) {
+        return `"#/components/schemas/${replacement}"`;
+      }
+      const component = registry.schemas.ids.get(match);
+      if (component) {
+        return `"#/components/schemas/${match}`;
+      }
+      const globalInSchema = globalsInSchemas.get(match);
+      if (globalInSchema) {
+        componentsToReplace.set(match, globalInSchema);
+        dynamicComponent.set(match, globalInSchema);
+        return `"#/components/schemas/${globalInSchema}"`;
+      }
+      const manualSchema = registry.schemas.manual.get(match);
+      if (manualSchema) {
+        componentsToReplace.set(match, manualSchema.key);
+        dynamicComponent.set(match, manualSchema.key);
+        manualSchema.io[io].used = true;
+        return `"#/components/schemas/${manualSchema.key}"`;
+      }
+      const componentName = `__schema${registry.schemas.dynamicSchemaCount++}`;
+      componentsToReplace.set(match, componentName);
+      dynamicComponent.set(match, componentName);
+      return `"#/components/schemas/${componentName}"`;
+    }
+  );
+  const patchedJsonSchema = JSON.parse(patched);
+  const components = ((_d = patchedJsonSchema.schemas.__shared) == null ? void 0 : _d.$defs) ?? {};
+  (_e = patchedJsonSchema.schemas).__shared ?? (_e.__shared = { $defs: components });
+  for (const [key, value] of registry.schemas.manual) {
+    if (value.io[io].used) {
+      dynamicComponent.set(key, value.key);
+    }
+  }
+  for (const [key, value] of globalsInSchemas) {
+    dynamicComponent.set(key, value);
+  }
+  for (const [key, value] of dynamicComponent) {
+    const component = patchedJsonSchema.schemas[key];
+    patchedJsonSchema.schemas[key] = {
+      $ref: `#/components/schemas/${value}`
+    };
+    components[value] = component;
+  }
+  const renamedComponents = renameComponents(components, outputIds, {
+    registry
+  });
+  if (renamedComponents.size === 0) {
+    delete patchedJsonSchema.schemas.__shared;
+    return {
+      schemas: patchedJsonSchema.schemas,
+      components
+    };
+  }
+  const renamedStringified = JSON.stringify(patchedJsonSchema).replace(
+    /"#\/components\/schemas\/([^"]+)"/g,
+    (_, match) => {
+      const newName = renamedComponents.get(match);
+      if (newName) {
+        return `"#/components/schemas/${newName}"`;
+      }
+      return `"#/components/schemas/${match}"`;
+    }
+  );
+  const renamedJsonSchema = JSON.parse(renamedStringified);
+  const renamedJsonSchemaComponents = ((_f = renamedJsonSchema.schemas.__shared) == null ? void 0 : _f.$defs) ?? {};
+  delete renamedJsonSchema.schemas.__shared;
+  return {
+    schemas: renamedJsonSchema.schemas,
+    components: renamedJsonSchemaComponents
+  };
+};
+const createRegistry = (components) => {
+  const registry = {
+    schemas: {
+      dynamicSchemaCount: 0,
+      input: {
+        seen: /* @__PURE__ */ new WeakMap(),
+        schemas: /* @__PURE__ */ new Map()
+      },
+      output: {
+        seen: /* @__PURE__ */ new WeakMap(),
+        schemas: /* @__PURE__ */ new Map()
+      },
+      ids: /* @__PURE__ */ new Map(),
+      manual: /* @__PURE__ */ new Map(),
+      setSchema: (key, schema, io) => {
+        const seenSchema = registry.schemas[io].seen.get(schema);
+        if (seenSchema) {
+          if (seenSchema.type === "manual") {
+            const manualSchema = registry.schemas.manual.get(seenSchema.id);
+            if (!manualSchema) {
+              throw new Error(
+                `Manual schema "${key}" not found in registry for ${io} IO.`
+              );
+            }
+            manualSchema.io[io].used = true;
+          }
+          return seenSchema.schemaObject;
+        }
+        const schemaObject = {};
+        registry.schemas[io].schemas.set(key, {
+          schemaObject,
+          zodType: schema
+        });
+        registry.schemas[io].seen.set(schema, { type: "schema", schemaObject });
+        return schemaObject;
+      }
+    },
+    headers: {
+      ids: /* @__PURE__ */ new Map(),
+      seen: /* @__PURE__ */ new WeakMap()
+    },
+    requestBodies: {
+      ids: /* @__PURE__ */ new Map(),
+      seen: /* @__PURE__ */ new WeakMap()
+    },
+    responses: {
+      ids: /* @__PURE__ */ new Map(),
+      seen: /* @__PURE__ */ new WeakMap()
+    },
+    parameters: {
+      ids: /* @__PURE__ */ new Map(),
+      seen: /* @__PURE__ */ new WeakMap()
+    },
+    callbacks: {
+      ids: /* @__PURE__ */ new Map(),
+      seen: /* @__PURE__ */ new WeakMap()
+    },
+    pathItems: {
+      ids: /* @__PURE__ */ new Map(),
+      seen: /* @__PURE__ */ new WeakMap()
+    }
+  };
+  registerSchemas(components == null ? void 0 : components.schemas, registry);
+  registerParameters(components == null ? void 0 : components.parameters, registry);
+  registerHeaders(components == null ? void 0 : components.headers, registry);
+  registerResponses(components == null ? void 0 : components.responses, registry);
+  registerPathItems(components == null ? void 0 : components.pathItems, registry);
+  registerRequestBodies(components == null ? void 0 : components.requestBodies, registry);
+  registerCallbacks(components == null ? void 0 : components.callbacks, registry);
+  return registry;
+};
+const registerSchemas = (schemas, registry) => {
+  if (!schemas) {
+    return;
+  }
+  for (const [key, schema] of Object.entries(schemas)) {
+    if (registry.schemas.ids.has(key)) {
+      throw new Error(`Schema "${key}" is already registered`);
+    }
+    if (isAnyZodType(schema)) {
+      const inputSchemaObject = {};
+      const outputSchemaObject = {};
+      const identifier = `components > schemas > ${key}`;
+      registry.schemas.input.schemas.set(identifier, {
+        zodType: schema,
+        schemaObject: inputSchemaObject
+      });
+      registry.schemas.input.seen.set(schema, {
+        type: "manual",
+        schemaObject: inputSchemaObject,
+        id: identifier
+      });
+      registry.schemas.output.schemas.set(identifier, {
+        zodType: schema,
+        schemaObject: outputSchemaObject
+      });
+      registry.schemas.output.seen.set(schema, {
+        type: "manual",
+        schemaObject: outputSchemaObject,
+        id: identifier
+      });
+      registry.schemas.manual.set(identifier, {
+        key,
+        io: {
+          input: {
+            schemaObject: inputSchemaObject
+          },
+          output: {
+            schemaObject: outputSchemaObject
+          }
+        },
+        zodType: schema
+      });
+      continue;
+    }
+    registry.schemas.ids.set(key, schema);
+  }
+};
+const registerParameters = (parameters, registry) => {
+  if (!parameters) {
+    return;
+  }
+  for (const [key, schema] of Object.entries(parameters)) {
+    if (registry.parameters.ids.has(key)) {
+      throw new Error(`Parameter "${key}" is already registered`);
+    }
+    if (isAnyZodType(schema)) {
+      const path = ["components", "parameters", key];
+      const paramObject = createParameter(
+        schema,
+        void 0,
+        {
+          registry,
+          io: "input"
+        },
+        path
+      );
+      registry.parameters.ids.set(key, paramObject);
+      registry.parameters.seen.set(schema, paramObject);
+      continue;
+    }
+    registry.parameters.ids.set(key, schema);
+  }
+};
+const registerHeaders = (headers, registry) => {
+  if (!headers) {
+    return;
+  }
+  for (const [key, schema] of Object.entries(headers)) {
+    if (registry.headers.ids.has(key)) {
+      throw new Error(`Header "${key}" is already registered`);
+    }
+    if (isAnyZodType(schema)) {
+      const path = ["components", "headers", key];
+      const headerObject = createHeader(
+        schema,
+        {
+          registry,
+          io: "output"
+        },
+        path
+      );
+      registry.headers.ids.set(key, headerObject);
+      registry.headers.seen.set(schema, headerObject);
+      continue;
+    }
+    registry.headers.ids.set(key, schema);
+  }
+};
+const registerResponses = (responses, registry) => {
+  if (!responses) {
+    return;
+  }
+  for (const [key, schema] of Object.entries(responses)) {
+    const path = ["components", "responses", key];
+    if (registry.responses.ids.has(key)) {
+      throw new Error(`Response "${key}" is already registered`);
+    }
+    const responseObject = createResponse(
+      schema,
+      {
+        registry,
+        io: "output"
+      },
+      path
+    );
+    registry.responses.ids.set(key, responseObject);
+    registry.responses.seen.set(schema, responseObject);
+  }
+};
+const registerRequestBodies = (requestBodies, registry) => {
+  if (!requestBodies) {
+    return;
+  }
+  for (const [key, schema] of Object.entries(requestBodies)) {
+    if (registry.requestBodies.ids.has(key)) {
+      throw new Error(`RequestBody "${key}" is already registered`);
+    }
+    if (isAnyZodType(schema)) {
+      const path = ["components", "requestBodies", key];
+      const requestBodyObject = createRequestBody(
+        schema,
+        {
+          registry,
+          io: "input"
+        },
+        path
+      );
+      registry.requestBodies.ids.set(key, requestBodyObject);
+      continue;
+    }
+    registry.requestBodies.ids.set(key, schema);
+  }
+};
+const registerCallbacks = (callbacks, registry) => {
+  if (!callbacks) {
+    return;
+  }
+  for (const [key, schema] of Object.entries(callbacks)) {
+    if (registry.callbacks.ids.has(key)) {
+      throw new Error(`Callback "${key}" is already registered`);
+    }
+    const path = ["components", "callbacks", key];
+    const callbackObject = createCallback(schema, registry, path);
+    registry.callbacks.ids.set(key, callbackObject);
+    registry.callbacks.seen.set(schema, callbackObject);
+  }
+};
+const registerPathItems = (pathItems, registry) => {
+  if (!pathItems) {
+    return;
+  }
+  for (const [key, schema] of Object.entries(pathItems)) {
+    if (registry.pathItems.ids.has(key)) {
+      throw new Error(`PathItem "${key}" is already registered`);
+    }
+    const path = ["components", "pathItems", key];
+    const pathItemObject = createPathItem(schema, registry, path);
+    registry.pathItems.ids.set(key, pathItemObject);
+    registry.pathItems.seen.set(schema, pathItemObject);
+    continue;
+  }
+};
+const createIOSchemas = (ctx) => {
+  const { schemas, components } = createSchemas(
+    Object.fromEntries(ctx.registry.schemas[ctx.io].schemas),
+    ctx
+  );
+  for (const [key, schema] of Object.entries(components)) {
+    ctx.registry.schemas.ids.set(key, schema);
+  }
+  for (const [key, schema] of Object.entries(schemas)) {
+    const ioSchema = ctx.registry.schemas[ctx.io].schemas.get(key);
+    if (ioSchema) {
+      Object.assign(ioSchema.schemaObject, schema);
+    }
+  }
+};
+const createManualSchemas = (registry) => {
+  var _a;
+  for (const [, value] of registry.schemas.manual) {
+    if (!value.io.input.used && !value.io.output.used) {
+      const io = ((_a = core.globalRegistry.get(value.zodType)) == null ? void 0 : _a.unusedIO) ?? "output";
+      const schema = value.io[io].schemaObject;
+      registry.schemas.ids.set(value.key, schema);
+    }
+  }
+};
+const createComponents = (registry, opts) => {
+  createIOSchemas({ registry, io: "input", opts });
+  createIOSchemas({ registry, io: "output", opts });
+  createManualSchemas(registry);
+  const components = {};
+  if (registry.schemas.ids.size > 0) {
+    components.schemas = Object.fromEntries(registry.schemas.ids);
+  }
+  if (registry.headers.ids.size > 0) {
+    components.headers = Object.fromEntries(registry.headers.ids);
+  }
+  if (registry.requestBodies.ids.size > 0) {
+    components.requestBodies = Object.fromEntries(registry.requestBodies.ids);
+  }
+  if (registry.responses.ids.size > 0) {
+    components.responses = Object.fromEntries(registry.responses.ids);
+  }
+  if (registry.parameters.ids.size > 0) {
+    components.parameters = Object.fromEntries(registry.parameters.ids);
+  }
+  if (registry.callbacks.ids.size > 0) {
+    components.callbacks = Object.fromEntries(registry.callbacks.ids);
+  }
+  if (registry.pathItems.ids.size > 0) {
+    components.pathItems = Object.fromEntries(registry.pathItems.ids);
+  }
+  return components;
+};
+exports.createComponents = createComponents;
+exports.createMediaTypeObject = createMediaTypeObject;
+exports.createParameter = createParameter;
+exports.createPaths = createPaths;
+exports.createRegistry = createRegistry;
+exports.createSchema = createSchema;
+exports.unwrapZodObject = unwrapZodObject;