zod-openapi 2.9.1 → 2.10.0

package/lib-commonjs/index.js

@@ -1,34 +1,1689 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  api: () => api_exports,
+  createDocument: () => createDocument,
+  extendZodWithOpenApi: () => extendZodWithOpenApi,
+  oas30: () => oas30_exports,
+  oas31: () => oas31_exports
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/zodType.ts
+var isZodType = (zodType, typeName) => zodType?._def?.typeName === typeName;
+var isAnyZodType = (zodType) => Boolean(
+  zodType?._def?.typeName
+);
+
+// src/create/schema/metadata.ts
+var enhanceWithMetadata = (schemaObject, metadata) => {
+  if ("$ref" in schemaObject) {
+    if (Object.values(metadata).every((val) => val === void 0)) {
+      return schemaObject;
+    }
+    return {
+      allOf: [schemaObject, metadata]
+    };
+  }
+  return {
+    ...schemaObject,
+    ...metadata
+  };
+};
+
+// src/create/schema/parsers/array.ts
+var createArraySchema = (zodArray, state) => {
+  const zodType = zodArray._def.type;
+  const minItems = zodArray._def.exactLength?.value ?? zodArray._def.minLength?.value;
+  const maxItems = zodArray._def.exactLength?.value ?? zodArray._def.maxLength?.value;
+  return {
+    type: "array",
+    items: createSchemaObject(zodType, state, ["array items"]),
+    ...minItems !== void 0 && { minItems },
+    ...maxItems !== void 0 && { maxItems }
+  };
+};
+
+// src/create/schema/parsers/boolean.ts
+var createBooleanSchema = (_zodBoolean) => ({
+  type: "boolean"
+});
+
+// src/create/schema/parsers/brand.ts
+var createBrandedSchema = (zodBranded, state) => createSchemaObject(zodBranded._def.type, state, ["brand"]);
+
+// src/create/schema/parsers/catch.ts
+var createCatchSchema = (zodCatch, state) => createSchemaObject(zodCatch._def.innerType, state, ["catch"]);
+
+// src/create/schema/parsers/date.ts
+var createDateSchema = (_zodDate) => ({
+  type: "string"
+});
+
+// src/create/schema/parsers/default.ts
+var createDefaultSchema = (zodDefault, state) => {
+  const schemaObject = createSchemaObject(zodDefault._def.innerType, state, [
+    "default"
+  ]);
+  return enhanceWithMetadata(schemaObject, {
+    default: zodDefault._def.defaultValue()
+  });
+};
+
+// src/create/schema/parsers/discriminatedUnion.ts
+var createDiscriminatedUnionSchema = (zodDiscriminatedUnion, state) => {
+  const options = zodDiscriminatedUnion.options;
+  const schemas = options.map(
+    (option, index) => createSchemaObject(option, state, [`discriminated union option ${index}`])
+  );
+  const discriminator = mapDiscriminator(
+    schemas,
+    options,
+    zodDiscriminatedUnion.discriminator,
+    state
+  );
+  return {
+    oneOf: schemas,
+    ...discriminator && { discriminator }
+  };
+};
+var mapDiscriminator = (schemas, zodObjects, discriminator, state) => {
+  if (typeof discriminator !== "string") {
+    return void 0;
+  }
+  const mapping = {};
+  for (const [index, zodObject] of zodObjects.entries()) {
+    const schema = schemas[index];
+    const componentSchemaRef = "$ref" in schema ? schema?.$ref : void 0;
+    if (!componentSchemaRef) {
+      return void 0;
+    }
+    const value = zodObject.shape[discriminator];
+    if (isZodType(value, "ZodEnum")) {
+      for (const enumValue of value._def.values) {
+        mapping[enumValue] = componentSchemaRef;
+      }
+      continue;
+    }
+    const literalValue = (value?._def).value;
+    if (typeof literalValue !== "string") {
+      throw new Error(
+        `Discriminator ${discriminator} could not be found in on index ${index} of a discriminated union at ${state.path.join(
+          " > "
+        )}`
+      );
+    }
+    mapping[literalValue] = componentSchemaRef;
+  }
+  return {
+    propertyName: discriminator,
+    mapping
+  };
+};
+
+// src/create/schema/parsers/enum.ts
+var createEnumSchema = (zodEnum) => ({
+  type: "string",
+  enum: zodEnum._def.values
+});
+
+// src/create/schema/parsers/intersection.ts
+var createIntersectionSchema = (zodIntersection, state) => ({
+  allOf: [
+    createSchemaObject(zodIntersection._def.left, state, ["intersection left"]),
+    createSchemaObject(zodIntersection._def.right, state, [
+      "intersection right"
+    ])
+  ]
+});
+
+// src/create/schema/parsers/lazy.ts
+var createLazySchema = (zodLazy, state) => {
+  const innerSchema = zodLazy._def.getter();
+  return createSchemaObject(innerSchema, state, ["lazy schema"]);
+};
+
+// src/create/schema/parsers/literal.ts
+var createLiteralSchema = (zodLiteral) => ({
+  type: typeof zodLiteral.value,
+  enum: [zodLiteral._def.value]
+});
+
+// src/create/schema/parsers/manual.ts
+var createManualTypeSchema = (zodSchema, state) => {
+  if (!zodSchema._def.openapi?.type) {
+    const zodType = zodSchema.constructor.name;
+    if (isZodType(zodSchema, "ZodEffects")) {
+      const schemaName = `${zodType} - ${zodSchema._def.effect.type}`;
+      throw new Error(
+        `Unknown schema ${schemaName} at ${state.path.join(
+          " > "
+        )}. Please assign it a manual 'type', wrap it in a ZodPipeline or change the 'effectType'.`
+      );
+    }
+    throw new Error(
+      `Unknown schema ${zodType}. Please assign it a manual 'type'.`
+    );
+  }
+  return {
+    type: zodSchema._def.openapi.type
+  };
+};
+
+// src/openapi.ts
+var openApiVersions = [
+  "3.0.0",
+  "3.0.1",
+  "3.0.2",
+  "3.0.3",
+  "3.1.0"
+];
+var satisfiesVersion = (test, against) => openApiVersions.indexOf(test) >= openApiVersions.indexOf(against);
+
+// src/create/schema/parsers/nativeEnum.ts
+var createNativeEnumSchema = (zodEnum, state) => {
+  const enumValues = getValidEnumValues(zodEnum._def.values);
+  const { numbers, strings } = sortStringsAndNumbers(enumValues);
+  if (strings.length && numbers.length) {
+    if (satisfiesVersion(state.components.openapi, "3.1.0"))
+      return {
+        type: ["string", "number"],
+        enum: [...strings, ...numbers]
+      };
+    return {
+      oneOf: [
+        { type: "string", enum: strings },
+        { type: "number", enum: numbers }
+      ]
+    };
+  }
+  if (strings.length) {
+    return {
+      type: "string",
+      enum: strings
+    };
+  }
+  return {
+    type: "number",
+    enum: numbers
+  };
+};
+var getValidEnumValues = (enumValues) => {
+  const keys = Object.keys(enumValues).filter(
+    (key) => typeof enumValues[enumValues[key]] !== "number"
+  );
+  return keys.map((key) => enumValues[key]);
+};
+var sortStringsAndNumbers = (values) => ({
+  strings: values.filter((value) => typeof value === "string"),
+  numbers: values.filter((value) => typeof value === "number")
+});
+
+// src/create/schema/parsers/null.ts
+var createNullSchema = (_zodNull) => ({
+  type: "null"
+});
+
+// src/create/schema/parsers/nullable.ts
+var createNullableSchema = (zodNullable, state) => {
+  const schemaObject = createSchemaObject(zodNullable.unwrap(), state, [
+    "nullable"
+  ]);
+  if ("$ref" in schemaObject || schemaObject.allOf) {
+    return {
+      oneOf: mapNullOf([schemaObject], state.components.openapi)
+    };
+  }
+  if (schemaObject.oneOf) {
+    const { oneOf, ...schema2 } = schemaObject;
+    return {
+      oneOf: mapNullOf(oneOf, state.components.openapi),
+      ...schema2
+    };
+  }
+  if (schemaObject.anyOf) {
+    const { anyOf, ...schema2 } = schemaObject;
+    return {
+      anyOf: mapNullOf(anyOf, state.components.openapi),
+      ...schema2
+    };
+  }
+  const { type, ...schema } = schemaObject;
+  if (satisfiesVersion(state.components.openapi, "3.1.0")) {
+    return {
+      type: mapNullType(type),
+      ...schema
+    };
+  }
+  return {
+    type,
+    nullable: true,
+    ...schema,
+    // https://github.com/OAI/OpenAPI-Specification/blob/main/proposals/2019-10-31-Clarify-Nullable.md#if-a-schema-specifies-nullable-true-and-enum-1-2-3-does-that-schema-allow-null-values-see-1900
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    ...schema.enum && { enum: [...schema.enum, null] }
+  };
+};
+var mapNullType = (type) => {
+  if (!type) {
+    return "null";
+  }
+  if (Array.isArray(type)) {
+    return [...type, "null"];
+  }
+  return [type, "null"];
+};
+var mapNullOf = (ofSchema, openapi) => {
+  if (satisfiesVersion(openapi, "3.1.0")) {
+    return [...ofSchema, { type: "null" }];
+  }
+  return [...ofSchema, { nullable: true }];
+};
+
+// src/create/schema/parsers/number.ts
+var createNumberSchema = (zodNumber, state) => {
+  const zodNumberChecks = getZodNumberChecks(zodNumber);
+  const minimum = mapMinimum(zodNumberChecks, state.components.openapi);
+  const maximum = mapMaximum(zodNumberChecks, state.components.openapi);
+  return {
+    type: mapNumberType(zodNumberChecks),
+    ...minimum && minimum,
+    // Union types are not easy to tame
+    ...maximum && maximum
+  };
+};
+var mapMaximum = (zodNumberCheck, openapi) => {
+  if (!zodNumberCheck.max) {
+    return void 0;
+  }
+  const maximum = zodNumberCheck.max.value;
+  if (zodNumberCheck.max.inclusive) {
+    return { ...maximum !== void 0 && { maximum } };
+  }
+  if (satisfiesVersion(openapi, "3.1.0")) {
+    return { exclusiveMaximum: maximum };
+  }
+  return { maximum, exclusiveMaximum: true };
+};
+var mapMinimum = (zodNumberCheck, openapi) => {
+  if (!zodNumberCheck.min) {
+    return void 0;
+  }
+  const minimum = zodNumberCheck.min.value;
+  if (zodNumberCheck.min.inclusive) {
+    return { ...minimum !== void 0 && { minimum } };
+  }
+  if (satisfiesVersion(openapi, "3.1.0")) {
+    return { exclusiveMinimum: minimum };
+  }
+  return { minimum, exclusiveMinimum: true };
+};
+var getZodNumberChecks = (zodNumber) => zodNumber._def.checks.reduce((acc, check) => {
+  acc[check.kind] = check;
+  return acc;
+}, {});
+var mapNumberType = (zodNumberChecks) => zodNumberChecks.int ? "integer" : "number";
+
+// src/create/schema/parsers/optional.ts
+var createOptionalSchema = (zodOptional, state) => (
+  // Optional doesn't change OpenAPI schema
+  createSchemaObject(zodOptional.unwrap(), state, ["optional"])
+);
+var isOptionalSchema = (zodSchema, state) => {
+  if (isZodType(zodSchema, "ZodOptional")) {
+    return true;
+  }
+  if (isZodType(zodSchema, "ZodDefault")) {
+    return state.type === "input";
+  }
+  if (isZodType(zodSchema, "ZodNullable") || isZodType(zodSchema, "ZodCatch")) {
+    return isOptionalSchema(zodSchema._def.innerType, state);
+  }
+  if (isZodType(zodSchema, "ZodEffects")) {
+    return isOptionalSchema(zodSchema._def.schema, state);
+  }
+  if (isZodType(zodSchema, "ZodUnion") || isZodType(zodSchema, "ZodDiscriminatedUnion")) {
+    return zodSchema._def.options.some(
+      (schema) => isOptionalSchema(schema, state)
+    );
+  }
+  if (isZodType(zodSchema, "ZodIntersection")) {
+    return [zodSchema._def.left, zodSchema._def.right].some(
+      (schema) => isOptionalSchema(schema, state)
+    );
+  }
+  if (isZodType(zodSchema, "ZodPipeline")) {
+    if (state.effectType === "input" || state.type === "input" && state.effectType !== "output") {
+      return isOptionalSchema(zodSchema._def.in, state);
+    }
+    if (state.effectType === "output" || state.type === "output" && state.effectType !== "input") {
+      return isOptionalSchema(zodSchema._def.out, state);
+    }
+  }
+  if (isZodType(zodSchema, "ZodLazy")) {
+    return isOptionalSchema(zodSchema._def.getter(), state);
+  }
+  return zodSchema.isOptional();
+};
+
+// src/create/schema/parsers/object.ts
+var createObjectSchema = (zodObject, state) => {
+  const extendedSchema = createExtendedSchema(
+    zodObject,
+    zodObject._def.extendMetadata?.extends,
+    state
+  );
+  if (extendedSchema) {
+    return extendedSchema;
+  }
+  return createObjectSchemaFromShape(
+    zodObject.shape,
+    {
+      unknownKeys: zodObject._def.unknownKeys,
+      catchAll: zodObject._def.catchall
+    },
+    state
+  );
+};
+var createExtendedSchema = (zodObject, baseZodObject, state) => {
+  if (!baseZodObject) {
+    return void 0;
+  }
+  const component = state.components.schemas.get(baseZodObject);
+  if (component ?? baseZodObject._def.openapi?.ref) {
+    createSchemaObject(baseZodObject, state, ["extended schema"]);
+  }
+  const completeComponent = state.components.schemas.get(baseZodObject);
+  if (!completeComponent) {
+    return void 0;
+  }
+  const diffOpts = createDiffOpts(
+    {
+      unknownKeys: baseZodObject._def.unknownKeys,
+      catchAll: baseZodObject._def.catchall
+    },
+    {
+      unknownKeys: zodObject._def.unknownKeys,
+      catchAll: zodObject._def.catchall
+    }
+  );
+  if (!diffOpts) {
+    return void 0;
+  }
+  const diffShape = createShapeDiff(
+    baseZodObject._def.shape(),
+    zodObject._def.shape()
+  );
+  if (!diffShape) {
+    return void 0;
+  }
+  return {
+    allOf: [{ $ref: createComponentSchemaRef(completeComponent.ref) }],
+    ...createObjectSchemaFromShape(diffShape, diffOpts, state)
+  };
+};
+var createDiffOpts = (baseOpts, extendedOpts) => {
+  if (baseOpts.unknownKeys === "strict" || !isZodType(baseOpts.catchAll, "ZodNever")) {
+    return void 0;
+  }
+  return {
+    catchAll: extendedOpts.catchAll,
+    unknownKeys: extendedOpts.unknownKeys
+  };
+};
+var createShapeDiff = (baseObj, extendedObj) => {
+  const acc = {};
+  for (const [key, val] of Object.entries(extendedObj)) {
+    const baseValue = baseObj[key];
+    if (val === baseValue) {
+      continue;
+    }
+    if (baseValue === void 0) {
+      acc[key] = extendedObj[key];
+      continue;
+    }
+    return null;
+  }
+  return acc;
+};
+var createObjectSchemaFromShape = (shape, { unknownKeys, catchAll }, state) => {
+  const properties = mapProperties(shape, state);
+  const required = mapRequired(shape, state);
+  return {
+    type: "object",
+    ...properties && { properties },
+    ...required && { required },
+    ...unknownKeys === "strict" && { additionalProperties: false },
+    ...!isZodType(catchAll, "ZodNever") && {
+      additionalProperties: createSchemaObject(catchAll, state, [
+        "additional properties"
+      ])
+    }
+  };
+};
+var mapRequired = (shape, state) => {
+  const required = Object.entries(shape).filter(([_key, zodSchema]) => !isOptionalSchema(zodSchema, state)).map(([key]) => key);
+  if (!required.length) {
+    return void 0;
+  }
+  return required;
+};
+var mapProperties = (shape, state) => Object.entries(shape).reduce(
+  (acc, [key, zodSchema]) => {
+    acc[key] = createSchemaObject(zodSchema, state, [`property: ${key}`]);
+    return acc;
+  },
+  {}
+);
+
+// src/create/schema/parsers/pipeline.ts
+var createPipelineSchema = (zodPipeline, state) => {
+  if (zodPipeline._def.openapi?.effectType === "input") {
+    return createSchemaObject(zodPipeline._def.in, state, ["pipeline input"]);
+  }
+  if (zodPipeline._def.openapi?.effectType === "output") {
+    return createSchemaObject(zodPipeline._def.out, state, ["pipeline output"]);
+  }
+  if (state.type === "input") {
+    state.effectType = "input";
+    return createSchemaObject(zodPipeline._def.in, state, ["pipeline input"]);
+  }
+  state.effectType = "output";
+  return createSchemaObject(zodPipeline._def.out, state, ["pipeline output"]);
+};
+
+// src/create/schema/parsers/preprocess.ts
+var createPreprocessSchema = (zodPreprocess, state) => createSchemaObject(zodPreprocess._def.schema, state, ["preprocess schema"]);
+
+// src/create/schema/parsers/readonly.ts
+var createReadonlySchema = (zodReadonly, state) => (
+  // Readonly doesn't change OpenAPI schema
+  createSchemaObject(zodReadonly._def.innerType, state, ["readonly"])
+);
+
+// src/create/schema/parsers/record.ts
+var createRecordSchema = (zodRecord, state) => {
+  const additionalProperties = createSchemaObject(
+    zodRecord.valueSchema,
+    state,
+    ["record value"]
+  );
+  const keySchema = createSchemaObject(zodRecord.keySchema, state, [
+    "record key"
+  ]);
+  const maybeComponent = "$ref" in keySchema && state.components.schemas.get(zodRecord.keySchema);
+  const maybeSchema = maybeComponent && maybeComponent.type === "complete" && maybeComponent.schemaObject;
+  const renderedKeySchema = maybeSchema || keySchema;
+  if ("enum" in renderedKeySchema && renderedKeySchema.enum) {
+    return {
+      type: "object",
+      properties: renderedKeySchema.enum.reduce((acc, key) => {
+        acc[key] = additionalProperties;
+        return acc;
+      }, {}),
+      additionalProperties: false
+    };
+  }
+  if (satisfiesVersion(state.components.openapi, "3.1.0") && "type" in renderedKeySchema && renderedKeySchema.type === "string" && Object.keys(renderedKeySchema).length > 1) {
+    return {
+      type: "object",
+      // @ts-expect-error FIXME: https://github.com/metadevpro/openapi3-ts/pull/120
+      propertyNames: keySchema,
+      additionalProperties
+    };
+  }
+  return {
+    type: "object",
+    additionalProperties
+  };
+};
+
+// src/create/schema/parsers/refine.ts
+var createRefineSchema = (zodRefine, state) => createSchemaObject(zodRefine._def.schema, state, ["refine schema"]);
+
+// src/create/schema/parsers/set.ts
+var createSetSchema = (zodSet, state) => {
+  const schema = zodSet._def.valueType;
+  const minItems = zodSet._def.minSize?.value;
+  const maxItems = zodSet._def.maxSize?.value;
+  return {
+    type: "array",
+    items: createSchemaObject(schema, state, ["set items"]),
+    uniqueItems: true,
+    ...minItems !== void 0 && { minItems },
+    ...maxItems !== void 0 && { maxItems }
+  };
+};
+
+// src/create/schema/parsers/string.ts
+var createStringSchema = (zodString) => {
+  const zodStringChecks = getZodStringChecks(zodString);
+  const format = mapStringFormat(zodStringChecks);
+  const patterns = mapPatterns(zodStringChecks);
+  const minLength = zodStringChecks.length?.[0]?.value ?? zodStringChecks.min?.[0]?.value;
+  const maxLength = zodStringChecks.length?.[0]?.value ?? zodStringChecks.max?.[0]?.value;
+  if (patterns.length <= 1) {
+    return {
+      type: "string",
+      ...format && { format },
+      ...patterns[0] && { pattern: patterns[0] },
+      ...minLength !== void 0 && { minLength },
+      ...maxLength !== void 0 && { maxLength }
+    };
+  }
+  return {
+    allOf: [
+      {
+        type: "string",
+        ...format && { format },
+        ...patterns[0] && { pattern: patterns[0] },
+        ...minLength !== void 0 && { minLength },
+        ...maxLength !== void 0 && { maxLength }
+      },
+      ...patterns.slice(1).map(
+        (pattern) => ({
+          type: "string",
+          pattern
+        })
+      )
+    ]
+  };
+};
+var getZodStringChecks = (zodString) => zodString._def.checks.reduce(
+  (acc, check) => {
+    const mapping = acc[check.kind];
+    if (mapping) {
+      mapping.push(check);
+      return acc;
+    }
+    acc[check.kind] = [check];
+    return acc;
+  },
+  {}
+);
+var mapPatterns = (zodStringChecks) => {
+  const startsWith = mapStartsWith(zodStringChecks);
+  const endsWith = mapEndsWith(zodStringChecks);
+  const regex = mapRegex(zodStringChecks);
+  const includes = mapIncludes(zodStringChecks);
+  const patterns = [
+    ...regex ?? [],
+    ...startsWith ? [startsWith] : [],
+    ...endsWith ? [endsWith] : [],
+    ...includes ?? []
+  ];
+  return patterns;
+};
+var mapStartsWith = (zodStringChecks) => {
+  if (zodStringChecks.startsWith?.[0]?.value) {
+    return `^${zodStringChecks.startsWith[0].value}`;
+  }
+  return void 0;
+};
+var mapEndsWith = (zodStringChecks) => {
+  if (zodStringChecks.endsWith?.[0]?.value) {
+    return `${zodStringChecks.endsWith[0].value}$`;
+  }
+  return void 0;
+};
+var mapRegex = (zodStringChecks) => zodStringChecks.regex?.map((regexCheck) => regexCheck.regex.source);
+var mapIncludes = (zodStringChecks) => zodStringChecks.includes?.map((includeCheck) => {
+  if (includeCheck.position === 0) {
+    return `^${includeCheck.value}`;
+  }
+  if (includeCheck.position) {
+    return `^.{${includeCheck.position}}${includeCheck.value}`;
+  }
+  return includeCheck.value;
+});
+var mapStringFormat = (zodStringChecks) => {
+  if (zodStringChecks.uuid) {
+    return "uuid";
+  }
+  if (zodStringChecks.datetime) {
+    return "date-time";
+  }
+  if (zodStringChecks.email) {
+    return "email";
+  }
+  if (zodStringChecks.url) {
+    return "uri";
+  }
+  return void 0;
+};
+
+// src/create/schema/parsers/transform.ts
+var createTransformSchema = (zodTransform, state) => {
+  if (zodTransform._def.openapi?.effectType === "output") {
+    return createManualTypeSchema(zodTransform, state);
+  }
+  if (zodTransform._def.openapi?.effectType === "input") {
+    return createSchemaObject(zodTransform._def.schema, state, [
+      "transform input"
+    ]);
+  }
+  if (state.type === "output") {
+    return createManualTypeSchema(zodTransform, state);
+  }
+  state.effectType = "input";
+  return createSchemaObject(zodTransform._def.schema, state, [
+    "transform input"
+  ]);
+};
+var throwTransformError = (zodType, state) => {
+  throw new Error(
+    `${JSON.stringify(zodType)} at ${state.path.join(
+      " > "
+    )} contains a transformation but is used in both an input and an output. This is likely a mistake. Set an \`effectType\`, wrap it in a ZodPipeline or assign it a manual type to resolve`
+  );
+};
+
+// src/create/schema/parsers/tuple.ts
+var createTupleSchema = (zodTuple, state) => {
+  const items = zodTuple.items;
+  const rest = zodTuple._def.rest;
+  return {
+    type: "array",
+    ...mapItemProperties(items, rest, state)
+  };
+};
+var mapPrefixItems = (items, state) => {
+  if (items.length) {
+    return items.map(
+      (item, index) => createSchemaObject(item, state, [`tuple item ${index}`])
+    );
+  }
+  return void 0;
+};
+var mapItemProperties = (items, rest, state) => {
+  const prefixItems = mapPrefixItems(items, state);
+  if (satisfiesVersion(state.components.openapi, "3.1.0")) {
+    if (!rest) {
+      return {
+        maxItems: items.length,
+        minItems: items.length,
+        ...prefixItems && { prefixItems }
+      };
+    }
+    return {
+      items: createSchemaObject(rest, state, ["tuple items"]),
+      ...prefixItems && { prefixItems }
+    };
+  }
+  if (!rest) {
+    return {
+      maxItems: items.length,
+      minItems: items.length,
+      ...prefixItems && { items: { oneOf: prefixItems } }
+    };
+  }
+  return {
+    ...prefixItems && {
+      items: {
+        oneOf: [
+          ...prefixItems,
+          createSchemaObject(rest, state, ["tuple items"])
+        ]
+      }
+    }
+  };
+};
+
+// src/create/schema/parsers/union.ts
+var createUnionSchema = (zodUnion, state) => {
+  const schemas = zodUnion.options.map(
+    (option, index) => createSchemaObject(option, state, [`union option ${index}`])
+  );
+  if (zodUnion._def.openapi?.unionOneOf) {
+    return {
+      oneOf: schemas
+    };
+  }
+  return {
+    anyOf: schemas
+  };
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.api = void 0;
-__exportStar(require("./create/document"), exports);
-__exportStar(require("./extendZod"), exports);
-__exportStar(require("./openapi3-ts/dist"), exports);
-exports.api = __importStar(require("./api"));
-//# sourceMappingURL=index.js.map
+
+// src/create/schema/parsers/unknown.ts
+var createUnknownSchema = (_zodUnknown) => ({});
+
+// src/create/schema/parsers/index.ts
+var createSchemaSwitch = (zodSchema, state) => {
+  if (zodSchema._def.openapi?.type) {
+    return createManualTypeSchema(zodSchema, state);
+  }
+  if (isZodType(zodSchema, "ZodString")) {
+    return createStringSchema(zodSchema);
+  }
+  if (isZodType(zodSchema, "ZodNumber")) {
+    return createNumberSchema(zodSchema, state);
+  }
+  if (isZodType(zodSchema, "ZodBoolean")) {
+    return createBooleanSchema(zodSchema);
+  }
+  if (isZodType(zodSchema, "ZodEnum")) {
+    return createEnumSchema(zodSchema);
+  }
+  if (isZodType(zodSchema, "ZodLiteral")) {
+    return createLiteralSchema(zodSchema);
+  }
+  if (isZodType(zodSchema, "ZodNativeEnum")) {
+    return createNativeEnumSchema(zodSchema, state);
+  }
+  if (isZodType(zodSchema, "ZodArray")) {
+    return createArraySchema(zodSchema, state);
+  }
+  if (isZodType(zodSchema, "ZodObject")) {
+    return createObjectSchema(zodSchema, state);
+  }
+  if (isZodType(zodSchema, "ZodUnion")) {
+    return createUnionSchema(zodSchema, state);
+  }
+  if (isZodType(zodSchema, "ZodDiscriminatedUnion")) {
+    return createDiscriminatedUnionSchema(zodSchema, state);
+  }
+  if (isZodType(zodSchema, "ZodNull")) {
+    return createNullSchema(zodSchema);
+  }
+  if (isZodType(zodSchema, "ZodNullable")) {
+    return createNullableSchema(zodSchema, state);
+  }
+  if (isZodType(zodSchema, "ZodOptional")) {
+    return createOptionalSchema(zodSchema, state);
+  }
+  if (isZodType(zodSchema, "ZodReadonly")) {
+    return createReadonlySchema(zodSchema, state);
+  }
+  if (isZodType(zodSchema, "ZodDefault")) {
+    return createDefaultSchema(zodSchema, state);
+  }
+  if (isZodType(zodSchema, "ZodRecord")) {
+    return createRecordSchema(zodSchema, state);
+  }
+  if (isZodType(zodSchema, "ZodTuple")) {
+    return createTupleSchema(zodSchema, state);
+  }
+  if (isZodType(zodSchema, "ZodDate")) {
+    return createDateSchema(zodSchema);
+  }
+  if (isZodType(zodSchema, "ZodPipeline")) {
+    return createPipelineSchema(zodSchema, state);
+  }
+  if (isZodType(zodSchema, "ZodEffects") && zodSchema._def.effect.type === "transform") {
+    return createTransformSchema(zodSchema, state);
+  }
+  if (isZodType(zodSchema, "ZodEffects") && zodSchema._def.effect.type === "preprocess") {
+    return createPreprocessSchema(zodSchema, state);
+  }
+  if (isZodType(zodSchema, "ZodEffects") && zodSchema._def.effect.type === "refinement") {
+    return createRefineSchema(zodSchema, state);
+  }
+  if (isZodType(zodSchema, "ZodNativeEnum")) {
+    return createNativeEnumSchema(zodSchema, state);
+  }
+  if (isZodType(zodSchema, "ZodIntersection")) {
+    return createIntersectionSchema(zodSchema, state);
+  }
+  if (isZodType(zodSchema, "ZodCatch")) {
+    return createCatchSchema(zodSchema, state);
+  }
+  if (isZodType(zodSchema, "ZodUnknown") || isZodType(zodSchema, "ZodAny")) {
+    return createUnknownSchema(zodSchema);
+  }
+  if (isZodType(zodSchema, "ZodLazy")) {
+    return createLazySchema(zodSchema, state);
+  }
+  if (isZodType(zodSchema, "ZodBranded")) {
+    return createBrandedSchema(zodSchema, state);
+  }
+  if (isZodType(zodSchema, "ZodSet")) {
+    return createSetSchema(zodSchema, state);
+  }
+  return createManualTypeSchema(zodSchema, state);
+};
+
+// src/create/schema/index.ts
+var newSchemaState = (state) => ({
+  type: state.type,
+  components: state.components,
+  path: [...state.path],
+  visited: new Set(state.visited)
+});
+var createNewSchema = (zodSchema, newState, subpath) => {
+  newState.path.push(...subpath);
+  if (newState.visited.has(zodSchema)) {
+    throw new Error(
+      `The schema at ${newState.path.join(
+        " > "
+      )} needs to be registered because it's circularly referenced`
+    );
+  }
+  newState.visited.add(zodSchema);
+  const {
+    effectType,
+    param,
+    header,
+    ref,
+    refType,
+    unionOneOf,
+    ...additionalMetadata
+  } = zodSchema._def.openapi ?? {};
+  const schema = createSchemaSwitch(zodSchema, newState);
+  const description = zodSchema.description;
+  const schemaWithMetadata = enhanceWithMetadata(schema, {
+    ...description && { description },
+    ...additionalMetadata
+  });
+  return {
+    schema: schemaWithMetadata,
+    newState
+  };
+};
+var createNewRef = (ref, zodSchema, state, subpath) => {
+  state.components.schemas.set(zodSchema, {
+    type: "in-progress",
+    ref
+  });
+  const newSchema = createNewSchema(
+    zodSchema,
+    newSchemaState({ ...state, visited: /* @__PURE__ */ new Set() }),
+    subpath
+  );
+  state.components.schemas.set(zodSchema, {
+    type: "complete",
+    ref,
+    schemaObject: newSchema.schema,
+    creationType: newSchema.newState?.effectType
+  });
+  return {
+    schema: { $ref: createComponentSchemaRef(ref) },
+    newState: newSchema.newState
+  };
+};
+var createExistingRef = (zodSchema, component, state, subpath) => {
+  const newState = newSchemaState(state);
+  newState.path.push(...subpath);
+  if (component && component.type === "complete") {
+    if (component.creationType && component.creationType !== state.type) {
+      throwTransformError(zodSchema, newState);
+    }
+    return {
+      schema: { $ref: createComponentSchemaRef(component.ref) },
+      newState: {
+        ...newState,
+        effectType: component.creationType
+      }
+    };
+  }
+  if (component && component.type === "in-progress") {
+    return {
+      schema: { $ref: createComponentSchemaRef(component.ref) },
+      newState
+    };
+  }
+  return;
+};
+var createSchemaOrRef = (zodSchema, state, subpath) => {
+  const component = state.components.schemas.get(zodSchema);
+  const existingRef = createExistingRef(zodSchema, component, state, subpath);
+  if (existingRef) {
+    return existingRef;
+  }
+  const ref = zodSchema._def.openapi?.ref ?? component?.ref;
+  if (ref) {
+    return createNewRef(ref, zodSchema, state, subpath);
+  }
+  return createNewSchema(zodSchema, newSchemaState(state), subpath);
+};
+var createSchemaObject = (zodSchema, state, subpath) => {
+  const { schema, newState } = createSchemaOrRef(zodSchema, state, subpath);
+  if (newState?.effectType) {
+    if (state.type !== newState?.effectType || state.effectType && newState.effectType !== state.effectType) {
+      throwTransformError(zodSchema, newState);
+    }
+    state.effectType = newState.effectType;
+  }
+  return schema;
+};
+
+// src/create/parameters.ts
+var createComponentParamRef = (ref) => `#/components/parameters/${ref}`;
+var createBaseParameter = (schema, components, subpath) => {
+  const { ref, ...rest } = schema._def.openapi?.param ?? {};
+  const state = newSchemaState({
+    components,
+    type: "input",
+    path: [],
+    visited: /* @__PURE__ */ new Set()
+  });
+  const schemaObject = createSchemaObject(schema, state, [
+    ...subpath,
+    "schema"
+  ]);
+  const required = !isOptionalSchema(schema, state);
+  return {
+    ...rest,
+    ...schema && { schema: schemaObject },
+    ...required && { required }
+  };
+};
+var createParamOrRef = (zodSchema, components, subpath, type, name) => {
+  const component = components.parameters.get(zodSchema);
+  const paramType = zodSchema._def?.openapi?.param?.in ?? component?.in ?? type;
+  const paramName = zodSchema._def?.openapi?.param?.name ?? component?.name ?? name;
+  if (!paramType) {
+    throw new Error("Parameter type missing");
+  }
+  if (!paramName) {
+    throw new Error("Parameter name missing");
+  }
+  if (component && component.type === "complete") {
+    if (!("$ref" in component.paramObject) && (component.in !== type || component.name !== name)) {
+      throw new Error(`parameterRef "${component.ref}" is already registered`);
+    }
+    return {
+      $ref: createComponentParamRef(component.ref)
+    };
+  }
+  const baseParamOrRef = createBaseParameter(zodSchema, components, subpath);
+  if ("$ref" in baseParamOrRef) {
+    throw new Error("Unexpected Error: received a reference object");
+  }
+  const ref = zodSchema?._def?.openapi?.param?.ref ?? component?.ref;
+  const paramObject = {
+    in: paramType,
+    name: paramName,
+    ...baseParamOrRef
+  };
+  if (ref) {
+    components.parameters.set(zodSchema, {
+      type: "complete",
+      paramObject,
+      ref,
+      in: paramType,
+      name: paramName
+    });
+    return {
+      $ref: createComponentParamRef(ref)
+    };
+  }
+  return paramObject;
+};
+var createParameters = (type, zodObject, components, subpath) => {
+  if (!zodObject) {
+    return [];
+  }
+  return Object.entries(zodObject.shape).map(
+    ([key, zodSchema]) => createParamOrRef(zodSchema, components, [...subpath, key], type, key)
+  );
+};
+var createRequestParams = (requestParams, components, subpath) => {
+  if (!requestParams) {
+    return [];
+  }
+  const pathParams = createParameters("path", requestParams.path, components, [
+    ...subpath,
+    "path"
+  ]);
+  const queryParams = createParameters(
+    "query",
+    requestParams.query,
+    components,
+    [...subpath, "query"]
+  );
+  const cookieParams = createParameters(
+    "cookie",
+    requestParams.cookie,
+    components,
+    [...subpath, "cookie"]
+  );
+  const headerParams = createParameters(
+    "header",
+    requestParams.header,
+    components,
+    [...subpath, "header"]
+  );
+  return [...pathParams, ...queryParams, ...cookieParams, ...headerParams];
+};
+var createManualParameters = (parameters, components, subpath) => parameters?.map((param, index) => {
+  if (isAnyZodType(param)) {
+    return createParamOrRef(param, components, [
+      ...subpath,
+      `param index ${index}`
+    ]);
+  }
+  return param;
+}) ?? [];
+var createParametersObject = (parameters, requestParams, components, subpath) => {
+  const manualParameters = createManualParameters(
+    parameters,
+    components,
+    subpath
+  );
+  const createdParams = createRequestParams(requestParams, components, subpath);
+  const combinedParameters = [
+    ...manualParameters,
+    ...createdParams
+  ];
+  return combinedParameters.length ? combinedParameters : void 0;
+};
+
+// src/create/content.ts
+var createMediaTypeSchema = (schemaObject, components, type, subpath) => {
+  if (!schemaObject) {
+    return void 0;
+  }
+  if (!isAnyZodType(schemaObject)) {
+    return schemaObject;
+  }
+  return createSchemaObject(
+    schemaObject,
+    newSchemaState({
+      components,
+      type,
+      path: [],
+      visited: /* @__PURE__ */ new Set()
+    }),
+    subpath
+  );
+};
+var createMediaTypeObject = (mediaTypeObject, components, type, subpath) => {
+  if (!mediaTypeObject) {
+    return void 0;
+  }
+  return {
+    ...mediaTypeObject,
+    schema: createMediaTypeSchema(mediaTypeObject.schema, components, type, [
+      ...subpath,
+      "schema"
+    ])
+  };
+};
+var createContent = (contentObject, components, type, subpath) => Object.entries(contentObject).reduce(
+  (acc, [mediaType, zodOpenApiMediaTypeObject]) => {
+    const mediaTypeObject = createMediaTypeObject(
+      zodOpenApiMediaTypeObject,
+      components,
+      type,
+      [...subpath, mediaType]
+    );
+    if (mediaTypeObject) {
+      acc[mediaType] = mediaTypeObject;
+    }
+    return acc;
+  },
+  {}
+);
+
+// src/create/specificationExtension.ts
+var isISpecificationExtension = (key) => key.startsWith("x-");
+
+// src/create/responses.ts
+var createResponseHeaders = (responseHeaders, components) => {
+  if (!responseHeaders) {
+    return void 0;
+  }
+  if (isAnyZodType(responseHeaders)) {
+    return Object.entries(responseHeaders.shape).reduce((acc, [key, zodSchema]) => {
+      acc[key] = createHeaderOrRef(zodSchema, components);
+      return acc;
+    }, {});
+  }
+  return responseHeaders;
+};
+var createHeaderOrRef = (schema, components) => {
+  const component = components.headers.get(schema);
+  if (component && component.type === "complete") {
+    return {
+      $ref: createComponentHeaderRef(component.ref)
+    };
+  }
+  const baseHeader = createBaseHeader(schema, components);
+  if ("$ref" in baseHeader) {
+    throw new Error("Unexpected Error: received a reference object");
+  }
+  const ref = schema._def?.openapi?.header?.ref ?? component?.ref;
+  if (ref) {
+    components.headers.set(schema, {
+      type: "complete",
+      headerObject: baseHeader,
+      ref
+    });
+    return {
+      $ref: createComponentHeaderRef(ref)
+    };
+  }
+  return baseHeader;
+};
+var createBaseHeader = (schema, components) => {
+  const { ref, ...rest } = schema._def.openapi?.header ?? {};
+  const state = newSchemaState({
+    components,
+    type: "output",
+    path: [],
+    visited: /* @__PURE__ */ new Set()
+  });
+  const schemaObject = createSchemaObject(schema, state, ["header"]);
+  const required = !isOptionalSchema(schema, state);
+  return {
+    ...rest,
+    ...schema && { schema: schemaObject },
+    ...required && { required }
+  };
+};
+var createComponentHeaderRef = (ref) => `#/components/headers/${ref}`;
+var createResponse = (responseObject, components, subpath) => {
+  if ("$ref" in responseObject) {
+    return responseObject;
+  }
+  const component = components.responses.get(responseObject);
+  if (component && component.type === "complete") {
+    return { $ref: createComponentResponseRef(component.ref) };
+  }
+  const { content, headers, ref, ...rest } = responseObject;
+  const maybeHeaders = createResponseHeaders(headers, components);
+  const response = {
+    ...rest,
+    ...maybeHeaders && { headers: maybeHeaders },
+    ...content && {
+      content: createContent(content, components, "output", [
+        ...subpath,
+        "content"
+      ])
+    }
+  };
+  const responseRef = ref ?? component?.ref;
+  if (responseRef) {
+    components.responses.set(responseObject, {
+      responseObject: response,
+      ref: responseRef,
+      type: "complete"
+    });
+    return {
+      $ref: createComponentResponseRef(responseRef)
+    };
+  }
+  return response;
+};
+var createResponses = (responsesObject, components, subpath) => Object.entries(responsesObject).reduce(
+  (acc, [statusCode, responseObject]) => {
+    if (isISpecificationExtension(statusCode)) {
+      acc[statusCode] = responseObject;
+      return acc;
+    }
+    acc[statusCode] = createResponse(responseObject, components, [
+      ...subpath,
+      statusCode
+    ]);
+    return acc;
+  },
+  {}
+);
+
+// src/create/paths.ts
+var createRequestBody = (requestBodyObject, components, subpath) => {
+  if (!requestBodyObject) {
+    return void 0;
+  }
+  const component = components.requestBodies.get(requestBodyObject);
+  if (component && component.type === "complete") {
+    return {
+      $ref: createComponentRequestBodyRef(component.ref)
+    };
+  }
+  const ref = requestBodyObject.ref ?? component?.ref;
+  const requestBody = {
+    ...requestBodyObject,
+    content: createContent(requestBodyObject.content, components, "input", [
+      ...subpath,
+      "content"
+    ])
+  };
+  if (ref) {
+    components.requestBodies.set(requestBodyObject, {
+      type: "complete",
+      ref,
+      requestBodyObject: requestBody
+    });
+    return {
+      $ref: createComponentRequestBodyRef(ref)
+    };
+  }
+  return requestBody;
+};
+var createOperation = (operationObject, components, subpath) => {
+  const { parameters, requestParams, requestBody, responses, ...rest } = operationObject;
+  const maybeParameters = createParametersObject(
+    parameters,
+    requestParams,
+    components,
+    [...subpath, "parameters"]
+  );
+  const maybeRequestBody = createRequestBody(
+    operationObject.requestBody,
+    components,
+    [...subpath, "request body"]
+  );
+  const maybeResponses = createResponses(
+    operationObject.responses,
+    components,
+    [...subpath, "responses"]
+  );
+  return {
+    ...rest,
+    ...maybeParameters && { parameters: maybeParameters },
+    ...maybeRequestBody && { requestBody: maybeRequestBody },
+    ...maybeResponses && { responses: maybeResponses }
+  };
+};
+var createPathItem = (pathObject, components, path) => Object.entries(pathObject).reduce(
+  (acc, [key, value]) => {
+    if (!value) {
+      return acc;
+    }
+    if (key === "get" || key === "put" || key === "post" || key === "delete" || key === "options" || key === "head" || key === "patch" || key === "trace") {
+      acc[key] = createOperation(
+        value,
+        components,
+        [path, key]
+      );
+      return acc;
+    }
+    acc[key] = value;
+    return acc;
+  },
+  {}
+);
+var createPaths = (pathsObject, components) => {
+  if (!pathsObject) {
+    return void 0;
+  }
+  return Object.entries(pathsObject).reduce(
+    (acc, [path, pathItemObject]) => {
+      if (isISpecificationExtension(path)) {
+        acc[path] = pathItemObject;
+        return acc;
+      }
+      acc[path] = createPathItem(pathItemObject, components, path);
+      return acc;
+    },
+    {}
+  );
+};
+
+// src/create/components.ts
+var getDefaultComponents = (componentsObject, openapi = "3.1.0") => {
+  const defaultComponents = {
+    schemas: /* @__PURE__ */ new Map(),
+    parameters: /* @__PURE__ */ new Map(),
+    headers: /* @__PURE__ */ new Map(),
+    requestBodies: /* @__PURE__ */ new Map(),
+    responses: /* @__PURE__ */ new Map(),
+    openapi
+  };
+  if (!componentsObject) {
+    return defaultComponents;
+  }
+  getSchemas(componentsObject.schemas, defaultComponents);
+  getParameters(componentsObject.parameters, defaultComponents);
+  getRequestBodies(componentsObject.requestBodies, defaultComponents);
+  getHeaders(componentsObject.headers, defaultComponents);
+  getResponses(componentsObject.responses, defaultComponents);
+  return defaultComponents;
+};
+var getSchemas = (schemas, components) => {
+  if (!schemas) {
+    return;
+  }
+  Object.entries(schemas).forEach(([key, schema]) => {
+    if (isAnyZodType(schema)) {
+      if (components.schemas.has(schema)) {
+        throw new Error(
+          `Schema ${JSON.stringify(schema._def)} is already registered`
+        );
+      }
+      const ref = schema._def.openapi?.ref ?? key;
+      components.schemas.set(schema, {
+        type: "manual",
+        ref
+      });
+    }
+  });
+};
+var getParameters = (parameters, components) => {
+  if (!parameters) {
+    return;
+  }
+  Object.entries(parameters).forEach(([key, schema]) => {
+    if (isAnyZodType(schema)) {
+      if (components.parameters.has(schema)) {
+        throw new Error(
+          `Parameter ${JSON.stringify(schema._def)} is already registered`
+        );
+      }
+      const ref = schema._def.openapi?.param?.ref ?? key;
+      const name = schema._def.openapi?.param?.name;
+      const location = schema._def.openapi?.param?.in;
+      if (!name || !location) {
+        throw new Error("`name` or `in` missing in .openapi()");
+      }
+      components.parameters.set(schema, {
+        type: "manual",
+        ref,
+        in: location,
+        name
+      });
+    }
+  });
+};
+var getHeaders = (responseHeaders, components) => {
+  if (!responseHeaders) {
+    return;
+  }
+  Object.entries(responseHeaders).forEach(([key, schema]) => {
+    if (isAnyZodType(schema)) {
+      if (components.parameters.has(schema)) {
+        throw new Error(
+          `Header ${JSON.stringify(schema._def)} is already registered`
+        );
+      }
+      const ref = schema._def.openapi?.param?.ref ?? key;
+      components.headers.set(schema, {
+        type: "manual",
+        ref
+      });
+    }
+  });
+};
+var getResponses = (responses, components) => {
+  if (!responses) {
+    return;
+  }
+  Object.entries(responses).forEach(([key, responseObject]) => {
+    if (components.responses.has(responseObject)) {
+      throw new Error(
+        `Header ${JSON.stringify(responseObject)} is already registered`
+      );
+    }
+    const ref = responseObject?.ref ?? key;
+    components.responses.set(responseObject, {
+      type: "manual",
+      ref
+    });
+  });
+};
+var getRequestBodies = (requestBodies, components) => {
+  if (!requestBodies) {
+    return;
+  }
+  Object.entries(requestBodies).forEach(([key, requestBody]) => {
+    if (components.requestBodies.has(requestBody)) {
+      throw new Error(
+        `Header ${JSON.stringify(requestBody)} is already registered`
+      );
+    }
+    const ref = requestBody?.ref ?? key;
+    components.requestBodies.set(requestBody, {
+      type: "manual",
+      ref
+    });
+  });
+};
+var createComponentSchemaRef = (schemaRef) => `#/components/schemas/${schemaRef}`;
+var createComponentResponseRef = (responseRef) => `#/components/responses/${responseRef}`;
+var createComponentRequestBodyRef = (requestBodyRef) => `#/components/requestBodies/${requestBodyRef}`;
+var createComponents = (componentsObject, components) => {
+  const combinedSchemas = createSchemaComponents(componentsObject, components);
+  const combinedParameters = createParamComponents(
+    componentsObject,
+    components
+  );
+  const combinedHeaders = createHeaderComponents(componentsObject, components);
+  const combinedResponses = createResponseComponents(components);
+  const combinedRequestBodies = createRequestBodiesComponents(components);
+  const { schemas, parameters, headers, responses, requestBodies, ...rest } = componentsObject;
+  const finalComponents = {
+    ...rest,
+    ...combinedSchemas && { schemas: combinedSchemas },
+    ...combinedParameters && { parameters: combinedParameters },
+    ...combinedRequestBodies && { requestBodies: combinedRequestBodies },
+    ...combinedHeaders && { headers: combinedHeaders },
+    ...combinedResponses && { responses: combinedResponses }
+  };
+  return Object.keys(finalComponents).length ? finalComponents : void 0;
+};
+var createSchemaComponents = (componentsObject, components) => {
+  Array.from(components.schemas).forEach(([schema, { type }], index) => {
+    if (type === "manual") {
+      const state = newSchemaState({
+        components,
+        type: schema._def.openapi?.refType ?? "output",
+        path: [],
+        visited: /* @__PURE__ */ new Set()
+      });
+      createSchemaObject(schema, state, [`component schema index ${index}`]);
+    }
+  });
+  const customComponents = Object.entries(
+    componentsObject.schemas ?? {}
+  ).reduce(
+    (acc, [key, value]) => {
+      if (isAnyZodType(value)) {
+        return acc;
+      }
+      if (acc[key]) {
+        throw new Error(`Schema "${key}" is already registered`);
+      }
+      acc[key] = value;
+      return acc;
+    },
+    {}
+  );
+  const finalComponents = Array.from(components.schemas).reduce((acc, [_zodType, component]) => {
+    if (component.type === "complete") {
+      if (acc[component.ref]) {
+        throw new Error(`Schema "${component.ref}" is already registered`);
+      }
+      acc[component.ref] = component.schemaObject;
+    }
+    return acc;
+  }, customComponents);
+  return Object.keys(finalComponents).length ? finalComponents : void 0;
+};
+var createParamComponents = (componentsObject, components) => {
+  Array.from(components.parameters).forEach(([schema, component], index) => {
+    if (component.type === "manual") {
+      createParamOrRef(
+        schema,
+        components,
+        [`component parameter index ${index}`],
+        component.in,
+        component.ref
+      );
+    }
+  });
+  const customComponents = Object.entries(
+    componentsObject.parameters ?? {}
+  ).reduce(
+    (acc, [key, value]) => {
+      if (!isAnyZodType(value)) {
+        if (acc[key]) {
+          throw new Error(`Parameter "${key}" is already registered`);
+        }
+        acc[key] = value;
+      }
+      return acc;
+    },
+    {}
+  );
+  const finalComponents = Array.from(components.parameters).reduce((acc, [_zodType, component]) => {
+    if (component.type === "complete") {
+      if (acc[component.ref]) {
+        throw new Error(`Parameter "${component.ref}" is already registered`);
+      }
+      acc[component.ref] = component.paramObject;
+    }
+    return acc;
+  }, customComponents);
+  return Object.keys(finalComponents).length ? finalComponents : void 0;
+};
+var createHeaderComponents = (componentsObject, components) => {
+  Array.from(components.headers).forEach(([schema, component]) => {
+    if (component.type === "manual") {
+      createHeaderOrRef(schema, components);
+    }
+  });
+  const headers = componentsObject.headers ?? {};
+  const customComponents = Object.entries(headers).reduce((acc, [key, value]) => {
+    if (!isAnyZodType(value)) {
+      if (acc[key]) {
+        throw new Error(`Header Ref "${key}" is already registered`);
+      }
+      acc[key] = value;
+    }
+    return acc;
+  }, {});
+  const finalComponents = Array.from(components.headers).reduce((acc, [_zodType, component]) => {
+    if (component.type === "complete") {
+      if (acc[component.ref]) {
+        throw new Error(`Header "${component.ref}" is already registered`);
+      }
+      acc[component.ref] = component.headerObject;
+    }
+    return acc;
+  }, customComponents);
+  return Object.keys(finalComponents).length ? finalComponents : void 0;
+};
+var createResponseComponents = (components) => {
+  Array.from(components.responses).forEach(([schema, component], index) => {
+    if (component.type === "manual") {
+      createResponse(schema, components, [`component response index ${index}`]);
+    }
+  });
+  const finalComponents = Array.from(components.responses).reduce((acc, [_zodType, component]) => {
+    if (component.type === "complete") {
+      if (acc[component.ref]) {
+        throw new Error(`Response "${component.ref}" is already registered`);
+      }
+      acc[component.ref] = component.responseObject;
+    }
+    return acc;
+  }, {});
+  return Object.keys(finalComponents).length ? finalComponents : void 0;
+};
+var createRequestBodiesComponents = (components) => {
+  Array.from(components.requestBodies).forEach(([schema, component], index) => {
+    if (component.type === "manual") {
+      createRequestBody(schema, components, [
+        `component request body ${index}`
+      ]);
+    }
+  });
+  const finalComponents = Array.from(components.requestBodies).reduce((acc, [_zodType, component]) => {
+    if (component.type === "complete") {
+      if (acc[component.ref]) {
+        throw new Error(`RequestBody "${component.ref}" is already registered`);
+      }
+      acc[component.ref] = component.requestBodyObject;
+    }
+    return acc;
+  }, {});
+  return Object.keys(finalComponents).length ? finalComponents : void 0;
+};
+
+// src/create/document.ts
+var createDocument = (zodOpenApiObject) => {
+  const { paths, webhooks, components = {}, ...rest } = zodOpenApiObject;
+  const defaultComponents = getDefaultComponents(
+    components,
+    zodOpenApiObject.openapi
+  );
+  const createdPaths = createPaths(paths, defaultComponents);
+  const createdWebhooks = createPaths(webhooks, defaultComponents);
+  const createdComponents = createComponents(components, defaultComponents);
+  return {
+    ...rest,
+    ...createdPaths && { paths: createdPaths },
+    ...createdWebhooks && { webhooks: createdWebhooks },
+    ...createdComponents && { components: createdComponents }
+  };
+};
+
+// src/extendZod.ts
+function extendZodWithOpenApi(zod) {
+  if (typeof zod.ZodType.prototype.openapi !== "undefined") {
+    return;
+  }
+  zod.ZodType.prototype.openapi = function(openapi) {
+    const result = new this.constructor({
+      ...this._def,
+      openapi
+    });
+    return result;
+  };
+  const zodObjectExtend = zod.ZodObject.prototype.extend;
+  zod.ZodObject.prototype.extend = function(...args) {
+    const extendResult = zodObjectExtend.apply(this, args);
+    extendResult._def.extendMetadata = {
+      extends: this
+    };
+    delete extendResult._def.openapi;
+    return extendResult;
+  };
+  const zodObjectOmit = zod.ZodObject.prototype.omit;
+  zod.ZodObject.prototype.omit = function(...args) {
+    const omitResult = zodObjectOmit.apply(this, args);
+    delete omitResult._def.extendMetadata;
+    delete omitResult._def.openapi;
+    return omitResult;
+  };
+  const zodObjectPick = zod.ZodObject.prototype.pick;
+  zod.ZodObject.prototype.pick = function(...args) {
+    const pickResult = zodObjectPick.apply(this, args);
+    delete pickResult._def.extendMetadata;
+    delete pickResult._def.openapi;
+    return pickResult;
+  };
+}
+
+// src/openapi3-ts/dist/oas30.ts
+var oas30_exports = {};
+
+// src/openapi3-ts/dist/oas31.ts
+var oas31_exports = {};
+
+// src/api.ts
+var api_exports = {};
+__export(api_exports, {
+  createComponents: () => createComponents,
+  createMediaTypeSchema: () => createMediaTypeSchema,
+  createParamOrRef: () => createParamOrRef,
+  getDefaultComponents: () => getDefaultComponents
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  api,
+  createDocument,
+  extendZodWithOpenApi,
+  oas30,
+  oas31
+});