zod-openapi 4.2.3 → 5.0.0-beta.0

package/dist/components.chunk.cjs

@@ -1,2448 +1,1078 @@
 "use strict";
-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"
-];
-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;
+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);
       }
-      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
-    };
-  }
-  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 unwrapZodObject(def.out, io, path);
     }
-    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"
+  throw new Error(
+    `Failed to unwrap ZodObject from type: ${zodType._zod.def.type} at ${path.join(" > ")}`
   );
-  return keys.map((key) => enumValues[key]);
 };
-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)
-    };
+const isRequired = (zodType, io) => {
+  if (io === "input") {
+    return zodType._zod.optin === 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
-    ])
-  };
+  return zodType._zod.optout === void 0;
 };
-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}`;
+const createParameter = (parameter, location, ctx, path) => {
+  var _a, _b;
+  const seenParameter = ctx.registry.parameters.seen.get(parameter);
+  if (seenParameter) {
+    return seenParameter;
+  }
+  const meta = v4.globalRegistry.get(parameter);
+  const name = (location == null ? void 0 : location.name) ?? ((_a = meta == null ? void 0 : meta.param) == null ? void 0 : _a.name);
+  const inLocation = (location == null ? void 0 : location.in) ?? ((_b = meta == null ? void 0 : meta.param) == null ? void 0 : _b.in);
+  if (!name || !inLocation) {
     throw new Error(
-      `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'.`
+      `Parameter at ${path.join(" > ")} is missing \`.meta({ param: { name, in } })\` information`
     );
   }
-  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 computedPath = [...path, inLocation, name].join(" > ");
+  const schemaObject = ctx.registry.schemas.setSchema(
+    computedPath,
+    parameter,
+    ctx.io
   );
-};
-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))
+  const { id, ...rest } = (meta == null ? void 0 : meta.param) ?? {};
+  const parameterObject = {
+    ...rest,
+    name,
+    in: inLocation,
+    schema: schemaObject
   };
-};
-const unwrapLiterals = (zodType, state) => {
-  if (isZodType(zodType, "ZodLiteral")) {
-    if (typeof zodType._def.value !== "string") {
-      return void 0;
-    }
-    return [zodType._def.value];
-  }
-  if (isZodType(zodType, "ZodNativeEnum")) {
-    const schema = createNativeEnumSchema(zodType, state);
-    if (schema.type === "schema" && schema.schema.type === "string") {
-      return schema.schema.enum;
-    }
-  }
-  if (isZodType(zodType, "ZodEnum")) {
-    return zodType._def.values;
+  if (isRequired(parameter, ctx.io)) {
+    parameterObject.required = true;
   }
-  if (isZodType(zodType, "ZodBranded")) {
-    return unwrapLiterals(zodType._def.type, state);
+  if (!parameterObject.description && (meta == null ? void 0 : meta.description)) {
+    parameterObject.description = meta.description;
   }
-  if (isZodType(zodType, "ZodReadonly")) {
-    return unwrapLiterals(zodType._def.innerType, state);
-  }
-  if (isZodType(zodType, "ZodCatch")) {
-    return unwrapLiterals(zodType._def.innerType, state);
+  if (id) {
+    const ref = {
+      $ref: `#/components/parameters/${id}`
+    };
+    ctx.registry.parameters.seen.set(parameter, ref);
+    ctx.registry.parameters.ids.set(id, parameterObject);
+    return ref;
   }
-  return void 0;
+  ctx.registry.parameters.seen.set(parameter, parameterObject);
+  return parameterObject;
 };
-const mapDiscriminator = (schemas, zodObjects, discriminator, state) => {
-  var _a;
-  if (typeof discriminator !== "string") {
+const createManualParameters = (parameters, ctx, path) => {
+  if (!parameters) {
     return void 0;
   }
-  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 parameterObjects = [];
+  for (const parameter of parameters) {
+    if (isAnyZodType(parameter)) {
+      const seenParameter = ctx.registry.parameters.seen.get(parameter);
+      if (seenParameter) {
+        parameterObjects.push(seenParameter);
+        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;
+      const paramObject = createParameter(parameter, void 0, ctx, [
+        ...path,
+        "parameters"
+      ]);
+      parameterObjects.push(paramObject);
+      continue;
     }
+    parameterObjects.push(parameter);
   }
-  return {
-    propertyName: discriminator,
-    mapping
-  };
-};
-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 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
-      }
-    };
-  }
-  return {
-    type: "schema",
-    schema: {
-      type: typeof zodLiteral.value,
-      enum: [zodLiteral.value]
-    }
-  };
+  return parameterObjects;
 };
-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'.`
-    );
+const createParameters = (requestParams, ctx, path) => {
+  if (!requestParams) {
+    return void 0;
   }
-  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
-      };
+  const parameterObjects = [];
+  for (const [location, schema] of Object.entries(requestParams ?? {})) {
+    if (!schema) {
+      continue;
     }
-    if (schemaObject.schema.anyOf) {
-      const { anyOf, ...schema3 } = schemaObject.schema;
-      return {
-        type: "schema",
-        schema: {
-          anyOf: mapNullOf(anyOf, state.components.openapi),
-          ...schema3
+    const zodObject = unwrapZodObject(schema, ctx.io, path);
+    for (const [name, zodSchema] of Object.entries(zodObject._zod.def.shape)) {
+      const seenParameter = ctx.registry.parameters.seen.get(zodSchema);
+      if (seenParameter) {
+        parameterObjects.push(seenParameter);
+        continue;
+      }
+      const paramObject = createParameter(
+        zodSchema,
+        {
+          in: location,
+          name
         },
-        effects: schemaObject.effects
-      };
+        ctx,
+        [...path, location, name]
+      );
+      parameterObjects.push(paramObject);
     }
-    const { type: type2, ...schema2 } = schemaObject.schema;
-    return {
-      type: "schema",
-      schema: {
-        type: mapNullType(type2),
-        ...schema2
-      },
-      effects: schemaObject.effects
-    };
   }
-  if (schemaObject.type === "ref") {
+  return parameterObjects;
+};
+const createMediaTypeObject = (mediaTypeObject, ctx, path) => {
+  const computedPath = path.join(" > ");
+  if (isAnyZodType(mediaTypeObject.schema)) {
+    const schemaObject = ctx.registry.schemas.setSchema(
+      computedPath,
+      mediaTypeObject.schema,
+      ctx.io
+    );
     return {
-      type: "schema",
-      schema: {
-        allOf: [schemaObject.schema],
-        nullable: true
-      },
-      effects: schemaObject.effects
+      ...mediaTypeObject,
+      schema: schemaObject
     };
   }
-  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
-  };
+  return mediaTypeObject;
 };
-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 createContent = (content, ctx, path) => {
+  const contentObject = {};
+  for (const [mediaType, mediaTypeObject] of Object.entries(content)) {
+    if (mediaTypeObject) {
+      contentObject[mediaType] = createMediaTypeObject(mediaTypeObject, ctx, [
+        ...path,
+        mediaType
+      ]);
     }
-  };
-};
-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 } };
-  }
-  if (satisfiesVersion(openapi, "3.1.0")) {
-    return { exclusiveMaximum: maximum };
   }
-  return { maximum, exclusiveMaximum: true };
+  return contentObject;
 };
-const mapMinimum = (zodNumberCheck, openapi) => {
-  if (!zodNumberCheck.min) {
+const createRequestBody = (requestBody, ctx, path) => {
+  if (!requestBody) {
     return void 0;
   }
-  const minimum = zodNumberCheck.min.value;
-  if (zodNumberCheck.min.inclusive) {
-    return { ...minimum !== void 0 && { minimum } };
+  const seenRequestBody = ctx.registry.requestBodies.seen.get(requestBody);
+  if (seenRequestBody) {
+    return seenRequestBody;
   }
-  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, "ZodLiteral") && zodSchema._def.value === void 0;
-const createObjectSchema = (zodObject, previous, state) => {
-  const extendedSchema = createExtendedSchema(
-    zodObject,
-    previous == null ? void 0 : previous.zodType,
-    state
+  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 (extendedSchema) {
-    return extendedSchema;
+  if (id) {
+    const ref = {
+      $ref: `#/components/headers/${id}`
+    };
+    ctx.registry.headers.ids.set(id, headerObject);
+    ctx.registry.headers.seen.set(header, ref);
+    return ref;
   }
-  return createObjectSchemaFromShape(
-    zodObject.shape,
-    {
-      unknownKeys: zodObject._def.unknownKeys,
-      catchAll: zodObject._def.catchall
-    },
-    state
-  );
+  ctx.registry.headers.seen.set(header, headerObject);
+  return headerObject;
 };
-const createExtendedSchema = (zodObject, baseZodObject, state) => {
-  var _a, _b, _c, _d, _e;
-  if (!baseZodObject) {
-    return void 0;
-  }
-  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"]);
-  }
-  const completeComponent = state.components.schemas.get(baseZodObject);
-  if (!completeComponent) {
+const createHeaders = (headers, ctx, path) => {
+  if (!headers) {
     return void 0;
   }
-  const diffOpts = createDiffOpts(
-    {
-      unknownKeys: baseZodObject._def.unknownKeys,
-      catchAll: baseZodObject._def.catchall
-    },
-    {
-      unknownKeys: zodObject._def.unknownKeys,
-      catchAll: zodObject._def.catchall
+  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;
     }
-  );
-  if (!diffOpts) {
-    return void 0;
+    return headersObject;
   }
-  const diffShape = createShapeDiff(
-    baseZodObject._def.shape(),
-    zodObject._def.shape()
-  );
-  if (!diffShape) {
-    return void 0;
+  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 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
-    };
+  const { content, headers, id, ...rest } = response;
+  const responseObject = rest;
+  if (id) {
+    ctx.registry.responses.ids.set(id, responseObject);
   }
-  if (schemaLength === 1 && extendedSchema.schema.description) {
-    return createDescriptionMetadata(
-      {
-        type: "ref",
-        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
-    );
+  ctx.registry.responses.seen.set(response, responseObject);
+  const maybeHeaders = createHeaders(headers, ctx, [...path, "headers"]);
+  if (maybeHeaders) {
+    responseObject.headers = maybeHeaders;
   }
-  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
-    ])
-  };
+  if (content) {
+    responseObject.content = createContent(content, ctx, [...path, "content"]);
+  }
+  return responseObject;
 };
-const createDiffOpts = (baseOpts, extendedOpts) => {
-  if (baseOpts.unknownKeys === "strict" || !isZodType(baseOpts.catchAll, "ZodNever")) {
+const createResponses = (responses, ctx, path) => {
+  if (!responses) {
     return void 0;
   }
-  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) {
+  const responsesObject = {};
+  for (const [statusCode, response] of Object.entries(responses)) {
+    if (!response) {
       continue;
     }
-    if (baseValue === void 0) {
-      acc[key] = extendedObj[key];
+    if (isISpecificationExtension(statusCode)) {
+      responsesObject[statusCode] = response;
       continue;
     }
-    return null;
-  }
-  return acc;
-};
-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;
+    if ("$ref" in response) {
+      responsesObject[statusCode] = response;
+      continue;
+    }
+    const responseObject = createResponse(
+      response,
+      ctx,
+      [...path, statusCode]
+    );
+    responsesObject[statusCode] = responseObject;
   }
-  return void 0;
+  return responsesObject;
 };
-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 createOperation = (operationObject, registry, path) => {
+  const {
+    parameters,
+    requestParams,
+    requestBody,
+    responses,
+    callbacks,
+    ...rest
+  } = operationObject;
+  const operation = rest;
+  const maybeManualParameters = createManualParameters(
+    parameters,
+    {
+      registry,
+      io: "input"
+    },
+    [...path, "parameters"]
   );
-  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
-      }
+  const maybeRequestParams = createParameters(
+    requestParams,
+    {
+      registry,
+      io: "input"
     },
-    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;
+    [...path, "requestParams"]
+  );
+  if (maybeRequestParams || maybeManualParameters) {
+    operation.parameters = [
+      ...maybeRequestParams ?? [],
+      ...maybeManualParameters ?? []
+    ];
   }
-  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;
-    },
+  const maybeRequestBody = createRequestBody(
+    requestBody,
     {
-      required: [],
-      effects: []
-    }
+      registry,
+      io: "input"
+    },
+    [...path, "requestBody"]
   );
-  return { required, effects };
-};
-const mapProperties = (shape, state) => {
-  const shapeEntries = Object.entries(shape);
-  if (!shapeEntries.length) {
-    return void 0;
+  if (maybeRequestBody) {
+    operation.requestBody = maybeRequestBody;
   }
-  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;
-    },
+  const maybeResponses = createResponses(
+    responses,
     {
-      schemas: {},
-      properties: {},
-      effects: []
-    }
+      registry,
+      io: "output"
+    },
+    [...path, "responses"]
   );
-};
-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"]);
-  }
-  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 (maybeResponses) {
+    operation.responses = maybeResponses;
   }
-  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"
+  const maybeCallbacks = createCallbacks(callbacks, registry, [
+    ...path,
+    "callbacks"
   ]);
-  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
-      ])
-    };
-  }
-  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 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: [
-        {
-          type: "string",
-          ...format && { format },
-          ...patterns[0] && { pattern: patterns[0] },
-          ...minLength !== void 0 && { minLength },
-          ...maxLength !== void 0 && { maxLength },
-          ...contentEncoding && { contentEncoding }
-        },
-        ...patterns.slice(1).map(
-          (pattern) => ({
-            type: "string",
-            pattern
-          })
-        )
-      ]
-    }
-  };
-};
-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 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}$`;
+  if (maybeCallbacks) {
+    operation.callbacks = maybeCallbacks;
   }
-  return void 0;
+  return operation;
 };
-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}`;
-    }
-    if (includeCheck.position) {
-      return `^.{${includeCheck.position}}${includeCheck.value}`;
+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;
     }
-    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";
-  }
-  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 mapContentEncoding = (zodStringChecks) => {
-  if (zodStringChecks.base64) {
-    return "base64";
-  }
-  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)
-          }
+    if (key === "parameters") {
+      pathItemObject[key] = createManualParameters(
+        value,
+        {
+          registry,
+          io: "input"
         },
-        effects: prefixItems == null ? void 0 : prefixItems.effects
-      };
+        [...path, key]
+      );
+      continue;
     }
-    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])
-    };
+    pathItemObject[key] = value;
   }
-  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
+  if (id) {
+    const ref = {
+      $ref: `#/components/pathItems/${id}`
     };
+    registry.pathItems.ids.set(id, pathItemObject);
+    registry.pathItems.seen.set(pathItem, ref);
+    return ref;
   }
-  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"
-    }
-  };
+  return pathItemObject;
 };
-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 createPaths = (paths, registry, path) => {
+  if (!paths) {
+    return void 0;
   }
-  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}`]));
+  const pathsObject = {};
+  for (const [singlePath, pathItemObject] of Object.entries(paths)) {
+    if (isISpecificationExtension(singlePath)) {
+      pathsObject[singlePath] = pathItemObject;
+      continue;
     }
-    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();
+    pathsObject[singlePath] = createPathItem(pathItemObject, registry, [
+      ...path,
+      singlePath
+    ]);
   }
-  return createManualTypeSchema(zodSchema, state);
+  return pathsObject;
 };
-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`
-    );
+const createCallback = (callbackObject, registry, path) => {
+  const seenCallback = registry.callbacks.seen.get(callbackObject);
+  if (seenCallback) {
+    return seenCallback;
   }
-  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()
+  const { id, ...rest } = callbackObject;
+  const callback = {};
+  for (const [name, pathItem] of Object.entries(rest)) {
+    if (isISpecificationExtension(name)) {
+      callback[name] = pathItem;
+      continue;
     }
-  });
-  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]
-      }
-    ] : 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]
-        }
-      ] : void 0,
-      zodType: zodSchema
-    };
+    callback[name] = createPathItem(
+      pathItem,
+      registry,
+      [...path, name]
+    );
   }
-  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
+  if (id) {
+    const ref = {
+      $ref: `#/components/callbacks/${id}`
     };
+    registry.callbacks.ids.set(id, callback);
+    registry.callbacks.seen.set(callbackObject, ref);
+    return ref;
   }
-  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
-  );
+  registry.callbacks.seen.set(callbackObject, callback);
+  return callback;
 };
-const createMediaTypeObject = (mediaTypeObject, components, type, subpath, documentOptions) => {
-  if (!mediaTypeObject) {
+const createCallbacks = (callbacks, registry, path) => {
+  if (!callbacks) {
     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;
-    }
-    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`);
+  const callbacksObject = {};
+  for (const [name, value] of Object.entries(callbacks)) {
+    if (isISpecificationExtension(name)) {
+      callbacksObject[name] = value;
+      continue;
     }
-    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
+    callbacksObject[name] = createCallback(
+      value,
+      registry,
+      [...path, name]
     );
   }
-  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;
+  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;
+      }
+      const meta = ctx.zodSchema.meta();
+      if (typeof (meta == null ? void 0 : meta.unionOneOf) === "boolean") {
+        if (meta.unionOneOf) {
+          ctx.jsonSchema.oneOf = ctx.jsonSchema.anyOf;
+          delete ctx.jsonSchema.anyOf;
+        }
+        delete ctx.jsonSchema.unionOneOf;
+      }
+      break;
+    }
+    case "date": {
+      ctx.jsonSchema.type = "string";
+      break;
+    }
+    case "literal": {
+      if (def.values.includes(void 0)) {
+        break;
+      }
+      break;
+    }
+  }
 };
-const getZodObject = (schema, type) => {
-  if (isZodType(schema, "ZodObject")) {
-    return schema;
-  }
-  if (isZodType(schema, "ZodLazy")) {
-    return getZodObject(schema.schema, type);
-  }
-  if (isZodType(schema, "ZodEffects")) {
-    return getZodObject(schema.innerType(), type);
+const validate = (ctx, opts) => {
+  var _a;
+  if (Object.keys(ctx.jsonSchema).length) {
+    return;
   }
-  if (isZodType(schema, "ZodBranded")) {
-    return getZodObject(schema.unwrap(), type);
+  const def = ctx.zodSchema._zod.def;
+  if ((_a = opts.allowEmptySchema) == null ? void 0 : _a[def.type]) {
+    return;
   }
-  if (isZodType(schema, "ZodPipeline")) {
-    if (type === "input") {
-      return getZodObject(schema._def.in, 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;
     }
-    return getZodObject(schema._def.out, type);
   }
-  throw new Error("failed to find ZodObject in schema");
+  throw new Error(
+    `Zod schema of type \`${def.type}\` cannot be represented in OpenAPI. Please assign it metadata with \`.meta()\``
+  );
 };
-const isISpecificationExtension = (key) => key.startsWith("x-");
-const createResponseHeaders = (responseHeaders, components, documentOptions) => {
-  if (!responseHeaders) {
-    return void 0;
+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
+    });
   }
-  if (isAnyZodType(responseHeaders)) {
-    return Object.entries(responseHeaders.shape).reduce((acc, [key, zodSchema]) => {
-      acc[key] = createHeaderOrRef(zodSchema, components, documentOptions);
-      return acc;
-    }, {});
+  for (const [key] of stringifiedComponents) {
+    const registeredComponent = ctx.registry.schemas.ids.get(key);
+    if (!registeredComponent) {
+      continue;
+    }
+    if (isDependencyPure(
+      componentDependencies,
+      stringifiedComponents,
+      ctx.registry,
+      key
+    )) {
+      continue;
+    }
+    const newName = outputIds.get(key) ?? `${key}Output`;
+    componentsToRename.set(key, newName);
+    components[newName] = components[key];
+    delete components[key];
+    continue;
   }
-  return responseHeaders;
+  return componentsToRename;
 };
-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 isDependencyPure = (componentDependencies, stringifiedComponents, registry, key, visited = /* @__PURE__ */ new Set()) => {
+  if (visited.has(key)) {
+    return true;
   }
-  const baseHeader = createBaseHeader(schema, components, documentOptions);
-  if ("$ref" in baseHeader) {
-    throw new Error("Unexpected Error: received a reference object");
+  const dependencies = componentDependencies.get(key);
+  if (dependencies.pure !== void 0) {
+    return dependencies.pure;
   }
-  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)
-    };
+  const stringified = stringifiedComponents.get(key);
+  const component = registry.schemas.ids.get(key);
+  if (component && stringified !== JSON.stringify(component)) {
+    dependencies.pure = false;
+    return false;
   }
-  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
+  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 }
   };
-  const schemaObject = createSchema(schema, state, ["header"]);
-  const optionalResult = schema.safeParse(void 0);
-  const required = !optionalResult.success || optionalResult !== void 0;
+  Object.assign(schemas, registrySchemas);
+  const jsonSchemas = createSchemas(schemas, {
+    registry: ctx.registry,
+    io: ctx.io,
+    opts: ctx.opts
+  });
   return {
-    ...rest,
-    ...schema && { schema: schemaObject },
-    ...required && { required }
+    schema: jsonSchemas.schemas.zodOpenApiCreateSchema,
+    components: jsonSchemas.components
   };
 };
-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 response = {
-    ...rest,
-    ...maybeHeaders && { headers: maybeHeaders },
-    ...content && {
-      content: createContent(
-        content,
-        components,
-        "output",
-        [...subpath, "content"],
-        documentOptions
-      )
+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;
     }
-  };
-  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)
-    };
+    componentsToReplace.set(`__shared#/$defs/${key}`, key);
   }
-  return response;
-};
-const createResponses = (responsesObject, components, subpath, documentOptions) => Object.entries(responsesObject).reduce(
-  (acc, [statusCode, responseObject]) => {
-    if (isISpecificationExtension(statusCode)) {
-      acc[statusCode] = responseObject;
-      return acc;
+  for (const value of Object.values(jsonSchema.schemas)) {
+    delete value.$schema;
+    delete value.id;
+  }
+  const dynamicComponent = /* @__PURE__ */ new Map();
+  const patched = JSON.stringify(jsonSchema).replace(
+    /"#\/components\/schemas\/([^"]+)"/g,
+    (_, match) => {
+      const replacement = componentsToReplace.get(match);
+      if (replacement) {
+        return `"#/components/schemas/${replacement}"`;
+      }
+      const component = registry.schemas.ids.get(match);
+      if (component) {
+        return `"#/components/schemas/${match}`;
+      }
+      const globalInSchema = globalsInSchemas.get(match);
+      if (globalInSchema) {
+        componentsToReplace.set(match, globalInSchema);
+        dynamicComponent.set(match, globalInSchema);
+        return `"#/components/schemas/${globalInSchema}"`;
+      }
+      const manualSchema = registry.schemas.manual.get(match);
+      if (manualSchema) {
+        componentsToReplace.set(match, manualSchema.key);
+        dynamicComponent.set(match, manualSchema.key);
+        manualSchema.io[io].used = true;
+        return `"#/components/schemas/${manualSchema.key}"`;
+      }
+      const componentName = `__schema${registry.schemas.dynamicSchemaCount++}`;
+      componentsToReplace.set(match, componentName);
+      dynamicComponent.set(match, componentName);
+      return `"#/components/schemas/${componentName}"`;
+    }
+  );
+  const patchedJsonSchema = JSON.parse(patched);
+  const components = ((_d = patchedJsonSchema.schemas.__shared) == null ? void 0 : _d.$defs) ?? {};
+  (_e = patchedJsonSchema.schemas).__shared ?? (_e.__shared = { $defs: components });
+  for (const [key, value] of registry.schemas.manual) {
+    if (value.io[io].used) {
+      dynamicComponent.set(key, value.key);
     }
-    acc[statusCode] = createResponse(
-      responseObject,
-      components,
-      [...subpath, statusCode],
-      documentOptions
-    );
-    return acc;
-  },
-  {}
-);
-const createRequestBody = (requestBodyObject, components, subpath, documentOptions) => {
-  if (!requestBodyObject) {
-    return void 0;
   }
-  const component = components.requestBodies.get(requestBodyObject);
-  if (component && component.type === "complete") {
-    return {
-      $ref: createComponentRequestBodyRef(component.ref)
+  for (const [key, value] of globalsInSchemas) {
+    dynamicComponent.set(key, value);
+  }
+  for (const [key, value] of dynamicComponent) {
+    const component = patchedJsonSchema.schemas[key];
+    patchedJsonSchema.schemas[key] = {
+      $ref: `#/components/schemas/${value}`
     };
+    components[value] = component;
   }
-  const ref = requestBodyObject.ref ?? (component == null ? void 0 : component.ref);
-  const requestBody = {
-    ...requestBodyObject,
-    content: createContent(
-      requestBodyObject.content,
-      components,
-      "input",
-      [...subpath, "content"],
-      documentOptions
-    )
-  };
-  if (ref) {
-    components.requestBodies.set(requestBodyObject, {
-      type: "complete",
-      ref,
-      requestBodyObject: requestBody
-    });
+  const renamedComponents = renameComponents(components, outputIds, {
+    registry
+  });
+  if (renamedComponents.size === 0) {
+    delete patchedJsonSchema.schemas.__shared;
     return {
-      $ref: createComponentRequestBodyRef(ref)
+      schemas: patchedJsonSchema.schemas,
+      components
     };
   }
-  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 renamedStringified = JSON.stringify(patchedJsonSchema).replace(
+    /"#\/components\/schemas\/([^"]+)"/g,
+    (_, match) => {
+      const newName = renamedComponents.get(match);
+      if (newName) {
+        return `"#/components/schemas/${newName}"`;
+      }
+      return `"#/components/schemas/${match}"`;
+    }
   );
+  const renamedJsonSchema = JSON.parse(renamedStringified);
+  const renamedJsonSchemaComponents = ((_f = renamedJsonSchema.schemas.__shared) == null ? void 0 : _f.$defs) ?? {};
+  delete renamedJsonSchema.schemas.__shared;
   return {
-    ...rest,
-    ...maybeParameters && { parameters: maybeParameters },
-    ...maybeRequestBody && { requestBody: maybeRequestBody },
-    ...maybeResponses && { responses: maybeResponses },
-    ...maybeCallbacks && { callbacks: maybeCallbacks }
+    schemas: renamedJsonSchema.schemas,
+    components: renamedJsonSchemaComponents
   };
 };
-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;
+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;
       }
-      acc[path] = createPathItem(
-        pathItemObject,
-        components,
-        [path],
-        documentOptions
-      );
-      return acc;
     },
-    {}
-  );
-};
-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;
+    headers: {
+      ids: /* @__PURE__ */ new Map(),
+      seen: /* @__PURE__ */ new WeakMap()
     },
-    {}
-  );
-};
-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
+    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()
+    }
   };
-  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) => {
+  registerSchemas(components == null ? void 0 : components.schemas, registry);
+  registerParameters(components == null ? void 0 : components.parameters, registry);
+  registerHeaders(components == null ? void 0 : components.headers, registry);
+  registerResponses(components == null ? void 0 : components.responses, registry);
+  registerPathItems(components == null ? void 0 : components.pathItems, registry);
+  registerRequestBodies(components == null ? void 0 : components.requestBodies, registry);
+  registerCallbacks(components == null ? void 0 : components.callbacks, registry);
+  return registry;
+};
+const registerSchemas = (schemas, registry) => {
   if (!schemas) {
     return;
   }
-  Object.entries(schemas).forEach(([key, schema]) => {
-    var _a, _b;
+  for (const [key, schema] of Object.entries(schemas)) {
+    if (registry.schemas.ids.has(key)) {
+      throw new Error(`Schema "${key}" is already registered`);
+    }
     if (isAnyZodType(schema)) {
-      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, {
+      const inputSchemaObject = {};
+      const outputSchemaObject = {};
+      const identifier = `components > schemas > ${key}`;
+      registry.schemas.input.schemas.set(identifier, {
+        zodType: schema,
+        schemaObject: inputSchemaObject
+      });
+      registry.schemas.input.seen.set(schema, {
+        type: "manual",
+        schemaObject: inputSchemaObject,
+        id: identifier
+      });
+      registry.schemas.output.schemas.set(identifier, {
+        zodType: schema,
+        schemaObject: outputSchemaObject
+      });
+      registry.schemas.output.seen.set(schema, {
         type: "manual",
-        ref
+        schemaObject: outputSchemaObject,
+        id: identifier
       });
+      registry.schemas.manual.set(identifier, {
+        key,
+        io: {
+          input: {
+            schemaObject: inputSchemaObject
+          },
+          output: {
+            schemaObject: outputSchemaObject
+          }
+        },
+        zodType: schema
+      });
+      continue;
     }
-  });
+    registry.schemas.ids.set(key, schema);
+  }
 };
-const getParameters = (parameters, components) => {
+const registerParameters = (parameters, registry) => {
   if (!parameters) {
     return;
   }
-  Object.entries(parameters).forEach(([key, schema]) => {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+  for (const [key, schema] of Object.entries(parameters)) {
+    if (registry.parameters.ids.has(key)) {
+      throw new Error(`Parameter "${key}" is already registered`);
+    }
     if (isAnyZodType(schema)) {
-      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
-      });
+      const path = ["components", "parameters", key];
+      const paramObject = createParameter(
+        schema,
+        void 0,
+        {
+          registry,
+          io: "input"
+        },
+        path
+      );
+      registry.parameters.ids.set(key, paramObject);
+      registry.parameters.seen.set(schema, paramObject);
+      continue;
     }
-  });
+    registry.parameters.ids.set(key, schema);
+  }
 };
-const getHeaders = (responseHeaders, components) => {
-  if (!responseHeaders) {
+const registerHeaders = (headers, registry) => {
+  if (!headers) {
     return;
   }
-  Object.entries(responseHeaders).forEach(([key, schema]) => {
-    var _a, _b, _c;
+  for (const [key, schema] of Object.entries(headers)) {
+    if (registry.headers.ids.has(key)) {
+      throw new Error(`Header "${key}" is already registered`);
+    }
     if (isAnyZodType(schema)) {
-      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
-      });
+      const path = ["components", "headers", key];
+      const headerObject = createHeader(
+        schema,
+        {
+          registry,
+          io: "output"
+        },
+        path
+      );
+      registry.headers.ids.set(key, headerObject);
+      registry.headers.seen.set(schema, headerObject);
+      continue;
     }
-  });
+    registry.headers.ids.set(key, schema);
+  }
 };
-const getResponses = (responses, components) => {
+const registerResponses = (responses, registry) => {
   if (!responses) {
     return;
   }
-  Object.entries(responses).forEach(([key, responseObject]) => {
-    if (components.responses.has(responseObject)) {
-      throw new Error(
-        `Header ${JSON.stringify(responseObject)} is already registered`
-      );
+  for (const [key, schema] of Object.entries(responses)) {
+    const path = ["components", "responses", key];
+    if (registry.responses.ids.has(key)) {
+      throw new Error(`Response "${key}" is already registered`);
     }
-    const ref = (responseObject == null ? void 0 : responseObject.ref) ?? key;
-    components.responses.set(responseObject, {
-      type: "manual",
-      ref
-    });
-  });
+    const responseObject = createResponse(
+      schema,
+      {
+        registry,
+        io: "output"
+      },
+      path
+    );
+    registry.responses.ids.set(key, responseObject);
+    registry.responses.seen.set(schema, responseObject);
+  }
 };
-const getRequestBodies = (requestBodies, components) => {
+const registerRequestBodies = (requestBodies, registry) => {
   if (!requestBodies) {
     return;
   }
-  Object.entries(requestBodies).forEach(([key, requestBody]) => {
-    if (components.requestBodies.has(requestBody)) {
-      throw new Error(
-        `Header ${JSON.stringify(requestBody)} is already registered`
+  for (const [key, schema] of Object.entries(requestBodies)) {
+    if (registry.requestBodies.ids.has(key)) {
+      throw new Error(`RequestBody "${key}" is already registered`);
+    }
+    if (isAnyZodType(schema)) {
+      const path = ["components", "requestBodies", key];
+      const requestBodyObject = createRequestBody(
+        schema,
+        {
+          registry,
+          io: "input"
+        },
+        path
       );
+      registry.requestBodies.ids.set(key, requestBodyObject);
+      continue;
     }
-    const ref = (requestBody == null ? void 0 : requestBody.ref) ?? key;
-    components.requestBodies.set(requestBody, {
-      type: "manual",
-      ref
-    });
-  });
+    registry.requestBodies.ids.set(key, schema);
+  }
 };
-const getCallbacks = (callbacks, components) => {
+const registerCallbacks = (callbacks, registry) => {
   if (!callbacks) {
     return;
   }
-  Object.entries(callbacks).forEach(([key, callback]) => {
-    if (components.callbacks.has(callback)) {
-      throw new Error(
-        `Callback ${JSON.stringify(callback)} is already registered`
-      );
+  for (const [key, schema] of Object.entries(callbacks)) {
+    if (registry.callbacks.ids.has(key)) {
+      throw new Error(`Callback "${key}" is already registered`);
     }
-    const ref = (callback == null ? void 0 : callback.ref) ?? key;
-    components.callbacks.set(callback, {
-      type: "manual",
-      ref
-    });
-  });
-};
-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 path = ["components", "callbacks", key];
+    const callbackObject = createCallback(schema, registry, path);
+    registry.callbacks.ids.set(key, callbackObject);
+    registry.callbacks.seen.set(schema, callbackObject);
+  }
 };
-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 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;
+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`);
     }
-    return acc;
-  }, customComponents);
-  return Object.keys(finalComponents).length ? finalComponents : void 0;
+    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 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;
-    },
-    {}
+const createIOSchemas = (ctx) => {
+  const { schemas, components } = createSchemas(
+    Object.fromEntries(ctx.registry.schemas[ctx.io].schemas),
+    ctx
   );
-  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 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 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;
+  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);
     }
-    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;
+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);
     }
-    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;
+const createComponents = (registry, opts) => {
+  createIOSchemas({ registry, io: "input", opts });
+  createIOSchemas({ registry, io: "output", opts });
+  createManualSchemas(registry);
+  const components = {};
+  if (registry.schemas.ids.size > 0) {
+    components.schemas = Object.fromEntries(registry.schemas.ids);
+  }
+  if (registry.headers.ids.size > 0) {
+    components.headers = Object.fromEntries(registry.headers.ids);
+  }
+  if (registry.requestBodies.ids.size > 0) {
+    components.requestBodies = Object.fromEntries(registry.requestBodies.ids);
+  }
+  if (registry.responses.ids.size > 0) {
+    components.responses = Object.fromEntries(registry.responses.ids);
+  }
+  if (registry.parameters.ids.size > 0) {
+    components.parameters = Object.fromEntries(registry.parameters.ids);
+  }
+  if (registry.callbacks.ids.size > 0) {
+    components.callbacks = Object.fromEntries(registry.callbacks.ids);
+  }
+  if (registry.pathItems.ids.size > 0) {
+    components.pathItems = Object.fromEntries(registry.pathItems.ids);
+  }
+  return components;
 };
 exports.createComponents = createComponents;
-exports.createMediaTypeSchema = createMediaTypeSchema;
-exports.createParamOrRef = createParamOrRef;
+exports.createMediaTypeObject = createMediaTypeObject;
+exports.createParameter = createParameter;
 exports.createPaths = createPaths;
+exports.createRegistry = createRegistry;
 exports.createSchema = createSchema;
-exports.createSchemaComponents = createSchemaComponents;
-exports.getDefaultComponents = getDefaultComponents;
-exports.getZodObject = getZodObject;
+exports.unwrapZodObject = unwrapZodObject;