zod-openapi 5.0.0-beta.0 → 5.0.0-beta.1

package/dist/components.chunk.cjs

@@ -1,1078 +1,2463 @@
 "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);
+const extendZodSymbols = require("./extendZodSymbols.chunk.cjs");
+const isZodType = (zodType, typeName) => {
+  var _a;
+  return ((_a = zodType == null ? void 0 : zodType._def) == null ? void 0 : _a.typeName) === typeName;
+};
+const isAnyZodType = (zodType) => {
+  var _a;
+  return Boolean(
+    (_a = zodType == null ? void 0 : zodType._def) == null ? void 0 : _a.typeName
+  );
+};
+const openApiVersions = [
+  "3.0.0",
+  "3.0.1",
+  "3.0.2",
+  "3.0.3",
+  "3.1.0",
+  "3.1.1"
+];
+const satisfiesVersion = (test, against) => openApiVersions.indexOf(test) >= openApiVersions.indexOf(against);
+const createDescriptionMetadata = (schema, description, state) => {
+  if (satisfiesVersion(state.components.openapi, "3.1.0")) {
+    return {
+      type: "ref",
+      schema: {
+        $ref: schema.schema.$ref,
+        description
+      },
+      zodType: schema.zodType,
+      effects: schema.effects,
+      schemaObject: schema.schemaObject
+    };
+  }
+  return {
+    type: "schema",
+    schema: {
+      description,
+      allOf: [schema.schema]
+    },
+    effects: schema.effects
+  };
+};
+const isValueEqual = (value, previous) => {
+  if (typeof value !== typeof previous) {
+    return false;
+  }
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return value === previous;
+  }
+  if (Array.isArray(value) && Array.isArray(previous)) {
+    const sorted = [...value].sort();
+    const previousSorted = [...previous].sort();
+    return sorted.every((v, i) => isValueEqual(v, previousSorted[i]));
+  }
+  if (value === null || previous === null) {
+    return value === previous;
+  }
+  if (typeof value === "object" && typeof previous === "object") {
+    const keys = Object.keys(value);
+    return keys.every(
+      (key) => isValueEqual(
+        value[key],
+        previous[key]
+      )
+    );
+  }
+  return value === previous;
+};
+const enhanceWithMetadata = (schema, metadata, state, previous) => {
+  const values = Object.entries(metadata).reduce(
+    (acc, [key, value]) => {
+      if (value === void 0) {
+        return acc;
       }
-      return unwrapZodObject(def.out, io, path);
+      acc[key] = value;
+      return acc;
+    },
+    {}
+  );
+  const length = Object.values(values).length;
+  if (schema.type === "ref") {
+    if (length === 0) {
+      return schema;
+    }
+    if (length === 1 && metadata.description) {
+      return createDescriptionMetadata(schema, metadata.description, state);
     }
+    return {
+      type: "schema",
+      schema: {
+        allOf: [schema.schema],
+        ...metadata
+      },
+      effects: schema.effects
+    };
   }
-  throw new Error(
-    `Failed to unwrap ZodObject from type: ${zodType._zod.def.type} at ${path.join(" > ")}`
+  if (previous && schema.schema.type !== "object") {
+    const diff = Object.entries({ ...schema.schema, ...values }).reduce(
+      (acc, [key, value]) => {
+        if (previous.schemaObject && isValueEqual(
+          previous.schemaObject[key],
+          value
+        )) {
+          return acc;
+        }
+        acc[key] = value;
+        return acc;
+      },
+      {}
+    );
+    const diffLength = Object.values(diff).length;
+    if (diffLength === 0) {
+      return {
+        type: "ref",
+        schema: {
+          $ref: previous.schema.$ref
+        },
+        effects: schema.effects,
+        schemaObject: previous.schemaObject,
+        zodType: previous.zodType
+      };
+    }
+    if (diffLength === 1 && typeof diff.description === "string") {
+      return createDescriptionMetadata(previous, diff.description, state);
+    }
+    return {
+      type: "schema",
+      schema: { allOf: [previous.schema], ...diff },
+      effects: schema.effects
+    };
+  }
+  return {
+    type: "schema",
+    schema: {
+      ...schema.schema,
+      ...metadata
+    },
+    effects: schema.effects
+  };
+};
+const createArraySchema = (zodArray, state) => {
+  var _a, _b, _c, _d;
+  const zodType = zodArray._def.type;
+  const minItems = ((_a = zodArray._def.exactLength) == null ? void 0 : _a.value) ?? ((_b = zodArray._def.minLength) == null ? void 0 : _b.value);
+  const maxItems = ((_c = zodArray._def.exactLength) == null ? void 0 : _c.value) ?? ((_d = zodArray._def.maxLength) == null ? void 0 : _d.value);
+  const items = createSchemaObject(zodType, state, ["array items"]);
+  return {
+    type: "schema",
+    schema: {
+      type: "array",
+      items: items.schema,
+      ...minItems !== void 0 && { minItems },
+      ...maxItems !== void 0 && { maxItems }
+    },
+    effects: items.effects
+  };
+};
+const createBigIntSchema = (_zodBigInt) => ({
+  type: "schema",
+  schema: {
+    type: "integer",
+    format: "int64"
+  }
+});
+const createBooleanSchema = (_zodBoolean) => ({
+  type: "schema",
+  schema: {
+    type: "boolean"
+  }
+});
+const createBrandedSchema = (zodBranded, state) => createSchemaObject(zodBranded._def.type, state, ["brand"]);
+const createCatchSchema = (zodCatch, state, previous) => {
+  const schemaObject = createSchemaObject(zodCatch._def.innerType, state, [
+    "default"
+  ]);
+  const catchResult = zodCatch.safeParse(void 0);
+  const maybeDefaultValue = catchResult.success ? {
+    default: catchResult.data
+  } : {};
+  return enhanceWithMetadata(schemaObject, maybeDefaultValue, state, previous);
+};
+const createDateSchema = (_zodDate, state) => {
+  var _a;
+  return {
+    type: "schema",
+    schema: ((_a = state.documentOptions) == null ? void 0 : _a.defaultDateSchema) ?? {
+      type: "string"
+    }
+  };
+};
+const createDefaultSchema = (zodDefault, state, previous) => {
+  const schemaObject = createSchemaObject(zodDefault._def.innerType, state, [
+    "default"
+  ]);
+  return enhanceWithMetadata(
+    schemaObject,
+    {
+      default: zodDefault._def.defaultValue()
+    },
+    state,
+    previous
+  );
+};
+const 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: "schema",
+        schema: {
+          type: ["string", "number"],
+          enum: [...strings, ...numbers]
+        }
+      };
+    }
+    return {
+      type: "schema",
+      schema: {
+        oneOf: [
+          { type: "string", enum: strings },
+          { type: "number", enum: numbers }
+        ]
+      }
+    };
+  }
+  if (strings.length) {
+    return {
+      type: "schema",
+      schema: {
+        type: "string",
+        enum: strings
+      }
+    };
+  }
+  return {
+    type: "schema",
+    schema: {
+      type: "number",
+      enum: numbers
+    }
+  };
+};
+const getValidEnumValues = (enumValues) => {
+  const keys = Object.keys(enumValues).filter(
+    (key) => typeof enumValues[enumValues[key]] !== "number"
   );
+  return keys.map((key) => enumValues[key]);
 };
-const isRequired = (zodType, io) => {
-  if (io === "input") {
-    return zodType._zod.optin === void 0;
+const sortStringsAndNumbers = (values) => ({
+  strings: values.filter((value) => typeof value === "string"),
+  numbers: values.filter((value) => typeof value === "number")
+});
+const createTransformSchema = (zodTransform, state) => {
+  var _a, _b, _c, _d, _e, _f;
+  if (((_b = (_a = zodTransform._def.zodOpenApi) == null ? void 0 : _a.openapi) == null ? void 0 : _b.effectType) === "output") {
+    return {
+      type: "schema",
+      schema: createManualOutputTransformSchema(zodTransform, state)
+    };
+  }
+  if (((_d = (_c = zodTransform._def.zodOpenApi) == null ? void 0 : _c.openapi) == null ? void 0 : _d.effectType) === "input" || ((_f = (_e = zodTransform._def.zodOpenApi) == null ? void 0 : _e.openapi) == null ? void 0 : _f.effectType) === "same") {
+    return createSchemaObject(zodTransform._def.schema, state, [
+      "transform input"
+    ]);
+  }
+  if (state.type === "output") {
+    return {
+      type: "schema",
+      schema: createManualOutputTransformSchema(zodTransform, state)
+    };
   }
-  return zodType._zod.optout === void 0;
+  const schema = createSchemaObject(zodTransform._def.schema, state, [
+    "transform input"
+  ]);
+  return {
+    ...schema,
+    effects: flattenEffects([
+      [
+        {
+          type: "schema",
+          creationType: "input",
+          zodType: zodTransform,
+          path: [...state.path]
+        }
+      ],
+      schema.effects
+    ])
+  };
 };
-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) {
+const createManualOutputTransformSchema = (zodTransform, state) => {
+  var _a, _b, _c;
+  if (!((_b = (_a = zodTransform._def.zodOpenApi) == null ? void 0 : _a.openapi) == null ? void 0 : _b.type)) {
+    const zodType = zodTransform.constructor.name;
+    const schemaName = `${zodType} - ${zodTransform._def.effect.type}`;
     throw new Error(
-      `Parameter at ${path.join(" > ")} is missing \`.meta({ param: { name, in } })\` information`
+      `Failed to determine a type for ${schemaName} at ${state.path.join(
+        " > "
+      )}. Please change the 'effectType' to 'same' or 'input', wrap it in a ZodPipeline or assign it a manual 'type'.`
     );
   }
-  const computedPath = [...path, inLocation, name].join(" > ");
-  const schemaObject = ctx.registry.schemas.setSchema(
-    computedPath,
-    parameter,
-    ctx.io
+  return {
+    type: (_c = zodTransform._def.zodOpenApi) == null ? void 0 : _c.openapi.type
+  };
+};
+const getZodTypeName = (zodType) => {
+  if (isZodType(zodType, "ZodEffects")) {
+    return `${zodType._def.typeName} - ${zodType._def.effect.type}`;
+  }
+  return zodType._def.typeName;
+};
+const throwTransformError = (effect) => {
+  const typeName = getZodTypeName(effect.zodType);
+  const input = effect.creationType;
+  const opposite = input === "input" ? "output" : "input";
+  throw new Error(
+    `The ${typeName} at ${effect.path.join(
+      " > "
+    )} is used within a registered compoment schema${effect.component ? ` (${effect.component.ref})` : ""} and contains an ${input} transformation${effect.component ? ` (${getZodTypeName(
+      effect.component.zodType
+    )}) defined at ${effect.component.path.join(" > ")}` : ""} which is also used in an ${opposite} schema.
+
+This may cause the schema to render incorrectly and is most likely a mistake. You can resolve this by:
+
+1. Setting an \`effectType\` on one of the transformations to \`same\` (Not applicable for ZodDefault), \`input\` or \`output\` eg. \`.openapi({type: 'same'})\`
+2. Wrapping the transformation in a ZodPipeline
+3. Assigning a manual type to the transformation eg. \`.openapi({type: 'string'})\`
+4. Removing the transformation
+5. Deregister the component containing the transformation`
   );
-  const { id, ...rest } = (meta == null ? void 0 : meta.param) ?? {};
-  const parameterObject = {
-    ...rest,
-    name,
-    in: inLocation,
-    schema: schemaObject
+};
+const resolveSingleEffect = (effect, state) => {
+  if (effect.type === "schema") {
+    return {
+      creationType: effect.creationType,
+      path: effect.path,
+      zodType: effect.zodType
+    };
+  }
+  if (effect.type === "component") {
+    if (state.visited.has(effect.zodType)) {
+      return;
+    }
+    const component = state.components.schemas.get(effect.zodType);
+    if ((component == null ? void 0 : component.type) !== "complete") {
+      throw new Error("Something went wrong, component schema is not complete");
+    }
+    if (component.resolvedEffect) {
+      return {
+        creationType: component.resolvedEffect.creationType,
+        path: effect.path,
+        zodType: effect.zodType,
+        component: {
+          ref: component.ref,
+          zodType: component.resolvedEffect.zodType,
+          path: component.resolvedEffect.path
+        }
+      };
+    }
+    if (!component.effects) {
+      return void 0;
+    }
+    state.visited.add(effect.zodType);
+    const resolved = resolveEffect(component.effects, state);
+    state.visited.delete(effect.zodType);
+    if (!resolved) {
+      return void 0;
+    }
+    component.resolvedEffect = resolved;
+    return resolved;
+  }
+  return void 0;
+};
+const resolveEffect = (effects, state) => {
+  const { input, output } = effects.reduce(
+    (acc, effect) => {
+      const resolvedSchemaEffect = resolveSingleEffect(effect, state);
+      if ((resolvedSchemaEffect == null ? void 0 : resolvedSchemaEffect.creationType) === "input") {
+        acc.input.push(resolvedSchemaEffect);
+      }
+      if ((resolvedSchemaEffect == null ? void 0 : resolvedSchemaEffect.creationType) === "output") {
+        acc.output.push(resolvedSchemaEffect);
+      }
+      if (resolvedSchemaEffect && acc.input.length > 1 && acc.output.length > 1) {
+        throwTransformError(resolvedSchemaEffect);
+      }
+      return acc;
+    },
+    { input: [], output: [] }
+  );
+  if (input.length > 0) {
+    return input[0];
+  }
+  if (output.length > 0) {
+    return output[0];
+  }
+  return void 0;
+};
+const verifyEffects = (effects, state) => {
+  const resolved = resolveEffect(effects, state);
+  if ((resolved == null ? void 0 : resolved.creationType) && resolved.creationType !== state.type) {
+    throwTransformError(resolved);
+  }
+};
+const flattenEffects = (effects) => {
+  const allEffects = effects.reduce((acc, effect) => {
+    if (effect) {
+      return acc.concat(effect);
+    }
+    return acc;
+  }, []);
+  return allEffects.length ? allEffects : void 0;
+};
+const createDiscriminatedUnionSchema = (zodDiscriminatedUnion, state) => {
+  const options = zodDiscriminatedUnion.options;
+  const schemas = options.map(
+    (option, index) => createSchemaObject(option, state, [`discriminated union option ${index}`])
+  );
+  const schemaObjects = schemas.map((schema) => schema.schema);
+  const discriminator = mapDiscriminator(
+    schemaObjects,
+    options,
+    zodDiscriminatedUnion.discriminator,
+    state
+  );
+  return {
+    type: "schema",
+    schema: {
+      oneOf: schemaObjects,
+      ...discriminator && { discriminator }
+    },
+    effects: flattenEffects(schemas.map((schema) => schema.effects))
   };
-  if (isRequired(parameter, ctx.io)) {
-    parameterObject.required = true;
+};
+const unwrapLiterals = (zodType, state) => {
+  if (isZodType(zodType, "ZodLiteral")) {
+    if (typeof zodType._def.value !== "string") {
+      return void 0;
+    }
+    return [zodType._def.value];
   }
-  if (!parameterObject.description && (meta == null ? void 0 : meta.description)) {
-    parameterObject.description = meta.description;
+  if (isZodType(zodType, "ZodNativeEnum")) {
+    const schema = createNativeEnumSchema(zodType, state);
+    if (schema.type === "schema" && schema.schema.type === "string") {
+      return schema.schema.enum;
+    }
   }
-  if (id) {
-    const ref = {
-      $ref: `#/components/parameters/${id}`
-    };
-    ctx.registry.parameters.seen.set(parameter, ref);
-    ctx.registry.parameters.ids.set(id, parameterObject);
-    return ref;
+  if (isZodType(zodType, "ZodEnum")) {
+    return zodType._def.values;
   }
-  ctx.registry.parameters.seen.set(parameter, parameterObject);
-  return parameterObject;
+  if (isZodType(zodType, "ZodBranded")) {
+    return unwrapLiterals(zodType._def.type, state);
+  }
+  if (isZodType(zodType, "ZodReadonly")) {
+    return unwrapLiterals(zodType._def.innerType, state);
+  }
+  if (isZodType(zodType, "ZodCatch")) {
+    return unwrapLiterals(zodType._def.innerType, state);
+  }
+  return void 0;
 };
-const createManualParameters = (parameters, ctx, path) => {
-  if (!parameters) {
+const mapDiscriminator = (schemas, zodObjects, discriminator, state) => {
+  var _a;
+  if (typeof discriminator !== "string") {
     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 mapping = {};
+  for (const [index, zodObject] of zodObjects.entries()) {
+    const schema = schemas[index];
+    const componentSchemaRef = "$ref" in schema ? schema == null ? void 0 : schema.$ref : void 0;
+    if (!componentSchemaRef) {
+      if ((_a = state.documentOptions) == null ? void 0 : _a.enforceDiscriminatedUnionComponents) {
+        throw new Error(
+          `Discriminated Union member ${index} at ${state.path.join(" > ")} is not registered as a component`
+        );
       }
-      const paramObject = createParameter(parameter, void 0, ctx, [
-        ...path,
-        "parameters"
-      ]);
-      parameterObjects.push(paramObject);
-      continue;
+      return void 0;
+    }
+    const value = zodObject.shape[discriminator];
+    const literals = unwrapLiterals(value, state);
+    if (!literals) {
+      return void 0;
+    }
+    for (const enumValue of literals) {
+      mapping[enumValue] = componentSchemaRef;
     }
-    parameterObjects.push(parameter);
   }
-  return parameterObjects;
+  return {
+    propertyName: discriminator,
+    mapping
+  };
 };
-const createParameters = (requestParams, ctx, path) => {
-  if (!requestParams) {
-    return void 0;
+const createEnumSchema = (zodEnum) => ({
+  type: "schema",
+  schema: {
+    type: "string",
+    enum: zodEnum._def.values
+  }
+});
+const createIntersectionSchema = (zodIntersection, state) => {
+  const schemas = flattenIntersection(zodIntersection);
+  const allOfs = schemas.map(
+    (schema, index) => createSchemaObject(schema, state, [`intersection ${index}`])
+  );
+  return {
+    type: "schema",
+    schema: {
+      allOf: allOfs.map((schema) => schema.schema)
+    },
+    effects: flattenEffects(allOfs.map((schema) => schema.effects))
+  };
+};
+const flattenIntersection = (zodType) => {
+  if (!isZodType(zodType, "ZodIntersection")) {
+    return [zodType];
   }
-  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 leftSchemas = flattenIntersection(zodType._def.left);
+  const rightSchemas = flattenIntersection(zodType._def.right);
+  return [...leftSchemas, ...rightSchemas];
+};
+const createLazySchema = (zodLazy, state) => {
+  const innerSchema = zodLazy._def.getter();
+  return createSchemaObject(innerSchema, state, ["lazy schema"]);
+};
+const createNullSchema = () => ({
+  type: "schema",
+  schema: {
+    type: "null"
+  }
+});
+const createLiteralSchema = (zodLiteral, state) => {
+  if (zodLiteral.value === null) {
+    return createNullSchema();
+  }
+  if (satisfiesVersion(state.components.openapi, "3.1.0")) {
+    return {
+      type: "schema",
+      schema: {
+        type: typeof zodLiteral.value,
+        const: zodLiteral.value
       }
-      const paramObject = createParameter(
-        zodSchema,
-        {
-          in: location,
-          name
-        },
-        ctx,
-        [...path, location, name]
-      );
-      parameterObjects.push(paramObject);
-    }
+    };
   }
-  return parameterObjects;
+  return {
+    type: "schema",
+    schema: {
+      type: typeof zodLiteral.value,
+      enum: [zodLiteral.value]
+    }
+  };
 };
-const createMediaTypeObject = (mediaTypeObject, ctx, path) => {
-  const computedPath = path.join(" > ");
-  if (isAnyZodType(mediaTypeObject.schema)) {
-    const schemaObject = ctx.registry.schemas.setSchema(
-      computedPath,
-      mediaTypeObject.schema,
-      ctx.io
+const createManualTypeSchema = (zodSchema, state) => {
+  var _a, _b, _c;
+  if (!((_b = (_a = zodSchema._def.zodOpenApi) == null ? void 0 : _a.openapi) == null ? void 0 : _b.type)) {
+    const schemaName = zodSchema.constructor.name;
+    throw new Error(
+      `Unknown schema ${schemaName} at ${state.path.join(
+        " > "
+      )}. Please assign it a manual 'type'.`
     );
+  }
+  return {
+    type: "schema",
+    schema: {
+      type: (_c = zodSchema._def.zodOpenApi) == null ? void 0 : _c.openapi.type
+    }
+  };
+};
+const createNullableSchema = (zodNullable, state) => {
+  const schemaObject = createSchemaObject(zodNullable.unwrap(), state, [
+    "nullable"
+  ]);
+  if (satisfiesVersion(state.components.openapi, "3.1.0")) {
+    if (schemaObject.type === "ref" || schemaObject.schema.allOf) {
+      return {
+        type: "schema",
+        schema: {
+          oneOf: mapNullOf([schemaObject.schema], state.components.openapi)
+        },
+        effects: schemaObject.effects
+      };
+    }
+    if (schemaObject.schema.oneOf) {
+      const { oneOf, ...schema3 } = schemaObject.schema;
+      return {
+        type: "schema",
+        schema: {
+          oneOf: mapNullOf(oneOf, state.components.openapi),
+          ...schema3
+        },
+        effects: schemaObject.effects
+      };
+    }
+    if (schemaObject.schema.anyOf) {
+      const { anyOf, ...schema3 } = schemaObject.schema;
+      return {
+        type: "schema",
+        schema: {
+          anyOf: mapNullOf(anyOf, state.components.openapi),
+          ...schema3
+        },
+        effects: schemaObject.effects
+      };
+    }
+    const { type: type2, const: schemaConst, ...schema2 } = schemaObject.schema;
+    if (schemaConst) {
+      return {
+        type: "schema",
+        schema: {
+          type: mapNullType(type2),
+          enum: [schemaConst, null],
+          ...schema2
+        },
+        effects: schemaObject.effects
+      };
+    }
+    return {
+      type: "schema",
+      schema: {
+        type: mapNullType(type2),
+        ...schema2,
+        // https://github.com/json-schema-org/json-schema-spec/issues/258
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        ...schema2.enum && { enum: [...schema2.enum, null] }
+      },
+      effects: schemaObject.effects
+    };
+  }
+  if (schemaObject.type === "ref") {
     return {
-      ...mediaTypeObject,
-      schema: schemaObject
+      type: "schema",
+      schema: {
+        allOf: [schemaObject.schema],
+        nullable: true
+      },
+      effects: schemaObject.effects
     };
   }
-  return mediaTypeObject;
+  const { type, ...schema } = schemaObject.schema;
+  return {
+    type: "schema",
+    schema: {
+      ...type && { 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] }
+    },
+    effects: schemaObject.effects
+  };
 };
-const createContent = (content, ctx, path) => {
-  const contentObject = {};
-  for (const [mediaType, mediaTypeObject] of Object.entries(content)) {
-    if (mediaTypeObject) {
-      contentObject[mediaType] = createMediaTypeObject(mediaTypeObject, ctx, [
-        ...path,
-        mediaType
-      ]);
+const mapNullType = (type) => {
+  if (!type) {
+    return "null";
+  }
+  if (Array.isArray(type)) {
+    return [...type, "null"];
+  }
+  return [type, "null"];
+};
+const mapNullOf = (ofSchema, openapi) => {
+  if (satisfiesVersion(openapi, "3.1.0")) {
+    return [...ofSchema, { type: "null" }];
+  }
+  return [...ofSchema, { nullable: true }];
+};
+const createNumberSchema = (zodNumber, state) => {
+  const zodNumberChecks = getZodNumberChecks(zodNumber);
+  const minimum = mapMinimum(zodNumberChecks, state.components.openapi);
+  const maximum = mapMaximum(zodNumberChecks, state.components.openapi);
+  const multipleOf = mapMultipleOf(zodNumberChecks);
+  return {
+    type: "schema",
+    schema: {
+      type: mapNumberType(zodNumberChecks),
+      ...multipleOf && multipleOf,
+      ...minimum && minimum,
+      // Union types are not easy to tame
+      ...maximum && maximum
     }
+  };
+};
+const mapMultipleOf = (zodNumberCheck) => zodNumberCheck.multipleOf ? { multipleOf: zodNumberCheck.multipleOf.value } : void 0;
+const mapMaximum = (zodNumberCheck, openapi) => {
+  if (!zodNumberCheck.max) {
+    return void 0;
+  }
+  const maximum = zodNumberCheck.max.value;
+  if (zodNumberCheck.max.inclusive) {
+    return { ...maximum !== void 0 && { maximum } };
   }
-  return contentObject;
+  if (satisfiesVersion(openapi, "3.1.0")) {
+    return { exclusiveMaximum: maximum };
+  }
+  return { maximum, exclusiveMaximum: true };
 };
-const createRequestBody = (requestBody, ctx, path) => {
-  if (!requestBody) {
+const mapMinimum = (zodNumberCheck, openapi) => {
+  if (!zodNumberCheck.min) {
     return void 0;
   }
-  const seenRequestBody = ctx.registry.requestBodies.seen.get(requestBody);
-  if (seenRequestBody) {
-    return seenRequestBody;
+  const minimum = zodNumberCheck.min.value;
+  if (zodNumberCheck.min.inclusive) {
+    return { ...minimum !== void 0 && { minimum } };
   }
-  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 (satisfiesVersion(openapi, "3.1.0")) {
+    return { exclusiveMinimum: minimum };
+  }
+  return { minimum, exclusiveMinimum: true };
+};
+const getZodNumberChecks = (zodNumber) => zodNumber._def.checks.reduce((acc, check) => {
+  acc[check.kind] = check;
+  return acc;
+}, {});
+const mapNumberType = (zodNumberChecks) => zodNumberChecks.int ? "integer" : "number";
+const createOptionalSchema = (zodOptional, state) => createSchemaObject(zodOptional.unwrap(), state, ["optional"]);
+const isOptionalObjectKey = (zodSchema) => isZodType(zodSchema, "ZodNever") || isZodType(zodSchema, "ZodUndefined") || isZodType(zodSchema, "ZodOptional") && isOptionalObjectKey(zodSchema.unwrap()) || isZodType(zodSchema, "ZodLiteral") && zodSchema._def.value === void 0;
+const createObjectSchema = (zodObject, previous, state) => {
+  const extendedSchema = createExtendedSchema(
+    zodObject,
+    previous == null ? void 0 : previous.zodType,
+    state
   );
-  if (id) {
-    const ref = {
-      $ref: `#/components/headers/${id}`
-    };
-    ctx.registry.headers.ids.set(id, headerObject);
-    ctx.registry.headers.seen.set(header, ref);
-    return ref;
+  if (extendedSchema) {
+    return extendedSchema;
   }
-  ctx.registry.headers.seen.set(header, headerObject);
-  return headerObject;
+  return createObjectSchemaFromShape(
+    zodObject.shape,
+    {
+      unknownKeys: zodObject._def.unknownKeys,
+      catchAll: zodObject._def.catchall
+    },
+    state
+  );
 };
-const createHeaders = (headers, ctx, path) => {
-  if (!headers) {
+const createExtendedSchema = (zodObject, baseZodObject, state) => {
+  var _a, _b, _c, _d, _e;
+  if (!baseZodObject) {
     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;
+  const component = state.components.schemas.get(baseZodObject);
+  if (component ?? ((_b = (_a = baseZodObject._def.zodOpenApi) == null ? void 0 : _a.openapi) == null ? void 0 : _b.ref)) {
+    createSchemaObject(baseZodObject, state, ["extended schema"]);
   }
-  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 completeComponent = state.components.schemas.get(baseZodObject);
+  if (!completeComponent) {
+    return void 0;
   }
-  const { content, headers, id, ...rest } = response;
-  const responseObject = rest;
-  if (id) {
-    ctx.registry.responses.ids.set(id, responseObject);
+  const diffOpts = createDiffOpts(
+    {
+      unknownKeys: baseZodObject._def.unknownKeys,
+      catchAll: baseZodObject._def.catchall
+    },
+    {
+      unknownKeys: zodObject._def.unknownKeys,
+      catchAll: zodObject._def.catchall
+    }
+  );
+  if (!diffOpts) {
+    return void 0;
   }
-  ctx.registry.responses.seen.set(response, responseObject);
-  const maybeHeaders = createHeaders(headers, ctx, [...path, "headers"]);
-  if (maybeHeaders) {
-    responseObject.headers = maybeHeaders;
+  const diffShape = createShapeDiff(
+    baseZodObject._def.shape(),
+    zodObject._def.shape()
+  );
+  if (!diffShape) {
+    return void 0;
   }
-  if (content) {
-    responseObject.content = createContent(content, ctx, [...path, "content"]);
+  const extendedSchema = createObjectSchemaFromShape(
+    diffShape,
+    diffOpts,
+    state,
+    true
+  );
+  const schemaLength = Object.keys(extendedSchema.schema).length;
+  const effects = flattenEffects([
+    completeComponent.type === "complete" ? completeComponent.effects : [],
+    completeComponent.type === "in-progress" ? [
+      {
+        type: "component",
+        zodType: zodObject,
+        path: [...state.path]
+      }
+    ] : [],
+    extendedSchema.effects
+  ]);
+  if (schemaLength === 0) {
+    return {
+      type: "ref",
+      schema: {
+        $ref: createComponentSchemaRef(
+          completeComponent.ref,
+          (_c = state.documentOptions) == null ? void 0 : _c.componentRefPath
+        )
+      },
+      schemaObject: completeComponent.type === "complete" ? completeComponent.schemaObject : void 0,
+      zodType: zodObject,
+      effects
+    };
+  }
+  if (schemaLength === 1 && extendedSchema.schema.description) {
+    return createDescriptionMetadata(
+      {
+        schema: {
+          $ref: createComponentSchemaRef(
+            completeComponent.ref,
+            (_d = state.documentOptions) == null ? void 0 : _d.componentRefPath
+          )
+        },
+        schemaObject: completeComponent.type === "complete" ? completeComponent.schemaObject : void 0,
+        zodType: zodObject,
+        effects
+      },
+      extendedSchema.schema.description,
+      state
+    );
   }
-  return responseObject;
+  return {
+    type: "schema",
+    schema: {
+      allOf: [
+        {
+          $ref: createComponentSchemaRef(
+            completeComponent.ref,
+            (_e = state.documentOptions) == null ? void 0 : _e.componentRefPath
+          )
+        }
+      ],
+      ...extendedSchema.schema
+    },
+    effects: flattenEffects([
+      completeComponent.type === "complete" ? completeComponent.effects : [],
+      completeComponent.type === "in-progress" ? [
+        {
+          type: "component",
+          zodType: zodObject,
+          path: [...state.path]
+        }
+      ] : [],
+      extendedSchema.effects
+    ])
+  };
 };
-const createResponses = (responses, ctx, path) => {
-  if (!responses) {
+const createDiffOpts = (baseOpts, extendedOpts) => {
+  if (baseOpts.unknownKeys === "strict" || !isZodType(baseOpts.catchAll, "ZodNever")) {
     return void 0;
   }
-  const responsesObject = {};
-  for (const [statusCode, response] of Object.entries(responses)) {
-    if (!response) {
-      continue;
-    }
-    if (isISpecificationExtension(statusCode)) {
-      responsesObject[statusCode] = response;
+  return {
+    catchAll: extendedOpts.catchAll,
+    unknownKeys: extendedOpts.unknownKeys
+  };
+};
+const createShapeDiff = (baseObj, extendedObj) => {
+  const acc = {};
+  for (const [key, val] of Object.entries(extendedObj)) {
+    const baseValue = baseObj[key];
+    if (val === baseValue) {
       continue;
     }
-    if ("$ref" in response) {
-      responsesObject[statusCode] = response;
+    if (baseValue === void 0) {
+      acc[key] = extendedObj[key];
       continue;
     }
-    const responseObject = createResponse(
-      response,
-      ctx,
-      [...path, statusCode]
-    );
-    responsesObject[statusCode] = responseObject;
+    return null;
   }
-  return responsesObject;
+  return acc;
 };
-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 mapAdditionalProperties = ({ unknownKeys, catchAll }, state) => {
+  if (!isZodType(catchAll, "ZodNever")) {
+    return createSchemaObject(catchAll, state, ["additional properties"]);
+  }
+  if (unknownKeys === "strict") {
+    return false;
+  }
+  if (unknownKeys === "passthrough") {
+    return true;
+  }
+  return void 0;
+};
+const createObjectSchemaFromShape = (shape, { unknownKeys, catchAll }, state, omitType) => {
+  const properties = mapProperties(shape, state);
+  const required = mapRequired(properties, shape, state);
+  const additionalProperties = mapAdditionalProperties(
+    { catchAll, unknownKeys },
+    state
   );
-  const maybeRequestParams = createParameters(
-    requestParams,
-    {
-      registry,
-      io: "input"
+  return {
+    type: "schema",
+    schema: {
+      ...!omitType && { type: "object" },
+      ...properties && { properties: properties.properties },
+      ...(required == null ? void 0 : required.required.length) && { required: required.required },
+      ...additionalProperties !== void 0 && {
+        additionalProperties: typeof additionalProperties === "object" ? additionalProperties.schema : additionalProperties
+      }
     },
-    [...path, "requestParams"]
-  );
-  if (maybeRequestParams || maybeManualParameters) {
-    operation.parameters = [
-      ...maybeRequestParams ?? [],
-      ...maybeManualParameters ?? []
-    ];
+    effects: flattenEffects([
+      ...(properties == null ? void 0 : properties.effects) ?? [],
+      typeof additionalProperties === "object" && (additionalProperties == null ? void 0 : additionalProperties.effects),
+      required == null ? void 0 : required.effects
+    ])
+  };
+};
+const mapRequired = (properties, shape, state) => {
+  if (!properties) {
+    return void 0;
   }
-  const maybeRequestBody = createRequestBody(
-    requestBody,
-    {
-      registry,
-      io: "input"
+  const { required, effects } = Object.entries(properties.schemas).reduce(
+    (acc, [key, schemaOrRef]) => {
+      const zodSchema = shape[key];
+      if (!zodSchema) {
+        throw new Error("Property somehow doesn't exist in shape");
+      }
+      const result = zodSchema.safeParse(void 0);
+      if (!result.success) {
+        acc.required.push(key);
+        return acc;
+      }
+      if (result.data !== void 0) {
+        const baseEffect = {
+          zodType: zodSchema,
+          path: [...state.path, `property: ${key}`]
+        };
+        const effect = schemaOrRef.type === "ref" ? {
+          ...baseEffect,
+          type: "component"
+        } : {
+          ...baseEffect,
+          type: "schema",
+          creationType: state.type
+        };
+        acc.effects.push(effect);
+        if (state.type === "output") {
+          acc.required.push(key);
+        }
+      }
+      return acc;
     },
-    [...path, "requestBody"]
+    {
+      required: [],
+      effects: []
+    }
   );
-  if (maybeRequestBody) {
-    operation.requestBody = maybeRequestBody;
+  return { required, effects };
+};
+const mapProperties = (shape, state) => {
+  const shapeEntries = Object.entries(shape);
+  if (!shapeEntries.length) {
+    return void 0;
   }
-  const maybeResponses = createResponses(
-    responses,
-    {
-      registry,
-      io: "output"
+  return shapeEntries.reduce(
+    (acc, [key, zodSchema]) => {
+      if (isOptionalObjectKey(zodSchema)) {
+        return acc;
+      }
+      const schema = createSchemaObject(zodSchema, state, [`property: ${key}`]);
+      acc.schemas[key] = schema;
+      acc.properties[key] = schema.schema;
+      acc.effects.push(schema.effects);
+      return acc;
     },
-    [...path, "responses"]
+    {
+      schemas: {},
+      properties: {},
+      effects: []
+    }
   );
-  if (maybeResponses) {
-    operation.responses = maybeResponses;
+};
+const createPipelineSchema = (zodPipeline, state) => {
+  var _a, _b, _c, _d, _e, _f;
+  if (((_b = (_a = zodPipeline._def.zodOpenApi) == null ? void 0 : _a.openapi) == null ? void 0 : _b.effectType) === "input" || ((_d = (_c = zodPipeline._def.zodOpenApi) == null ? void 0 : _c.openapi) == null ? void 0 : _d.effectType) === "same") {
+    return createSchemaObject(zodPipeline._def.in, state, ["pipeline input"]);
   }
-  const maybeCallbacks = createCallbacks(callbacks, registry, [
-    ...path,
-    "callbacks"
+  if (((_f = (_e = zodPipeline._def.zodOpenApi) == null ? void 0 : _e.openapi) == null ? void 0 : _f.effectType) === "output") {
+    return createSchemaObject(zodPipeline._def.out, state, ["pipeline output"]);
+  }
+  if (state.type === "input") {
+    const schema2 = createSchemaObject(zodPipeline._def.in, state, [
+      "pipeline input"
+    ]);
+    return {
+      ...schema2,
+      effects: flattenEffects([
+        [
+          {
+            type: "schema",
+            creationType: "input",
+            path: [...state.path],
+            zodType: zodPipeline
+          }
+        ],
+        schema2.effects
+      ])
+    };
+  }
+  const schema = createSchemaObject(zodPipeline._def.out, state, [
+    "pipeline output"
+  ]);
+  return {
+    ...schema,
+    effects: flattenEffects([
+      [
+        {
+          type: "schema",
+          creationType: "output",
+          path: [...state.path],
+          zodType: zodPipeline
+        }
+      ],
+      schema.effects
+    ])
+  };
+};
+const createPreprocessSchema = (zodPreprocess, state) => createSchemaObject(zodPreprocess._def.schema, state, ["preprocess schema"]);
+const createReadonlySchema = (zodReadonly, state) => (
+  // Readonly doesn't change OpenAPI schema
+  createSchemaObject(zodReadonly._def.innerType, state, ["readonly"])
+);
+const createRecordSchema = (zodRecord, state) => {
+  const additionalProperties = createSchemaObject(
+    zodRecord.valueSchema,
+    state,
+    ["record value"]
+  );
+  const keySchema = createSchemaObject(zodRecord.keySchema, state, [
+    "record key"
   ]);
-  if (maybeCallbacks) {
-    operation.callbacks = maybeCallbacks;
+  const maybeComponent = state.components.schemas.get(zodRecord.keySchema);
+  const isComplete = maybeComponent && maybeComponent.type === "complete";
+  const maybeSchema = isComplete && maybeComponent.schemaObject;
+  const maybeEffects = isComplete && maybeComponent.effects || void 0;
+  const renderedKeySchema = maybeSchema || keySchema.schema;
+  if ("enum" in renderedKeySchema && renderedKeySchema.enum) {
+    return {
+      type: "schema",
+      schema: {
+        type: "object",
+        properties: renderedKeySchema.enum.reduce((acc, key) => {
+          acc[key] = additionalProperties.schema;
+          return acc;
+        }, {}),
+        additionalProperties: false
+      },
+      effects: flattenEffects([
+        keySchema.effects,
+        additionalProperties.effects,
+        maybeEffects
+      ])
+    };
   }
-  return operation;
+  if (satisfiesVersion(state.components.openapi, "3.1.0") && "type" in renderedKeySchema && renderedKeySchema.type === "string" && Object.keys(renderedKeySchema).length > 1) {
+    return {
+      type: "schema",
+      schema: {
+        type: "object",
+        propertyNames: keySchema.schema,
+        additionalProperties: additionalProperties.schema
+      },
+      effects: flattenEffects([
+        keySchema.effects,
+        additionalProperties.effects
+      ])
+    };
+  }
+  return {
+    type: "schema",
+    schema: {
+      type: "object",
+      additionalProperties: additionalProperties.schema
+    },
+    effects: additionalProperties.effects
+  };
 };
-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,
+const createRefineSchema = (zodRefine, state) => createSchemaObject(zodRefine._def.schema, state, ["refine schema"]);
+const createSetSchema = (zodSet, state) => {
+  var _a, _b;
+  const schema = zodSet._def.valueType;
+  const minItems = (_a = zodSet._def.minSize) == null ? void 0 : _a.value;
+  const maxItems = (_b = zodSet._def.maxSize) == null ? void 0 : _b.value;
+  const itemSchema = createSchemaObject(schema, state, ["set items"]);
+  return {
+    type: "schema",
+    schema: {
+      type: "array",
+      items: itemSchema.schema,
+      uniqueItems: true,
+      ...minItems !== void 0 && { minItems },
+      ...maxItems !== void 0 && { maxItems }
+    },
+    effects: itemSchema.effects
+  };
+};
+const createStringSchema = (zodString, state) => {
+  var _a, _b, _c, _d, _e, _f, _g, _h;
+  const zodStringChecks = getZodStringChecks(zodString);
+  const format = mapStringFormat(zodStringChecks);
+  const patterns = mapPatterns(zodStringChecks);
+  const minLength = ((_b = (_a = zodStringChecks.length) == null ? void 0 : _a[0]) == null ? void 0 : _b.value) ?? ((_d = (_c = zodStringChecks.min) == null ? void 0 : _c[0]) == null ? void 0 : _d.value);
+  const maxLength = ((_f = (_e = zodStringChecks.length) == null ? void 0 : _e[0]) == null ? void 0 : _f.value) ?? ((_h = (_g = zodStringChecks.max) == null ? void 0 : _g[0]) == null ? void 0 : _h.value);
+  const contentEncoding = satisfiesVersion(state.components.openapi, "3.1.0") ? mapContentEncoding(zodStringChecks) : void 0;
+  if (patterns.length <= 1) {
+    return {
+      type: "schema",
+      schema: {
+        type: "string",
+        ...format && { format },
+        ...patterns[0] && { pattern: patterns[0] },
+        ...minLength !== void 0 && { minLength },
+        ...maxLength !== void 0 && { maxLength },
+        ...contentEncoding && { contentEncoding }
+      }
+    };
+  }
+  return {
+    type: "schema",
+    schema: {
+      allOf: [
         {
-          registry,
-          io: "input"
+          type: "string",
+          ...format && { format },
+          ...patterns[0] && { pattern: patterns[0] },
+          ...minLength !== void 0 && { minLength },
+          ...maxLength !== void 0 && { maxLength },
+          ...contentEncoding && { contentEncoding }
         },
-        [...path, key]
-      );
-      continue;
+        ...patterns.slice(1).map(
+          (pattern) => ({
+            type: "string",
+            pattern
+          })
+        )
+      ]
     }
-    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;
+  };
+};
+const 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;
+  },
+  {}
+);
+const 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;
+};
+const mapStartsWith = (zodStringChecks) => {
+  var _a, _b;
+  if ((_b = (_a = zodStringChecks.startsWith) == null ? void 0 : _a[0]) == null ? void 0 : _b.value) {
+    return `^${zodStringChecks.startsWith[0].value}`;
   }
-  return pathItemObject;
+  return void 0;
 };
-const createPaths = (paths, registry, path) => {
-  if (!paths) {
-    return void 0;
+const mapEndsWith = (zodStringChecks) => {
+  var _a, _b;
+  if ((_b = (_a = zodStringChecks.endsWith) == null ? void 0 : _a[0]) == null ? void 0 : _b.value) {
+    return `${zodStringChecks.endsWith[0].value}$`;
   }
-  const pathsObject = {};
-  for (const [singlePath, pathItemObject] of Object.entries(paths)) {
-    if (isISpecificationExtension(singlePath)) {
-      pathsObject[singlePath] = pathItemObject;
-      continue;
+  return void 0;
+};
+const mapRegex = (zodStringChecks) => {
+  var _a;
+  return (_a = zodStringChecks.regex) == null ? void 0 : _a.map((regexCheck) => regexCheck.regex.source);
+};
+const mapIncludes = (zodStringChecks) => {
+  var _a;
+  return (_a = zodStringChecks.includes) == null ? void 0 : _a.map((includeCheck) => {
+    if (includeCheck.position === 0) {
+      return `^${includeCheck.value}`;
     }
-    pathsObject[singlePath] = createPathItem(pathItemObject, registry, [
-      ...path,
-      singlePath
-    ]);
+    if (includeCheck.position) {
+      return `^.{${includeCheck.position}}${includeCheck.value}`;
+    }
+    return includeCheck.value;
+  });
+};
+const mapStringFormat = (zodStringChecks) => {
+  var _a, _b, _c, _d;
+  if (zodStringChecks.uuid) {
+    return "uuid";
+  }
+  if (zodStringChecks.datetime) {
+    return "date-time";
+  }
+  if (zodStringChecks.date) {
+    return "date";
+  }
+  if (zodStringChecks.time) {
+    return "time";
+  }
+  if (zodStringChecks.duration) {
+    return "duration";
   }
-  return pathsObject;
+  if (zodStringChecks.email) {
+    return "email";
+  }
+  if (zodStringChecks.url) {
+    return "uri";
+  }
+  if ((_a = zodStringChecks.ip) == null ? void 0 : _a.every((ip) => ip.version === "v4")) {
+    return "ipv4";
+  }
+  if ((_b = zodStringChecks.ip) == null ? void 0 : _b.every((ip) => ip.version === "v6")) {
+    return "ipv6";
+  }
+  if ((_c = zodStringChecks.cidr) == null ? void 0 : _c.every((ip) => ip.version === "v4")) {
+    return "ipv4";
+  }
+  if ((_d = zodStringChecks.cidr) == null ? void 0 : _d.every((ip) => ip.version === "v6")) {
+    return "ipv6";
+  }
+  return void 0;
 };
-const createCallback = (callbackObject, registry, path) => {
-  const seenCallback = registry.callbacks.seen.get(callbackObject);
-  if (seenCallback) {
-    return seenCallback;
+const mapContentEncoding = (zodStringChecks) => {
+  if (zodStringChecks.base64) {
+    return "base64";
   }
-  const { id, ...rest } = callbackObject;
-  const callback = {};
-  for (const [name, pathItem] of Object.entries(rest)) {
-    if (isISpecificationExtension(name)) {
-      callback[name] = pathItem;
-      continue;
+  return void 0;
+};
+const createTupleSchema = (zodTuple, state) => {
+  const items = zodTuple.items;
+  const rest = zodTuple._def.rest;
+  const prefixItems = mapPrefixItems(items, state);
+  if (satisfiesVersion(state.components.openapi, "3.1.0")) {
+    if (!rest) {
+      return {
+        type: "schema",
+        schema: {
+          type: "array",
+          maxItems: items.length,
+          minItems: items.length,
+          ...prefixItems && {
+            prefixItems: prefixItems.schemas.map((item) => item.schema)
+          }
+        },
+        effects: prefixItems == null ? void 0 : prefixItems.effects
+      };
     }
-    callback[name] = createPathItem(
-      pathItem,
-      registry,
-      [...path, name]
-    );
+    const itemSchema = createSchemaObject(rest, state, ["tuple items"]);
+    return {
+      type: "schema",
+      schema: {
+        type: "array",
+        items: itemSchema.schema,
+        ...prefixItems && {
+          prefixItems: prefixItems.schemas.map((item) => item.schema)
+        }
+      },
+      effects: flattenEffects([prefixItems == null ? void 0 : prefixItems.effects, itemSchema.effects])
+    };
   }
-  if (id) {
-    const ref = {
-      $ref: `#/components/callbacks/${id}`
+  if (!rest) {
+    return {
+      type: "schema",
+      schema: {
+        type: "array",
+        maxItems: items.length,
+        minItems: items.length,
+        ...prefixItems && {
+          items: { oneOf: prefixItems.schemas.map((item) => item.schema) }
+        }
+      },
+      effects: prefixItems == null ? void 0 : prefixItems.effects
     };
-    registry.callbacks.ids.set(id, callback);
-    registry.callbacks.seen.set(callbackObject, ref);
-    return ref;
   }
-  registry.callbacks.seen.set(callbackObject, callback);
-  return callback;
+  if (prefixItems) {
+    const restSchema = createSchemaObject(rest, state, ["tuple items"]);
+    return {
+      type: "schema",
+      schema: {
+        type: "array",
+        items: {
+          oneOf: [
+            ...prefixItems.schemas.map((item) => item.schema),
+            restSchema.schema
+          ]
+        }
+      },
+      effects: flattenEffects([restSchema.effects, prefixItems.effects])
+    };
+  }
+  return {
+    type: "schema",
+    schema: {
+      type: "array"
+    }
+  };
 };
-const createCallbacks = (callbacks, registry, path) => {
-  if (!callbacks) {
-    return void 0;
+const mapPrefixItems = (items, state) => {
+  if (items.length) {
+    const schemas = items.map(
+      (item, index) => createSchemaObject(item, state, [`tuple item ${index}`])
+    );
+    return {
+      effects: flattenEffects(schemas.map((s) => s.effects)),
+      schemas
+    };
   }
-  const callbacksObject = {};
-  for (const [name, value] of Object.entries(callbacks)) {
-    if (isISpecificationExtension(name)) {
-      callbacksObject[name] = value;
-      continue;
+  return void 0;
+};
+const createUnionSchema = (zodUnion, state) => {
+  var _a, _b, _c;
+  const schemas = zodUnion.options.reduce((acc, option, index) => {
+    if (!isOptionalObjectKey(option)) {
+      acc.push(createSchemaObject(option, state, [`union option ${index}`]));
     }
-    callbacksObject[name] = createCallback(
-      value,
-      registry,
-      [...path, name]
+    return acc;
+  }, []);
+  if (((_b = (_a = zodUnion._def.zodOpenApi) == null ? void 0 : _a.openapi) == null ? void 0 : _b.unionOneOf) ?? ((_c = state.documentOptions) == null ? void 0 : _c.unionOneOf)) {
+    return {
+      type: "schema",
+      schema: {
+        oneOf: schemas.map((s) => s.schema)
+      },
+      effects: flattenEffects(schemas.map((s) => s.effects))
+    };
+  }
+  return {
+    type: "schema",
+    schema: {
+      anyOf: schemas.map((s) => s.schema)
+    },
+    effects: flattenEffects(schemas.map((s) => s.effects))
+  };
+};
+const createUnknownSchema = (_zodUnknown) => ({
+  type: "schema",
+  schema: {}
+});
+const createSchemaSwitch = (zodSchema, previous, state) => {
+  var _a, _b;
+  if ((_b = (_a = zodSchema._def.zodOpenApi) == null ? void 0 : _a.openapi) == null ? void 0 : _b.type) {
+    return createManualTypeSchema(zodSchema, state);
+  }
+  if (isZodType(zodSchema, "ZodString")) {
+    return createStringSchema(zodSchema, state);
+  }
+  if (isZodType(zodSchema, "ZodNumber")) {
+    return createNumberSchema(zodSchema, state);
+  }
+  if (isZodType(zodSchema, "ZodBoolean")) {
+    return createBooleanSchema();
+  }
+  if (isZodType(zodSchema, "ZodEnum")) {
+    return createEnumSchema(zodSchema);
+  }
+  if (isZodType(zodSchema, "ZodLiteral")) {
+    return createLiteralSchema(zodSchema, state);
+  }
+  if (isZodType(zodSchema, "ZodNativeEnum")) {
+    return createNativeEnumSchema(zodSchema, state);
+  }
+  if (isZodType(zodSchema, "ZodArray")) {
+    return createArraySchema(zodSchema, state);
+  }
+  if (isZodType(zodSchema, "ZodObject")) {
+    return createObjectSchema(zodSchema, previous, state);
+  }
+  if (isZodType(zodSchema, "ZodUnion")) {
+    return createUnionSchema(zodSchema, state);
+  }
+  if (isZodType(zodSchema, "ZodDiscriminatedUnion")) {
+    return createDiscriminatedUnionSchema(zodSchema, state);
+  }
+  if (isZodType(zodSchema, "ZodNull")) {
+    return createNullSchema();
+  }
+  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, previous);
+  }
+  if (isZodType(zodSchema, "ZodRecord")) {
+    return createRecordSchema(zodSchema, state);
+  }
+  if (isZodType(zodSchema, "ZodTuple")) {
+    return createTupleSchema(zodSchema, state);
+  }
+  if (isZodType(zodSchema, "ZodDate")) {
+    return createDateSchema(zodSchema, state);
+  }
+  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, previous);
+  }
+  if (isZodType(zodSchema, "ZodUnknown") || isZodType(zodSchema, "ZodAny")) {
+    return createUnknownSchema();
+  }
+  if (isZodType(zodSchema, "ZodLazy")) {
+    return createLazySchema(zodSchema, state);
+  }
+  if (isZodType(zodSchema, "ZodBranded")) {
+    return createBrandedSchema(zodSchema, state);
+  }
+  if (isZodType(zodSchema, "ZodSet")) {
+    return createSetSchema(zodSchema, state);
+  }
+  if (isZodType(zodSchema, "ZodBigInt")) {
+    return createBigIntSchema();
+  }
+  return createManualTypeSchema(zodSchema, state);
+};
+const createNewSchema = ({
+  zodSchema,
+  previous,
+  state
+}) => {
+  var _a;
+  if (state.visited.has(zodSchema)) {
+    throw new Error(
+      `The schema at ${state.path.join(
+        " > "
+      )} needs to be registered because it's circularly referenced`
     );
   }
-  return callbacksObject;
-};
-const override = (ctx) => {
-  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 = def.options[Number(index)]._zod.propValues[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;
+  state.visited.add(zodSchema);
+  const {
+    effectType,
+    param,
+    header,
+    ref,
+    refType,
+    unionOneOf,
+    ...additionalMetadata
+  } = ((_a = zodSchema._def.zodOpenApi) == null ? void 0 : _a.openapi) ?? {};
+  const schema = createSchemaSwitch(zodSchema, previous, state);
+  const schemaWithMetadata = enhanceWithMetadata(
+    schema,
+    additionalMetadata,
+    state,
+    previous
+  );
+  state.visited.delete(zodSchema);
+  return schemaWithMetadata;
+};
+const createNewRef = ({
+  previous,
+  ref,
+  zodSchema,
+  state
+}) => {
+  var _a;
+  state.components.schemas.set(zodSchema, {
+    type: "in-progress",
+    ref
+  });
+  const newSchema = createNewSchema({
+    zodSchema,
+    previous,
+    state: {
+      ...state,
+      visited: /* @__PURE__ */ new Set()
+    }
+  });
+  state.components.schemas.set(zodSchema, {
+    type: "complete",
+    ref,
+    schemaObject: newSchema.schema,
+    effects: newSchema.effects
+  });
+  return {
+    type: "ref",
+    schema: {
+      $ref: createComponentSchemaRef(
+        ref,
+        (_a = state.documentOptions) == null ? void 0 : _a.componentRefPath
+      )
+    },
+    schemaObject: newSchema.schema,
+    effects: newSchema.effects ? [
+      {
+        type: "component",
+        zodType: zodSchema,
+        path: [...state.path]
       }
-      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;
+    ] : void 0,
+    zodType: zodSchema
+  };
+};
+const createExistingRef = (zodSchema, component, state) => {
+  var _a, _b;
+  if (component && component.type === "complete") {
+    return {
+      type: "ref",
+      schema: {
+        $ref: createComponentSchemaRef(
+          component.ref,
+          (_a = state.documentOptions) == null ? void 0 : _a.componentRefPath
+        )
+      },
+      schemaObject: component.schemaObject,
+      effects: component.effects ? [
+        {
+          type: "component",
+          zodType: zodSchema,
+          path: [...state.path]
         }
-        delete ctx.jsonSchema.unionOneOf;
-      }
-      break;
-    }
-    case "date": {
-      ctx.jsonSchema.type = "string";
-      break;
+      ] : void 0,
+      zodType: zodSchema
+    };
+  }
+  if (component && component.type === "in-progress") {
+    return {
+      type: "ref",
+      schema: {
+        $ref: createComponentSchemaRef(
+          component.ref,
+          (_b = state.documentOptions) == null ? void 0 : _b.componentRefPath
+        )
+      },
+      schemaObject: void 0,
+      effects: [
+        {
+          type: "component",
+          zodType: zodSchema,
+          path: [...state.path]
+        }
+      ],
+      zodType: zodSchema
+    };
+  }
+  return;
+};
+const createSchemaOrRef = (zodSchema, state, onlyRef) => {
+  var _a, _b, _c, _d;
+  const component = state.components.schemas.get(zodSchema);
+  const existingRef = createExistingRef(zodSchema, component, state);
+  if (existingRef) {
+    return existingRef;
+  }
+  const previous = ((_a = zodSchema._def.zodOpenApi) == null ? void 0 : _a[extendZodSymbols.previousSymbol]) ? createSchemaOrRef(
+    zodSchema._def.zodOpenApi[extendZodSymbols.previousSymbol],
+    state,
+    true
+  ) : void 0;
+  const current = ((_b = zodSchema._def.zodOpenApi) == null ? void 0 : _b[extendZodSymbols.currentSymbol]) && zodSchema._def.zodOpenApi[extendZodSymbols.currentSymbol] !== zodSchema ? createSchemaOrRef(
+    zodSchema._def.zodOpenApi[extendZodSymbols.currentSymbol],
+    state,
+    true
+  ) : void 0;
+  const ref = ((_d = (_c = zodSchema._def.zodOpenApi) == null ? void 0 : _c.openapi) == null ? void 0 : _d.ref) ?? (component == null ? void 0 : component.ref);
+  if (ref) {
+    return current ? createNewSchema({ zodSchema, previous: current, state }) : createNewRef({ ref, zodSchema, previous, state });
+  }
+  if (onlyRef) {
+    return previous ?? current;
+  }
+  return createNewSchema({ zodSchema, previous: previous ?? current, state });
+};
+const createSchemaObject = (zodSchema, state, subpath) => {
+  state.path.push(...subpath);
+  const schema = createSchemaOrRef(zodSchema, state);
+  if (!schema) {
+    throw new Error("Schema does not exist");
+  }
+  state.path.pop();
+  return schema;
+};
+const createSchema = (zodSchema, state, subpath) => {
+  const schema = createSchemaObject(zodSchema, state, subpath);
+  if (schema.effects) {
+    verifyEffects(schema.effects, state);
+  }
+  return schema.schema;
+};
+const createMediaTypeSchema = (schemaObject, components, type, subpath, documentOptions) => {
+  if (!schemaObject) {
+    return void 0;
+  }
+  if (!isAnyZodType(schemaObject)) {
+    return schemaObject;
+  }
+  return createSchema(
+    schemaObject,
+    {
+      components,
+      type,
+      path: [],
+      visited: /* @__PURE__ */ new Set(),
+      documentOptions
+    },
+    subpath
+  );
+};
+const createMediaTypeObject = (mediaTypeObject, components, type, subpath, documentOptions) => {
+  if (!mediaTypeObject) {
+    return void 0;
+  }
+  return {
+    ...mediaTypeObject,
+    schema: createMediaTypeSchema(
+      mediaTypeObject.schema,
+      components,
+      type,
+      [...subpath, "schema"],
+      documentOptions
+    )
+  };
+};
+const createContent = (contentObject, components, type, subpath, documentOptions) => Object.entries(contentObject).reduce(
+  (acc, [mediaType, zodOpenApiMediaTypeObject]) => {
+    const mediaTypeObject = createMediaTypeObject(
+      zodOpenApiMediaTypeObject,
+      components,
+      type,
+      [...subpath, mediaType],
+      documentOptions
+    );
+    if (mediaTypeObject) {
+      acc[mediaType] = mediaTypeObject;
     }
-    case "literal": {
-      if (def.values.includes(void 0)) {
-        break;
-      }
-      break;
+    return acc;
+  },
+  {}
+);
+const createComponentParamRef = (ref) => `#/components/parameters/${ref}`;
+const createBaseParameter = (schema, components, subpath, documentOptions) => {
+  var _a, _b, _c, _d;
+  const { ref, ...rest } = ((_b = (_a = schema._def.zodOpenApi) == null ? void 0 : _a.openapi) == null ? void 0 : _b.param) ?? {};
+  const state = {
+    components,
+    type: "input",
+    path: [],
+    visited: /* @__PURE__ */ new Set(),
+    documentOptions
+  };
+  const schemaObject = createSchema(schema, state, [...subpath, "schema"]);
+  const required = !schema.isOptional();
+  const description = ((_d = (_c = schema._def.zodOpenApi) == null ? void 0 : _c.openapi) == null ? void 0 : _d.description) ?? schema._def.description;
+  return {
+    ...description && { description },
+    ...rest,
+    ...schema && { schema: schemaObject },
+    ...required && { required }
+  };
+};
+const createParamOrRef = (zodSchema, components, subpath, type, name, documentOptions) => {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+  const component = components.parameters.get(zodSchema);
+  const paramType = ((_c = (_b = (_a = zodSchema._def.zodOpenApi) == null ? void 0 : _a.openapi) == null ? void 0 : _b.param) == null ? void 0 : _c.in) ?? (component == null ? void 0 : component.in) ?? type;
+  const paramName = ((_f = (_e = (_d = zodSchema._def.zodOpenApi) == null ? void 0 : _d.openapi) == null ? void 0 : _e.param) == null ? void 0 : _f.name) ?? (component == null ? void 0 : 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 !== paramType || component.name !== paramName)) {
+      throw new Error(`parameterRef "${component.ref}" is already registered`);
     }
+    return {
+      $ref: createComponentParamRef(component.ref)
+    };
+  }
+  const baseParamOrRef = createBaseParameter(
+    zodSchema,
+    components,
+    subpath,
+    documentOptions
+  );
+  if ("$ref" in baseParamOrRef) {
+    throw new Error("Unexpected Error: received a reference object");
+  }
+  const ref = ((_i = (_h = (_g = zodSchema == null ? void 0 : zodSchema._def.zodOpenApi) == null ? void 0 : _g.openapi) == null ? void 0 : _h.param) == null ? void 0 : _i.ref) ?? (component == null ? void 0 : 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;
+};
+const createParameters = (type, zodObjectType, components, subpath, documentOptions) => {
+  if (!zodObjectType) {
+    return [];
+  }
+  const zodObject = getZodObject(zodObjectType, "input").shape;
+  return Object.entries(zodObject).map(
+    ([key, zodSchema]) => createParamOrRef(
+      zodSchema,
+      components,
+      [...subpath, key],
+      type,
+      key,
+      documentOptions
+    )
+  );
+};
+const createRequestParams = (requestParams, components, subpath, documentOptions) => {
+  if (!requestParams) {
+    return [];
+  }
+  const pathParams = createParameters(
+    "path",
+    requestParams.path,
+    components,
+    [...subpath, "path"],
+    documentOptions
+  );
+  const queryParams = createParameters(
+    "query",
+    requestParams.query,
+    components,
+    [...subpath, "query"],
+    documentOptions
+  );
+  const cookieParams = createParameters(
+    "cookie",
+    requestParams.cookie,
+    components,
+    [...subpath, "cookie"],
+    documentOptions
+  );
+  const headerParams = createParameters(
+    "header",
+    requestParams.header,
+    components,
+    [...subpath, "header"],
+    documentOptions
+  );
+  return [...pathParams, ...queryParams, ...cookieParams, ...headerParams];
+};
+const createManualParameters = (parameters, components, subpath, documentOptions) => (parameters == null ? void 0 : parameters.map((param, index) => {
+  if (isAnyZodType(param)) {
+    return createParamOrRef(
+      param,
+      components,
+      [...subpath, `param index ${index}`],
+      void 0,
+      void 0,
+      documentOptions
+    );
   }
+  return param;
+})) ?? [];
+const createParametersObject = (parameters, requestParams, components, subpath, documentOptions) => {
+  const manualParameters = createManualParameters(
+    parameters,
+    components,
+    subpath,
+    documentOptions
+  );
+  const createdParams = createRequestParams(
+    requestParams,
+    components,
+    subpath,
+    documentOptions
+  );
+  const combinedParameters = [
+    ...manualParameters,
+    ...createdParams
+  ];
+  return combinedParameters.length ? combinedParameters : void 0;
 };
-const validate = (ctx, opts) => {
-  var _a;
-  if (Object.keys(ctx.jsonSchema).length) {
-    return;
+const getZodObject = (schema, type) => {
+  if (isZodType(schema, "ZodObject")) {
+    return schema;
   }
-  const def = ctx.zodSchema._zod.def;
-  if ((_a = opts.allowEmptySchema) == null ? void 0 : _a[def.type]) {
-    return;
+  if (isZodType(schema, "ZodLazy")) {
+    return getZodObject(schema.schema, type);
   }
-  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;
+  if (isZodType(schema, "ZodEffects")) {
+    return getZodObject(schema.innerType(), type);
+  }
+  if (isZodType(schema, "ZodBranded")) {
+    return getZodObject(schema.unwrap(), type);
+  }
+  if (isZodType(schema, "ZodPipeline")) {
+    if (type === "input") {
+      return getZodObject(schema._def.in, type);
     }
+    return getZodObject(schema._def.out, type);
   }
-  throw new Error(
-    `Zod schema of type \`${def.type}\` cannot be represented in OpenAPI. Please assign it metadata with \`.meta()\``
-  );
+  throw new Error("failed to find ZodObject in schema");
 };
-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
-    });
+const isISpecificationExtension = (key) => key.startsWith("x-");
+const createResponseHeaders = (responseHeaders, components, documentOptions) => {
+  if (!responseHeaders) {
+    return void 0;
   }
-  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;
+  if (isAnyZodType(responseHeaders)) {
+    return Object.entries(responseHeaders.shape).reduce((acc, [key, zodSchema]) => {
+      acc[key] = createHeaderOrRef(zodSchema, components, documentOptions);
+      return acc;
+    }, {});
   }
-  return componentsToRename;
+  return responseHeaders;
 };
-const isDependencyPure = (componentDependencies, stringifiedComponents, registry, key, visited = /* @__PURE__ */ new Set()) => {
-  if (visited.has(key)) {
-    return true;
+const createHeaderOrRef = (schema, components, documentOptions) => {
+  var _a, _b, _c;
+  const component = components.headers.get(schema);
+  if (component && component.type === "complete") {
+    return {
+      $ref: createComponentHeaderRef(component.ref)
+    };
   }
-  const dependencies = componentDependencies.get(key);
-  if (dependencies.pure !== void 0) {
-    return dependencies.pure;
+  const baseHeader = createBaseHeader(schema, components, documentOptions);
+  if ("$ref" in baseHeader) {
+    throw new Error("Unexpected Error: received a reference object");
   }
-  const stringified = stringifiedComponents.get(key);
-  const component = registry.schemas.ids.get(key);
-  if (component && stringified !== JSON.stringify(component)) {
-    dependencies.pure = false;
-    return false;
+  const ref = ((_c = (_b = (_a = schema._def.zodOpenApi) == null ? void 0 : _a.openapi) == null ? void 0 : _b.header) == null ? void 0 : _c.ref) ?? (component == null ? void 0 : component.ref);
+  if (ref) {
+    components.headers.set(schema, {
+      type: "complete",
+      headerObject: baseHeader,
+      ref
+    });
+    return {
+      $ref: createComponentHeaderRef(ref)
+    };
   }
-  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 }
+  return baseHeader;
+};
+const createBaseHeader = (schema, components, documentOptions) => {
+  var _a, _b;
+  const { ref, ...rest } = ((_b = (_a = schema._def.zodOpenApi) == null ? void 0 : _a.openapi) == null ? void 0 : _b.header) ?? {};
+  const state = {
+    components,
+    type: "output",
+    path: [],
+    visited: /* @__PURE__ */ new Set(),
+    documentOptions
   };
-  Object.assign(schemas, registrySchemas);
-  const jsonSchemas = createSchemas(schemas, {
-    registry: ctx.registry,
-    io: ctx.io,
-    opts: ctx.opts
-  });
+  const schemaObject = createSchema(schema, state, ["header"]);
+  const optionalResult = schema.safeParse(void 0);
+  const required = !optionalResult.success || optionalResult !== void 0;
   return {
-    schema: jsonSchemas.schemas.zodOpenApiCreateSchema,
-    components: jsonSchemas.components
+    ...rest,
+    ...schema && { schema: schemaObject },
+    ...required && { required }
   };
 };
-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 createComponentHeaderRef = (ref) => `#/components/headers/${ref}`;
+const createResponse = (responseObject, components, subpath, documentOptions) => {
+  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,
+    documentOptions
   );
-  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);
+  const response = {
+    ...rest,
+    ...maybeHeaders && { headers: maybeHeaders },
+    ...content && {
+      content: createContent(
+        content,
+        components,
+        "output",
+        [...subpath, "content"],
+        documentOptions
+      )
     }
+  };
+  const responseRef = ref ?? (component == null ? void 0 : component.ref);
+  if (responseRef) {
+    components.responses.set(responseObject, {
+      responseObject: response,
+      ref: responseRef,
+      type: "complete"
+    });
+    return {
+      $ref: createComponentResponseRef(responseRef)
+    };
   }
-  for (const [key, value] of globalsInSchemas) {
-    dynamicComponent.set(key, value);
+  return response;
+};
+const createResponses = (responsesObject, components, subpath, documentOptions) => Object.entries(responsesObject).reduce(
+  (acc, [statusCode, responseObject]) => {
+    if (isISpecificationExtension(statusCode)) {
+      acc[statusCode] = responseObject;
+      return acc;
+    }
+    acc[statusCode] = createResponse(
+      responseObject,
+      components,
+      [...subpath, statusCode],
+      documentOptions
+    );
+    return acc;
+  },
+  {}
+);
+const createRequestBody = (requestBodyObject, components, subpath, documentOptions) => {
+  if (!requestBodyObject) {
+    return void 0;
   }
-  for (const [key, value] of dynamicComponent) {
-    const component = patchedJsonSchema.schemas[key];
-    patchedJsonSchema.schemas[key] = {
-      $ref: `#/components/schemas/${value}`
+  const component = components.requestBodies.get(requestBodyObject);
+  if (component && component.type === "complete") {
+    return {
+      $ref: createComponentRequestBodyRef(component.ref)
     };
-    components[value] = component;
   }
-  const renamedComponents = renameComponents(components, outputIds, {
-    registry
-  });
-  if (renamedComponents.size === 0) {
-    delete patchedJsonSchema.schemas.__shared;
+  const { ref: reqBodyRef, ...cleanRequestBody } = requestBodyObject;
+  const ref = reqBodyRef ?? (component == null ? void 0 : component.ref);
+  const requestBody = {
+    ...cleanRequestBody,
+    content: createContent(
+      cleanRequestBody.content,
+      components,
+      "input",
+      [...subpath, "content"],
+      documentOptions
+    )
+  };
+  if (ref) {
+    components.requestBodies.set(requestBodyObject, {
+      type: "complete",
+      ref,
+      requestBodyObject: requestBody
+    });
     return {
-      schemas: patchedJsonSchema.schemas,
-      components
+      $ref: createComponentRequestBodyRef(ref)
     };
   }
-  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}"`;
-    }
+  return requestBody;
+};
+const createOperation = (operationObject, components, subpath, documentOptions) => {
+  const { parameters, requestParams, requestBody, responses, ...rest } = operationObject;
+  const maybeParameters = createParametersObject(
+    parameters,
+    requestParams,
+    components,
+    [...subpath, "parameters"],
+    documentOptions
+  );
+  const maybeRequestBody = createRequestBody(
+    operationObject.requestBody,
+    components,
+    [...subpath, "request body"],
+    documentOptions
+  );
+  const maybeResponses = createResponses(
+    operationObject.responses,
+    components,
+    [...subpath, "responses"],
+    documentOptions
+  );
+  const maybeCallbacks = createCallbacks(
+    operationObject.callbacks,
+    components,
+    [...subpath, "callbacks"],
+    documentOptions
   );
-  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
+    ...rest,
+    ...maybeParameters && { parameters: maybeParameters },
+    ...maybeRequestBody && { requestBody: maybeRequestBody },
+    ...maybeResponses && { responses: maybeResponses },
+    ...maybeCallbacks && { callbacks: maybeCallbacks }
   };
 };
-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;
+const createPathItem = (pathObject, components, path, documentOptions) => 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],
+        documentOptions
+      );
+      return acc;
+    }
+    acc[key] = value;
+    return acc;
+  },
+  {}
+);
+const createPaths = (pathsObject, components, documentOptions) => {
+  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],
+        documentOptions
+      );
+      return acc;
     },
-    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()
+    {}
+  );
+};
+const createCallback = (callbackObject, components, subpath, documentOptions) => {
+  const { ref, ...callbacks } = callbackObject;
+  const callback = Object.entries(
+    callbacks
+  ).reduce((acc, [callbackName, pathItemObject]) => {
+    if (isISpecificationExtension(callbackName)) {
+      acc[callbackName] = pathItemObject;
+      return acc;
     }
+    acc[callbackName] = createPathItem(
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+      pathItemObject,
+      components,
+      [...subpath, callbackName],
+      documentOptions
+    );
+    return acc;
+  }, {});
+  if (ref) {
+    components.callbacks.set(callbackObject, {
+      type: "complete",
+      ref,
+      callbackObject: callback
+    });
+    return {
+      $ref: createComponentCallbackRef(ref)
+    };
+  }
+  return callback;
+};
+const createCallbacks = (callbacksObject, components, subpath, documentOptions) => {
+  if (!callbacksObject) {
+    return void 0;
+  }
+  return Object.entries(callbacksObject).reduce(
+    (acc, [callbackName, callbackObject]) => {
+      if (isISpecificationExtension(callbackName)) {
+        acc[callbackName] = callbackObject;
+        return acc;
+      }
+      acc[callbackName] = createCallback(
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+        callbackObject,
+        components,
+        [...subpath, callbackName],
+        documentOptions
+      );
+      return acc;
+    },
+    {}
+  );
+};
+const 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(),
+    callbacks: /* @__PURE__ */ new Map(),
+    openapi
   };
-  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 (!componentsObject) {
+    return defaultComponents;
+  }
+  getSchemas(componentsObject.schemas, defaultComponents);
+  getParameters(componentsObject.parameters, defaultComponents);
+  getRequestBodies(componentsObject.requestBodies, defaultComponents);
+  getHeaders(componentsObject.headers, defaultComponents);
+  getResponses(componentsObject.responses, defaultComponents);
+  getCallbacks(componentsObject.callbacks, defaultComponents);
+  return defaultComponents;
+};
+const getSchemas = (schemas, components) => {
   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`);
-    }
+  Object.entries(schemas).forEach(([key, schema]) => {
+    var _a, _b;
     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, {
+      if (components.schemas.has(schema)) {
+        throw new Error(
+          `Schema ${JSON.stringify(schema._def)} is already registered`
+        );
+      }
+      const ref = ((_b = (_a = schema._def.zodOpenApi) == null ? void 0 : _a.openapi) == null ? void 0 : _b.ref) ?? key;
+      components.schemas.set(schema, {
         type: "manual",
-        schemaObject: outputSchemaObject,
-        id: identifier
+        ref
       });
-      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) => {
+const getParameters = (parameters, components) => {
   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`);
-    }
+  Object.entries(parameters).forEach(([key, schema]) => {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i;
     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;
+      if (components.parameters.has(schema)) {
+        throw new Error(
+          `Parameter ${JSON.stringify(schema._def)} is already registered`
+        );
+      }
+      const ref = ((_c = (_b = (_a = schema._def.zodOpenApi) == null ? void 0 : _a.openapi) == null ? void 0 : _b.param) == null ? void 0 : _c.ref) ?? key;
+      const name = (_f = (_e = (_d = schema._def.zodOpenApi) == null ? void 0 : _d.openapi) == null ? void 0 : _e.param) == null ? void 0 : _f.name;
+      const location = (_i = (_h = (_g = schema._def.zodOpenApi) == null ? void 0 : _g.openapi) == null ? void 0 : _h.param) == null ? void 0 : _i.in;
+      if (!name || !location) {
+        throw new Error("`name` or `in` missing in .openapi()");
+      }
+      components.parameters.set(schema, {
+        type: "manual",
+        ref,
+        in: location,
+        name
+      });
     }
-    registry.parameters.ids.set(key, schema);
-  }
+  });
 };
-const registerHeaders = (headers, registry) => {
-  if (!headers) {
+const getHeaders = (responseHeaders, components) => {
+  if (!responseHeaders) {
     return;
   }
-  for (const [key, schema] of Object.entries(headers)) {
-    if (registry.headers.ids.has(key)) {
-      throw new Error(`Header "${key}" is already registered`);
-    }
+  Object.entries(responseHeaders).forEach(([key, schema]) => {
+    var _a, _b, _c;
     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;
+      if (components.parameters.has(schema)) {
+        throw new Error(
+          `Header ${JSON.stringify(schema._def)} is already registered`
+        );
+      }
+      const ref = ((_c = (_b = (_a = schema._def.zodOpenApi) == null ? void 0 : _a.openapi) == null ? void 0 : _b.param) == null ? void 0 : _c.ref) ?? key;
+      components.headers.set(schema, {
+        type: "manual",
+        ref
+      });
     }
-    registry.headers.ids.set(key, schema);
-  }
+  });
 };
-const registerResponses = (responses, registry) => {
+const getResponses = (responses, components) => {
   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`);
+  Object.entries(responses).forEach(([key, responseObject]) => {
+    if (components.responses.has(responseObject)) {
+      throw new Error(
+        `Header ${JSON.stringify(responseObject)} is already registered`
+      );
     }
-    const responseObject = createResponse(
-      schema,
-      {
-        registry,
-        io: "output"
-      },
-      path
-    );
-    registry.responses.ids.set(key, responseObject);
-    registry.responses.seen.set(schema, responseObject);
-  }
+    const ref = (responseObject == null ? void 0 : responseObject.ref) ?? key;
+    components.responses.set(responseObject, {
+      type: "manual",
+      ref
+    });
+  });
 };
-const registerRequestBodies = (requestBodies, registry) => {
+const getRequestBodies = (requestBodies, components) => {
   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
+  Object.entries(requestBodies).forEach(([key, requestBody]) => {
+    if (components.requestBodies.has(requestBody)) {
+      throw new Error(
+        `Header ${JSON.stringify(requestBody)} is already registered`
       );
-      registry.requestBodies.ids.set(key, requestBodyObject);
-      continue;
     }
-    registry.requestBodies.ids.set(key, schema);
-  }
+    const ref = (requestBody == null ? void 0 : requestBody.ref) ?? key;
+    components.requestBodies.set(requestBody, {
+      type: "manual",
+      ref
+    });
+  });
 };
-const registerCallbacks = (callbacks, registry) => {
+const getCallbacks = (callbacks, components) => {
   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`);
+  Object.entries(callbacks).forEach(([key, callback]) => {
+    if (components.callbacks.has(callback)) {
+      throw new Error(
+        `Callback ${JSON.stringify(callback)} 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 ref = (callback == null ? void 0 : callback.ref) ?? key;
+    components.callbacks.set(callback, {
+      type: "manual",
+      ref
+    });
+  });
 };
-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 createComponentSchemaRef = (schemaRef, componentPath) => `${componentPath ?? "#/components/schemas/"}${schemaRef}`;
+const createComponentResponseRef = (responseRef) => `#/components/responses/${responseRef}`;
+const createComponentRequestBodyRef = (requestBodyRef) => `#/components/requestBodies/${requestBodyRef}`;
+const createComponentCallbackRef = (callbackRef) => `#/components/callbacks/${callbackRef}`;
+const createComponents = (componentsObject, components, documentOptions) => {
+  const combinedSchemas = createSchemaComponents(
+    componentsObject,
+    components,
+    documentOptions
+  );
+  const combinedParameters = createParamComponents(
+    componentsObject,
+    components,
+    documentOptions
+  );
+  const combinedHeaders = createHeaderComponents(
+    componentsObject,
+    components,
+    documentOptions
+  );
+  const combinedResponses = createResponseComponents(
+    components,
+    documentOptions
+  );
+  const combinedRequestBodies = createRequestBodiesComponents(
+    components,
+    documentOptions
+  );
+  const combinedCallbacks = createCallbackComponents(
+    components,
+    documentOptions
+  );
+  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 },
+    ...combinedCallbacks && { callbacks: combinedCallbacks }
+  };
+  return Object.keys(finalComponents).length ? finalComponents : void 0;
+};
+const createSchemaComponents = (componentsObject, components, documentOptions) => {
+  Array.from(components.schemas).forEach(([schema, { type }], index) => {
+    var _a, _b;
+    if (type === "manual") {
+      const state = {
+        components,
+        type: ((_b = (_a = schema._def.zodOpenApi) == null ? void 0 : _a.openapi) == null ? void 0 : _b.refType) ?? "output",
+        path: [],
+        visited: /* @__PURE__ */ new Set(),
+        documentOptions
+      };
+      createSchema(schema, state, [`component schema index ${index}`]);
     }
-    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 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;
 };
-const createIOSchemas = (ctx) => {
-  const { schemas, components } = createSchemas(
-    Object.fromEntries(ctx.registry.schemas[ctx.io].schemas),
-    ctx
+const createParamComponents = (componentsObject, components, documentOptions) => {
+  Array.from(components.parameters).forEach(([schema, component], index) => {
+    if (component.type === "manual") {
+      createParamOrRef(
+        schema,
+        components,
+        [`component parameter index ${index}`],
+        component.in,
+        component.ref,
+        documentOptions
+      );
+    }
+  });
+  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;
+    },
+    {}
   );
-  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 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;
 };
-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 createHeaderComponents = (componentsObject, components, documentOptions) => {
+  Array.from(components.headers).forEach(([schema, component]) => {
+    if (component.type === "manual") {
+      createHeaderOrRef(schema, components, documentOptions);
     }
-  }
+  });
+  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;
 };
-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;
+const createResponseComponents = (components, documentOptions) => {
+  Array.from(components.responses).forEach(([schema, component], index) => {
+    if (component.type === "manual") {
+      createResponse(
+        schema,
+        components,
+        [`component response index ${index}`],
+        documentOptions
+      );
+    }
+  });
+  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;
+};
+const createRequestBodiesComponents = (components, documentOptions) => {
+  Array.from(components.requestBodies).forEach(([schema, component], index) => {
+    if (component.type === "manual") {
+      createRequestBody(
+        schema,
+        components,
+        [`component request body ${index}`],
+        documentOptions
+      );
+    }
+  });
+  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;
+};
+const createCallbackComponents = (components, documentOptions) => {
+  Array.from(components.callbacks).forEach(([schema, component], index) => {
+    if (component.type === "manual") {
+      createCallback(
+        schema,
+        components,
+        [`component callback ${index}`],
+        documentOptions
+      );
+    }
+  });
+  const finalComponents = Array.from(components.callbacks).reduce((acc, [_zodType, component]) => {
+    if (component.type === "complete") {
+      if (acc[component.ref]) {
+        throw new Error(`Callback "${component.ref}" is already registered`);
+      }
+      acc[component.ref] = component.callbackObject;
+    }
+    return acc;
+  }, {});
+  return Object.keys(finalComponents).length ? finalComponents : void 0;
 };
 exports.createComponents = createComponents;
-exports.createMediaTypeObject = createMediaTypeObject;
-exports.createParameter = createParameter;
+exports.createMediaTypeSchema = createMediaTypeSchema;
+exports.createParamOrRef = createParamOrRef;
 exports.createPaths = createPaths;
-exports.createRegistry = createRegistry;
 exports.createSchema = createSchema;
-exports.unwrapZodObject = unwrapZodObject;
+exports.createSchemaComponents = createSchemaComponents;
+exports.getDefaultComponents = getDefaultComponents;
+exports.getZodObject = getZodObject;