zod-openapi 5.0.0-beta.3 → 5.0.0-beta.4

package/dist/components.chunk.cjs

@@ -1,1023 +0,0 @@
-"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]);
-  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, ctx) => {
-  var _a, _b;
-  const entries = {};
-  for (const [name, { zodType }] of Object.entries(schemas)) {
-    entries[name] = zodType;
-  }
-  const schemaRegistry = v4.object(entries);
-  const outputIds = /* @__PURE__ */ new Map();
-  const jsonSchema = v4.toJSONSchema(schemaRegistry, {
-    override(context) {
-      const meta = context.zodSchema.meta();
-      if ((meta == null ? void 0 : meta.outputId) && (meta == null ? void 0 : meta.id)) {
-        outputIds.set(meta.id, meta.outputId);
-      }
-      if (context.jsonSchema.$ref) {
-        return;
-      }
-      const enrichedContext = { ...context, io: ctx.io };
-      override(enrichedContext);
-      if (typeof ctx.opts.override === "function") {
-        ctx.opts.override(enrichedContext);
-      }
-      if (typeof (meta == null ? void 0 : meta.override) === "function") {
-        meta.override(enrichedContext);
-        delete context.jsonSchema.override;
-      }
-      if (typeof (meta == null ? void 0 : meta.override) === "object" && meta.override !== null) {
-        Object.assign(context.jsonSchema, meta.override);
-        delete context.jsonSchema.override;
-      }
-      delete context.jsonSchema.$schema;
-      delete context.jsonSchema.id;
-      deleteZodOpenApiMeta(context.jsonSchema);
-      validate(enrichedContext, ctx.opts);
-    },
-    io: ctx.io,
-    unrepresentable: "any"
-  });
-  const components = jsonSchema.$defs ?? {};
-  const dynamicComponents = /* @__PURE__ */ new Map();
-  for (const [key, value] of Object.entries(components)) {
-    if (/^__schema\d+$/.test(key)) {
-      const newName = `__schema${ctx.registry.schemas.dynamicSchemaCount++}`;
-      dynamicComponents.set(key, `"#/components/schemas/${newName}"`);
-      if (newName !== key) {
-        components[newName] = value;
-        delete components[key];
-      }
-    }
-  }
-  const parsedJsonSchema = JSON.parse(
-    JSON.stringify(jsonSchema).replace(
-      /"#\/\$defs\/([^"]+)"/g,
-      (_, match) => {
-        const dynamic = dynamicComponents.get(match);
-        if (dynamic) {
-          return dynamic;
-        }
-        const manualComponent = ctx.registry.schemas.manual.get(match);
-        if (manualComponent) {
-          manualComponent.io[ctx.io].used++;
-        }
-        return `"#/components/schemas/${match}"`;
-      }
-    )
-  );
-  for (const [key, value] of ctx.registry.schemas.manual) {
-    if (value.io[ctx.io].used === 1 && ((_a = parsedJsonSchema.properties) == null ? void 0 : _a[value.identifier]) && ((_b = parsedJsonSchema.$defs) == null ? void 0 : _b[key])) {
-      parsedJsonSchema.properties[value.identifier] = parsedJsonSchema.$defs[key];
-      delete parsedJsonSchema.$defs[key];
-      continue;
-    }
-  }
-  const renamedComponents = renameComponents(
-    parsedJsonSchema.$defs ?? {},
-    outputIds,
-    ctx
-  );
-  if (!renamedComponents.size) {
-    return {
-      schemas: parsedJsonSchema.properties,
-      components: parsedJsonSchema.$defs ?? {}
-    };
-  }
-  const renamedJsonSchema = JSON.parse(
-    JSON.stringify(parsedJsonSchema).replace(
-      /"#\/components\/schemas\/([^"]+)"/g,
-      (_, match) => {
-        const replacement = renamedComponents.get(match);
-        if (replacement) {
-          return `"#/components/schemas/${replacement}"`;
-        }
-        return `"#/components/schemas/${match}"`;
-      }
-    )
-  );
-  return {
-    schemas: renamedJsonSchema.properties,
-    components: renamedJsonSchema.$defs ?? {}
-  };
-};
-const createRegistry = (components) => {
-  const registry = {
-    schemas: {
-      dynamicSchemaCount: 0,
-      input: /* @__PURE__ */ new Map(),
-      output: /* @__PURE__ */ new Map(),
-      ids: /* @__PURE__ */ new Map(),
-      manual: /* @__PURE__ */ new Map(),
-      setSchema: (key, schema, io) => {
-        const schemaObject = {};
-        registry.schemas[io].set(key, {
-          schemaObject,
-          zodType: schema
-        });
-        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.set(identifier, {
-        zodType: schema,
-        schemaObject: inputSchemaObject
-      });
-      registry.schemas.output.set(identifier, {
-        zodType: schema,
-        schemaObject: outputSchemaObject
-      });
-      registry.schemas.manual.set(key, {
-        identifier,
-        io: {
-          input: {
-            schemaObject: inputSchemaObject,
-            used: 0
-          },
-          output: {
-            schemaObject: outputSchemaObject,
-            used: 0
-          }
-        },
-        zodType: schema
-      });
-      const meta = core.globalRegistry.get(schema);
-      if (meta == null ? void 0 : meta.id) {
-        continue;
-      }
-      core.globalRegistry.add(schema, {
-        ...meta,
-        id: key
-      });
-      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]),
-    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].get(key);
-    if (ioSchema) {
-      Object.assign(ioSchema.schemaObject, schema);
-    }
-  }
-};
-const createManualSchemas = (registry) => {
-  var _a;
-  for (const [key, value] of registry.schemas.manual) {
-    if (value.io.input.used === 1) {
-      const io = ((_a = core.globalRegistry.get(value.zodType)) == null ? void 0 : _a.unusedIO) ?? "output";
-      const schema = value.io[io].schemaObject;
-      registry.schemas.ids.set(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;