zod-openapi 2.19.0 → 3.0.0

package/dist/index.mjs

@@ -1,2118 +1,5 @@
+import { getDefaultComponents, createPaths, createComponents } from "./components.chunk.mjs";
 import { extendZodWithOpenApi } from "./extendZod.chunk.mjs";
-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 enhanceWithMetadata = (schema, metadata) => {
-  if (schema.type === "ref") {
-    if (Object.values(metadata).every((val) => val === void 0)) {
-      return schema;
-    }
-    return {
-      type: "schema",
-      schema: {
-        allOf: [schema.schema, metadata]
-      },
-      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 createBooleanSchema = (_zodBoolean) => ({
-  type: "schema",
-  schema: {
-    type: "boolean"
-  }
-});
-const createBrandedSchema = (zodBranded, state) => createSchemaObject(zodBranded._def.type, state, ["brand"]);
-const createCatchSchema = (zodCatch, state) => createSchemaObject(zodCatch._def.innerType, state, ["catch"]);
-const createDateSchema = (_zodDate) => ({
-  type: "schema",
-  schema: {
-    type: "string"
-  }
-});
-const createDefaultSchema = (zodDefault, state) => {
-  const schemaObject = createSchemaObject(zodDefault._def.innerType, state, [
-    "default"
-  ]);
-  return enhanceWithMetadata(schemaObject, {
-    default: zodDefault._def.defaultValue()
-  });
-};
-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 createNativeEnumSchema = (zodEnum, state) => {
-  const enumValues = getValidEnumValues(zodEnum._def.values);
-  const { numbers, strings } = sortStringsAndNumbers(enumValues);
-  if (strings.length && numbers.length) {
-    if (satisfiesVersion(state.components.openapi, "3.1.0"))
-      return {
-        type: "schema",
-        schema: {
-          type: ["string", "number"],
-          enum: [...strings, ...numbers]
-        }
-      };
-    return {
-      type: "schema",
-      schema: {
-        oneOf: [
-          { type: "string", enum: strings },
-          { type: "number", enum: numbers }
-        ]
-      }
-    };
-  }
-  if (strings.length) {
-    return {
-      type: "schema",
-      schema: {
-        type: "string",
-        enum: strings
-      }
-    };
-  }
-  return {
-    type: "schema",
-    schema: {
-      type: "number",
-      enum: numbers
-    }
-  };
-};
-const getValidEnumValues = (enumValues) => {
-  const keys = Object.keys(enumValues).filter(
-    (key) => typeof enumValues[enumValues[key]] !== "number"
-  );
-  return keys.map((key) => enumValues[key]);
-};
-const sortStringsAndNumbers = (values) => ({
-  strings: values.filter((value) => typeof value === "string"),
-  numbers: values.filter((value) => typeof value === "number")
-});
-const createTransformSchema = (zodTransform, state) => {
-  var _a, _b, _c;
-  if (((_a = zodTransform._def.openapi) == null ? void 0 : _a.effectType) === "output") {
-    return {
-      type: "schema",
-      schema: createManualOutputTransformSchema(zodTransform, state)
-    };
-  }
-  if (((_b = zodTransform._def.openapi) == null ? void 0 : _b.effectType) === "input" || ((_c = zodTransform._def.openapi) == null ? void 0 : _c.effectType) === "same") {
-    return createSchemaObject(zodTransform._def.schema, state, [
-      "transform input"
-    ]);
-  }
-  if (state.type === "output") {
-    return {
-      type: "schema",
-      schema: createManualOutputTransformSchema(zodTransform, state)
-    };
-  }
-  const schema = createSchemaObject(zodTransform._def.schema, state, [
-    "transform input"
-  ]);
-  return {
-    ...schema,
-    effects: flattenEffects([
-      [
-        {
-          type: "schema",
-          creationType: "input",
-          zodType: zodTransform,
-          path: [...state.path]
-        }
-      ],
-      schema.effects
-    ])
-  };
-};
-const createManualOutputTransformSchema = (zodTransform, state) => {
-  var _a;
-  if (!((_a = zodTransform._def.openapi) == null ? void 0 : _a.type)) {
-    const zodType = zodTransform.constructor.name;
-    const schemaName = `${zodType} - ${zodTransform._def.effect.type}`;
-    throw new Error(
-      `Failed to determine a type for ${schemaName} at ${state.path.join(
-        " > "
-      )}. Please change the 'effectType' to 'input', wrap it in a ZodPipeline or assign it a manual 'type'.`
-    );
-  }
-  return {
-    type: zodTransform._def.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 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 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 (isZodType(zodType, "ZodBranded")) {
-    return unwrapLiterals(zodType._def.type, state);
-  }
-  if (isZodType(zodType, "ZodReadonly")) {
-    return unwrapLiterals(zodType._def.innerType, state);
-  }
-  if (isZodType(zodType, "ZodCatch")) {
-    return unwrapLiterals(zodType._def.innerType, state);
-  }
-  return void 0;
-};
-const mapDiscriminator = (schemas, zodObjects, discriminator, state) => {
-  if (typeof discriminator !== "string") {
-    return void 0;
-  }
-  const mapping = {};
-  for (const [index, zodObject] of zodObjects.entries()) {
-    const schema = schemas[index];
-    const componentSchemaRef = "$ref" in schema ? schema == null ? void 0 : schema.$ref : void 0;
-    if (!componentSchemaRef) {
-      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;
-    }
-  }
-  return {
-    propertyName: discriminator,
-    mapping
-  };
-};
-const createEnumSchema = (zodEnum) => ({
-  type: "schema",
-  schema: {
-    type: "string",
-    enum: zodEnum._def.values
-  }
-});
-const createIntersectionSchema = (zodIntersection, state) => {
-  const left = createSchemaObject(zodIntersection._def.left, state, [
-    "intersection left"
-  ]);
-  const right = createSchemaObject(zodIntersection._def.right, state, [
-    "intersection right"
-  ]);
-  return {
-    type: "schema",
-    schema: {
-      allOf: [left.schema, right.schema]
-    },
-    effects: flattenEffects([left.effects, right.effects])
-  };
-};
-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]
-    }
-  };
-};
-const createManualTypeSchema = (zodSchema, state) => {
-  var _a;
-  if (!((_a = zodSchema._def.openapi) == null ? void 0 : _a.type)) {
-    const schemaName = zodSchema.constructor.name;
-    throw new Error(
-      `Unknown schema ${schemaName} at ${state.path.join(
-        " > "
-      )}. Please assign it a manual 'type'.`
-    );
-  }
-  return {
-    type: "schema",
-    schema: {
-      type: zodSchema._def.openapi.type
-    }
-  };
-};
-const createNullableSchema = (zodNullable, state) => {
-  const schemaObject = createSchemaObject(zodNullable.unwrap(), state, [
-    "nullable"
-  ]);
-  if (satisfiesVersion(state.components.openapi, "3.1.0")) {
-    if (schemaObject.type === "ref" || schemaObject.schema.allOf) {
-      return {
-        type: "schema",
-        schema: {
-          oneOf: mapNullOf([schemaObject.schema], state.components.openapi)
-        },
-        effects: schemaObject.effects
-      };
-    }
-    if (schemaObject.schema.oneOf) {
-      const { oneOf, ...schema3 } = schemaObject.schema;
-      return {
-        type: "schema",
-        schema: {
-          oneOf: mapNullOf(oneOf, state.components.openapi),
-          ...schema3
-        },
-        effects: schemaObject.effects
-      };
-    }
-    if (schemaObject.schema.anyOf) {
-      const { anyOf, ...schema3 } = schemaObject.schema;
-      return {
-        type: "schema",
-        schema: {
-          anyOf: mapNullOf(anyOf, state.components.openapi),
-          ...schema3
-        },
-        effects: schemaObject.effects
-      };
-    }
-    const { type: type2, ...schema2 } = schemaObject.schema;
-    return {
-      type: "schema",
-      schema: {
-        type: mapNullType(type2),
-        ...schema2
-      },
-      effects: schemaObject.effects
-    };
-  }
-  if (schemaObject.type === "ref") {
-    return {
-      type: "schema",
-      schema: {
-        allOf: [schemaObject.schema],
-        nullable: true
-      },
-      effects: schemaObject.effects
-    };
-  }
-  const { type, ...schema } = schemaObject.schema;
-  return {
-    type: "schema",
-    schema: {
-      ...type && { type },
-      nullable: true,
-      ...schema,
-      // https://github.com/OAI/OpenAPI-Specification/blob/main/proposals/2019-10-31-Clarify-Nullable.md#if-a-schema-specifies-nullable-true-and-enum-1-2-3-does-that-schema-allow-null-values-see-1900
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-      ...schema.enum && { enum: [...schema.enum, null] }
-    },
-    effects: schemaObject.effects
-  };
-};
-const 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);
-  return {
-    type: "schema",
-    schema: {
-      type: mapNumberType(zodNumberChecks),
-      ...minimum && minimum,
-      // Union types are not easy to tame
-      ...maximum && maximum
-    }
-  };
-};
-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 };
-};
-const mapMinimum = (zodNumberCheck, openapi) => {
-  if (!zodNumberCheck.min) {
-    return void 0;
-  }
-  const minimum = zodNumberCheck.min.value;
-  if (zodNumberCheck.min.inclusive) {
-    return { ...minimum !== void 0 && { minimum } };
-  }
-  if (satisfiesVersion(openapi, "3.1.0")) {
-    return { exclusiveMinimum: minimum };
-  }
-  return { minimum, exclusiveMinimum: true };
-};
-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 isOptionalSchema = (zodSchema, state) => {
-  var _a, _b, _c;
-  if (isZodType(zodSchema, "ZodOptional") || isZodType(zodSchema, "ZodNever") || isZodType(zodSchema, "ZodUndefined") || isZodType(zodSchema, "ZodLiteral") && zodSchema._def.value === void 0) {
-    return { optional: true };
-  }
-  if (isZodType(zodSchema, "ZodDefault")) {
-    if (((_a = zodSchema._def.openapi) == null ? void 0 : _a.effectType) === "input") {
-      return { optional: true };
-    }
-    if (((_b = zodSchema._def.openapi) == null ? void 0 : _b.effectType) === "output") {
-      return { optional: false };
-    }
-    return {
-      optional: state.type === "input",
-      effects: [
-        {
-          type: "schema",
-          creationType: state.type,
-          zodType: zodSchema,
-          path: [...state.path]
-        }
-      ]
-    };
-  }
-  if (isZodType(zodSchema, "ZodNullable") || isZodType(zodSchema, "ZodCatch")) {
-    return isOptionalSchema(zodSchema._def.innerType, state);
-  }
-  if (isZodType(zodSchema, "ZodEffects")) {
-    return isOptionalSchema(zodSchema._def.schema, state);
-  }
-  if (isZodType(zodSchema, "ZodUnion") || isZodType(zodSchema, "ZodDiscriminatedUnion")) {
-    const results = zodSchema._def.options.map(
-      (schema) => isOptionalSchema(schema, state)
-    );
-    return results.reduce(
-      (acc, result) => ({
-        optional: acc.optional || result.optional,
-        effects: flattenEffects([acc.effects, result.effects])
-      }),
-      { optional: false }
-    );
-  }
-  if (isZodType(zodSchema, "ZodIntersection")) {
-    const results = [zodSchema._def.left, zodSchema._def.right].map(
-      (schema) => isOptionalSchema(schema, state)
-    );
-    return results.reduce(
-      (acc, result) => ({
-        optional: acc.optional || result.optional,
-        effects: flattenEffects([acc.effects, result.effects])
-      }),
-      { optional: false }
-    );
-  }
-  if (isZodType(zodSchema, "ZodPipeline")) {
-    const type = ((_c = zodSchema._def.openapi) == null ? void 0 : _c.effectType) ?? state.type;
-    if (type === "input") {
-      return isOptionalSchema(zodSchema._def.in, state);
-    }
-    if (type === "output") {
-      return isOptionalSchema(zodSchema._def.out, state);
-    }
-  }
-  if (isZodType(zodSchema, "ZodLazy")) {
-    return isOptionalSchema(zodSchema._def.getter(), state);
-  }
-  return { optional: zodSchema.isOptional() };
-};
-const createObjectSchema = (zodObject, state) => {
-  var _a;
-  const extendedSchema = createExtendedSchema(
-    zodObject,
-    (_a = zodObject._def.extendMetadata) == null ? void 0 : _a.extends,
-    state
-  );
-  if (extendedSchema) {
-    return extendedSchema;
-  }
-  return createObjectSchemaFromShape(
-    zodObject.shape,
-    {
-      unknownKeys: zodObject._def.unknownKeys,
-      catchAll: zodObject._def.catchall
-    },
-    state
-  );
-};
-const createExtendedSchema = (zodObject, baseZodObject, state) => {
-  var _a;
-  if (!baseZodObject) {
-    return void 0;
-  }
-  const component = state.components.schemas.get(baseZodObject);
-  if (component ?? ((_a = baseZodObject._def.openapi) == null ? void 0 : _a.ref)) {
-    createSchemaObject(baseZodObject, state, ["extended schema"]);
-  }
-  const completeComponent = state.components.schemas.get(baseZodObject);
-  if (!completeComponent) {
-    return void 0;
-  }
-  const diffOpts = createDiffOpts(
-    {
-      unknownKeys: baseZodObject._def.unknownKeys,
-      catchAll: baseZodObject._def.catchall
-    },
-    {
-      unknownKeys: zodObject._def.unknownKeys,
-      catchAll: zodObject._def.catchall
-    }
-  );
-  if (!diffOpts) {
-    return void 0;
-  }
-  const diffShape = createShapeDiff(
-    baseZodObject._def.shape(),
-    zodObject._def.shape()
-  );
-  if (!diffShape) {
-    return void 0;
-  }
-  const extendedSchema = createObjectSchemaFromShape(
-    diffShape,
-    diffOpts,
-    state
-  );
-  return {
-    type: "schema",
-    schema: {
-      allOf: [{ $ref: createComponentSchemaRef(completeComponent.ref) }],
-      ...extendedSchema.schema
-    },
-    effects: flattenEffects([
-      completeComponent.type === "complete" ? completeComponent.effects : [],
-      completeComponent.type === "in-progress" ? [
-        {
-          type: "component",
-          zodType: zodObject,
-          path: [...state.path]
-        }
-      ] : [],
-      extendedSchema.effects
-    ])
-  };
-};
-const createDiffOpts = (baseOpts, extendedOpts) => {
-  if (baseOpts.unknownKeys === "strict" || !isZodType(baseOpts.catchAll, "ZodNever")) {
-    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) {
-      continue;
-    }
-    if (baseValue === void 0) {
-      acc[key] = extendedObj[key];
-      continue;
-    }
-    return null;
-  }
-  return acc;
-};
-const createObjectSchemaFromShape = (shape, { unknownKeys, catchAll }, state) => {
-  const properties = mapProperties(shape, state);
-  const required = mapRequired(shape, state);
-  const additionalProperties = !isZodType(catchAll, "ZodNever") ? createSchemaObject(catchAll, state, ["additional properties"]) : void 0;
-  return {
-    type: "schema",
-    schema: {
-      type: "object",
-      ...properties && { properties: properties.properties },
-      ...(required == null ? void 0 : required.required.length) && { required: required.required },
-      ...unknownKeys === "strict" && { additionalProperties: false },
-      ...additionalProperties && {
-        additionalProperties: additionalProperties.schema
-      }
-    },
-    effects: flattenEffects([
-      ...(properties == null ? void 0 : properties.effects) ?? [],
-      additionalProperties == null ? void 0 : additionalProperties.effects,
-      required == null ? void 0 : required.effects
-    ])
-  };
-};
-const mapRequired = (shape, state) => {
-  const { required, effects: allEffects } = Object.entries(shape).reduce(
-    (acc, [key, zodSchema]) => {
-      state.path.push(`property: ${key}`);
-      const { optional, effects } = isOptionalSchema(zodSchema, state);
-      state.path.pop();
-      if (!optional) {
-        acc.required.push(key);
-      }
-      if (effects) {
-        acc.effects.push(effects);
-      }
-      return acc;
-    },
-    {
-      required: [],
-      effects: []
-    }
-  );
-  return { required, effects: flattenEffects(allEffects) };
-};
-const mapProperties = (shape, state) => {
-  const shapeEntries = Object.entries(shape);
-  if (!shapeEntries.length) {
-    return void 0;
-  }
-  return shapeEntries.reduce(
-    (acc, [key, zodSchema]) => {
-      if (isZodType(zodSchema, "ZodNever") || isZodType(zodSchema, "ZodUndefined")) {
-        return acc;
-      }
-      const property = createSchemaObject(zodSchema, state, [
-        `property: ${key}`
-      ]);
-      acc.properties[key] = property.schema;
-      acc.effects.push(property.effects);
-      return acc;
-    },
-    {
-      properties: {},
-      effects: []
-    }
-  );
-};
-const createPipelineSchema = (zodPipeline, state) => {
-  var _a, _b, _c;
-  if (((_a = zodPipeline._def.openapi) == null ? void 0 : _a.effectType) === "input" || ((_b = zodPipeline._def.openapi) == null ? void 0 : _b.effectType) === "same") {
-    return createSchemaObject(zodPipeline._def.in, state, ["pipeline input"]);
-  }
-  if (((_c = zodPipeline._def.openapi) == null ? void 0 : _c.effectType) === "output") {
-    return createSchemaObject(zodPipeline._def.out, state, ["pipeline output"]);
-  }
-  if (state.type === "input") {
-    const schema2 = createSchemaObject(zodPipeline._def.in, state, [
-      "pipeline input"
-    ]);
-    return {
-      ...schema2,
-      effects: flattenEffects([
-        [
-          {
-            type: "schema",
-            creationType: "input",
-            path: [...state.path],
-            zodType: zodPipeline
-          }
-        ],
-        schema2.effects
-      ])
-    };
-  }
-  const schema = createSchemaObject(zodPipeline._def.out, state, [
-    "pipeline output"
-  ]);
-  return {
-    ...schema,
-    effects: flattenEffects([
-      [
-        {
-          type: "schema",
-          creationType: "output",
-          path: [...state.path],
-          zodType: zodPipeline
-        }
-      ],
-      schema.effects
-    ])
-  };
-};
-const createPreprocessSchema = (zodPreprocess, state) => createSchemaObject(zodPreprocess._def.schema, state, ["preprocess schema"]);
-const createReadonlySchema = (zodReadonly, state) => (
-  // Readonly doesn't change OpenAPI schema
-  createSchemaObject(zodReadonly._def.innerType, state, ["readonly"])
-);
-const createRecordSchema = (zodRecord, state) => {
-  const additionalProperties = createSchemaObject(
-    zodRecord.valueSchema,
-    state,
-    ["record value"]
-  );
-  const keySchema = createSchemaObject(zodRecord.keySchema, state, [
-    "record key"
-  ]);
-  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}$`;
-  }
-  return void 0;
-};
-const mapRegex = (zodStringChecks) => {
-  var _a;
-  return (_a = zodStringChecks.regex) == null ? void 0 : _a.map((regexCheck) => regexCheck.regex.source);
-};
-const mapIncludes = (zodStringChecks) => {
-  var _a;
-  return (_a = zodStringChecks.includes) == null ? void 0 : _a.map((includeCheck) => {
-    if (includeCheck.position === 0) {
-      return `^${includeCheck.value}`;
-    }
-    if (includeCheck.position) {
-      return `^.{${includeCheck.position}}${includeCheck.value}`;
-    }
-    return includeCheck.value;
-  });
-};
-const mapStringFormat = (zodStringChecks) => {
-  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";
-  }
-  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)
-          }
-        },
-        effects: prefixItems == null ? void 0 : prefixItems.effects
-      };
-    }
-    const itemSchema = createSchemaObject(rest, state, ["tuple items"]);
-    return {
-      type: "schema",
-      schema: {
-        type: "array",
-        items: itemSchema.schema,
-        ...prefixItems && {
-          prefixItems: prefixItems.schemas.map((item) => item.schema)
-        }
-      },
-      effects: flattenEffects([prefixItems == null ? void 0 : prefixItems.effects, itemSchema.effects])
-    };
-  }
-  if (!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 (prefixItems) {
-    const restSchema = createSchemaObject(rest, state, ["tuple items"]);
-    return {
-      type: "schema",
-      schema: {
-        type: "array",
-        items: {
-          oneOf: [
-            ...prefixItems.schemas.map((item) => item.schema),
-            restSchema.schema
-          ]
-        }
-      },
-      effects: flattenEffects([restSchema.effects, prefixItems.effects])
-    };
-  }
-  return {
-    type: "schema",
-    schema: {
-      type: "array"
-    }
-  };
-};
-const 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
-    };
-  }
-  return void 0;
-};
-const createUnionSchema = (zodUnion, state) => {
-  var _a;
-  const schemas = zodUnion.options.map(
-    (option, index) => createSchemaObject(option, state, [`union option ${index}`])
-  );
-  if ((_a = zodUnion._def.openapi) == null ? void 0 : _a.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, state) => {
-  var _a;
-  if ((_a = zodSchema._def.openapi) == null ? void 0 : _a.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, 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);
-  }
-  if (isZodType(zodSchema, "ZodRecord")) {
-    return createRecordSchema(zodSchema, state);
-  }
-  if (isZodType(zodSchema, "ZodTuple")) {
-    return createTupleSchema(zodSchema, state);
-  }
-  if (isZodType(zodSchema, "ZodDate")) {
-    return createDateSchema();
-  }
-  if (isZodType(zodSchema, "ZodPipeline")) {
-    return createPipelineSchema(zodSchema, state);
-  }
-  if (isZodType(zodSchema, "ZodEffects") && zodSchema._def.effect.type === "transform") {
-    return createTransformSchema(zodSchema, state);
-  }
-  if (isZodType(zodSchema, "ZodEffects") && zodSchema._def.effect.type === "preprocess") {
-    return createPreprocessSchema(zodSchema, state);
-  }
-  if (isZodType(zodSchema, "ZodEffects") && zodSchema._def.effect.type === "refinement") {
-    return createRefineSchema(zodSchema, state);
-  }
-  if (isZodType(zodSchema, "ZodNativeEnum")) {
-    return createNativeEnumSchema(zodSchema, state);
-  }
-  if (isZodType(zodSchema, "ZodIntersection")) {
-    return createIntersectionSchema(zodSchema, state);
-  }
-  if (isZodType(zodSchema, "ZodCatch")) {
-    return createCatchSchema(zodSchema, state);
-  }
-  if (isZodType(zodSchema, "ZodUnknown") || isZodType(zodSchema, "ZodAny")) {
-    return createUnknownSchema();
-  }
-  if (isZodType(zodSchema, "ZodLazy")) {
-    return createLazySchema(zodSchema, state);
-  }
-  if (isZodType(zodSchema, "ZodBranded")) {
-    return createBrandedSchema(zodSchema, state);
-  }
-  if (isZodType(zodSchema, "ZodSet")) {
-    return createSetSchema(zodSchema, state);
-  }
-  return createManualTypeSchema(zodSchema, state);
-};
-const isDescriptionEqual = (schema, zodSchema) => schema.type === "ref" && zodSchema.description === schema.zodType.description;
-const createNewSchema = (zodSchema, state) => {
-  if (state.visited.has(zodSchema)) {
-    throw new Error(
-      `The schema at ${state.path.join(
-        " > "
-      )} needs to be registered because it's circularly referenced`
-    );
-  }
-  state.visited.add(zodSchema);
-  const {
-    effectType,
-    param,
-    header,
-    ref,
-    refType,
-    unionOneOf,
-    ...additionalMetadata
-  } = zodSchema._def.openapi ?? {};
-  const schema = createSchemaSwitch(zodSchema, state);
-  const description = zodSchema.description && !isDescriptionEqual(schema, zodSchema) ? zodSchema.description : void 0;
-  const schemaWithMetadata = enhanceWithMetadata(schema, {
-    ...description && { description },
-    ...additionalMetadata
-  });
-  state.visited.delete(zodSchema);
-  return schemaWithMetadata;
-};
-const createNewRef = (ref, zodSchema, state) => {
-  state.components.schemas.set(zodSchema, {
-    type: "in-progress",
-    ref
-  });
-  const newSchema = createNewSchema(zodSchema, {
-    ...state,
-    visited: /* @__PURE__ */ new Set()
-  });
-  state.components.schemas.set(zodSchema, {
-    type: "complete",
-    ref,
-    schemaObject: newSchema.schema,
-    effects: newSchema.effects
-  });
-  return {
-    type: "ref",
-    schema: { $ref: createComponentSchemaRef(ref) },
-    effects: newSchema.effects ? [
-      {
-        type: "component",
-        zodType: zodSchema,
-        path: [...state.path]
-      }
-    ] : void 0,
-    zodType: zodSchema
-  };
-};
-const createExistingRef = (zodSchema, component, state) => {
-  if (component && component.type === "complete") {
-    return {
-      type: "ref",
-      schema: { $ref: createComponentSchemaRef(component.ref) },
-      effects: component.effects ? [
-        {
-          type: "component",
-          zodType: zodSchema,
-          path: [...state.path]
-        }
-      ] : void 0,
-      zodType: zodSchema
-    };
-  }
-  if (component && component.type === "in-progress") {
-    return {
-      type: "ref",
-      schema: { $ref: createComponentSchemaRef(component.ref) },
-      effects: [
-        {
-          type: "component",
-          zodType: zodSchema,
-          path: [...state.path]
-        }
-      ],
-      zodType: zodSchema
-    };
-  }
-  return;
-};
-const createSchemaOrRef = (zodSchema, state) => {
-  var _a;
-  const component = state.components.schemas.get(zodSchema);
-  const existingRef = createExistingRef(zodSchema, component, state);
-  if (existingRef) {
-    return existingRef;
-  }
-  const ref = ((_a = zodSchema._def.openapi) == null ? void 0 : _a.ref) ?? (component == null ? void 0 : component.ref);
-  if (ref) {
-    return createNewRef(ref, zodSchema, state);
-  }
-  return createNewSchema(zodSchema, state);
-};
-const createSchemaObject = (zodSchema, state, subpath) => {
-  state.path.push(...subpath);
-  const schema = createSchemaOrRef(zodSchema, state);
-  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) => {
-  if (!schemaObject) {
-    return void 0;
-  }
-  if (!isAnyZodType(schemaObject)) {
-    return schemaObject;
-  }
-  return createSchema(
-    schemaObject,
-    {
-      components,
-      type,
-      path: [],
-      visited: /* @__PURE__ */ new Set()
-    },
-    subpath
-  );
-};
-const createMediaTypeObject = (mediaTypeObject, components, type, subpath) => {
-  if (!mediaTypeObject) {
-    return void 0;
-  }
-  return {
-    ...mediaTypeObject,
-    schema: createMediaTypeSchema(mediaTypeObject.schema, components, type, [
-      ...subpath,
-      "schema"
-    ])
-  };
-};
-const createContent = (contentObject, components, type, subpath) => Object.entries(contentObject).reduce(
-  (acc, [mediaType, zodOpenApiMediaTypeObject]) => {
-    const mediaTypeObject = createMediaTypeObject(
-      zodOpenApiMediaTypeObject,
-      components,
-      type,
-      [...subpath, mediaType]
-    );
-    if (mediaTypeObject) {
-      acc[mediaType] = mediaTypeObject;
-    }
-    return acc;
-  },
-  {}
-);
-const createComponentParamRef = (ref) => `#/components/parameters/${ref}`;
-const createBaseParameter = (schema, components, subpath) => {
-  var _a, _b, _c;
-  const { ref, ...rest } = ((_a = schema._def.openapi) == null ? void 0 : _a.param) ?? {};
-  const state = {
-    components,
-    type: "input",
-    path: [],
-    visited: /* @__PURE__ */ new Set()
-  };
-  const schemaObject = createSchema(schema, state, [...subpath, "schema"]);
-  const required = !((_b = isOptionalSchema(schema, state)) == null ? void 0 : _b.optional);
-  const description = ((_c = schema._def.openapi) == null ? void 0 : _c.description) ?? schema._def.description;
-  return {
-    ...description && { description },
-    ...rest,
-    ...schema && { schema: schemaObject },
-    ...required && { required }
-  };
-};
-const createParamOrRef = (zodSchema, components, subpath, type, name) => {
-  var _a, _b, _c, _d, _e, _f, _g, _h, _i;
-  const component = components.parameters.get(zodSchema);
-  const paramType = ((_c = (_b = (_a = zodSchema._def) == 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) == null ? void 0 : _d.openapi) == null ? void 0 : _e.param) == null ? void 0 : _f.name) ?? (component == null ? void 0 : component.name) ?? name;
-  if (!paramType) {
-    throw new Error("Parameter type missing");
-  }
-  if (!paramName) {
-    throw new Error("Parameter name missing");
-  }
-  if (component && component.type === "complete") {
-    if (!("$ref" in component.paramObject) && (component.in !== paramType || component.name !== paramName)) {
-      throw new Error(`parameterRef "${component.ref}" is already registered`);
-    }
-    return {
-      $ref: createComponentParamRef(component.ref)
-    };
-  }
-  const baseParamOrRef = createBaseParameter(zodSchema, components, subpath);
-  if ("$ref" in baseParamOrRef) {
-    throw new Error("Unexpected Error: received a reference object");
-  }
-  const ref = ((_i = (_h = (_g = zodSchema == null ? void 0 : zodSchema._def) == 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) => {
-  if (!zodObjectType) {
-    return [];
-  }
-  const zodObject = getZodObject(zodObjectType).shape;
-  return Object.entries(zodObject).map(
-    ([key, zodSchema]) => createParamOrRef(zodSchema, components, [...subpath, key], type, key)
-  );
-};
-const createRequestParams = (requestParams, components, subpath) => {
-  if (!requestParams) {
-    return [];
-  }
-  const pathParams = createParameters("path", requestParams.path, components, [
-    ...subpath,
-    "path"
-  ]);
-  const queryParams = createParameters(
-    "query",
-    requestParams.query,
-    components,
-    [...subpath, "query"]
-  );
-  const cookieParams = createParameters(
-    "cookie",
-    requestParams.cookie,
-    components,
-    [...subpath, "cookie"]
-  );
-  const headerParams = createParameters(
-    "header",
-    requestParams.header,
-    components,
-    [...subpath, "header"]
-  );
-  return [...pathParams, ...queryParams, ...cookieParams, ...headerParams];
-};
-const createManualParameters = (parameters, components, subpath) => (parameters == null ? void 0 : parameters.map((param, index) => {
-  if (isAnyZodType(param)) {
-    return createParamOrRef(param, components, [
-      ...subpath,
-      `param index ${index}`
-    ]);
-  }
-  return param;
-})) ?? [];
-const createParametersObject = (parameters, requestParams, components, subpath) => {
-  const manualParameters = createManualParameters(
-    parameters,
-    components,
-    subpath
-  );
-  const createdParams = createRequestParams(requestParams, components, subpath);
-  const combinedParameters = [
-    ...manualParameters,
-    ...createdParams
-  ];
-  return combinedParameters.length ? combinedParameters : void 0;
-};
-const getZodObject = (schema, type) => {
-  if (isZodType(schema, "ZodObject")) {
-    return schema;
-  }
-  if (isZodType(schema, "ZodLazy")) {
-    return getZodObject(schema.schema);
-  }
-  if (isZodType(schema, "ZodEffects")) {
-    return getZodObject(schema.innerType());
-  }
-  if (isZodType(schema, "ZodBranded")) {
-    return getZodObject(schema.unwrap());
-  }
-  if (isZodType(schema, "ZodPipeline")) {
-    {
-      return getZodObject(schema._def.in);
-    }
-  }
-  throw new Error("failed to find ZodObject in schema");
-};
-const isISpecificationExtension = (key) => key.startsWith("x-");
-const createResponseHeaders = (responseHeaders, components) => {
-  if (!responseHeaders) {
-    return void 0;
-  }
-  if (isAnyZodType(responseHeaders)) {
-    return Object.entries(responseHeaders.shape).reduce((acc, [key, zodSchema]) => {
-      acc[key] = createHeaderOrRef(zodSchema, components);
-      return acc;
-    }, {});
-  }
-  return responseHeaders;
-};
-const createHeaderOrRef = (schema, components) => {
-  var _a, _b, _c;
-  const component = components.headers.get(schema);
-  if (component && component.type === "complete") {
-    return {
-      $ref: createComponentHeaderRef(component.ref)
-    };
-  }
-  const baseHeader = createBaseHeader(schema, components);
-  if ("$ref" in baseHeader) {
-    throw new Error("Unexpected Error: received a reference object");
-  }
-  const ref = ((_c = (_b = (_a = schema._def) == 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)
-    };
-  }
-  return baseHeader;
-};
-const createBaseHeader = (schema, components) => {
-  var _a, _b;
-  const { ref, ...rest } = ((_a = schema._def.openapi) == null ? void 0 : _a.header) ?? {};
-  const state = {
-    components,
-    type: "output",
-    path: [],
-    visited: /* @__PURE__ */ new Set()
-  };
-  const schemaObject = createSchema(schema, state, ["header"]);
-  const required = !((_b = isOptionalSchema(schema, state)) == null ? void 0 : _b.optional);
-  return {
-    ...rest,
-    ...schema && { schema: schemaObject },
-    ...required && { required }
-  };
-};
-const createComponentHeaderRef = (ref) => `#/components/headers/${ref}`;
-const createResponse = (responseObject, components, subpath) => {
-  if ("$ref" in responseObject) {
-    return responseObject;
-  }
-  const component = components.responses.get(responseObject);
-  if (component && component.type === "complete") {
-    return { $ref: createComponentResponseRef(component.ref) };
-  }
-  const { content, headers, ref, ...rest } = responseObject;
-  const maybeHeaders = createResponseHeaders(headers, components);
-  const response = {
-    ...rest,
-    ...maybeHeaders && { headers: maybeHeaders },
-    ...content && {
-      content: createContent(content, components, "output", [
-        ...subpath,
-        "content"
-      ])
-    }
-  };
-  const responseRef = ref ?? (component == null ? void 0 : component.ref);
-  if (responseRef) {
-    components.responses.set(responseObject, {
-      responseObject: response,
-      ref: responseRef,
-      type: "complete"
-    });
-    return {
-      $ref: createComponentResponseRef(responseRef)
-    };
-  }
-  return response;
-};
-const createResponses = (responsesObject, components, subpath) => Object.entries(responsesObject).reduce(
-  (acc, [statusCode, responseObject]) => {
-    if (isISpecificationExtension(statusCode)) {
-      acc[statusCode] = responseObject;
-      return acc;
-    }
-    acc[statusCode] = createResponse(responseObject, components, [
-      ...subpath,
-      statusCode
-    ]);
-    return acc;
-  },
-  {}
-);
-const createRequestBody = (requestBodyObject, components, subpath) => {
-  if (!requestBodyObject) {
-    return void 0;
-  }
-  const component = components.requestBodies.get(requestBodyObject);
-  if (component && component.type === "complete") {
-    return {
-      $ref: createComponentRequestBodyRef(component.ref)
-    };
-  }
-  const ref = requestBodyObject.ref ?? (component == null ? void 0 : component.ref);
-  const requestBody = {
-    ...requestBodyObject,
-    content: createContent(requestBodyObject.content, components, "input", [
-      ...subpath,
-      "content"
-    ])
-  };
-  if (ref) {
-    components.requestBodies.set(requestBodyObject, {
-      type: "complete",
-      ref,
-      requestBodyObject: requestBody
-    });
-    return {
-      $ref: createComponentRequestBodyRef(ref)
-    };
-  }
-  return requestBody;
-};
-const createOperation = (operationObject, components, subpath) => {
-  const { parameters, requestParams, requestBody, responses, ...rest } = operationObject;
-  const maybeParameters = createParametersObject(
-    parameters,
-    requestParams,
-    components,
-    [...subpath, "parameters"]
-  );
-  const maybeRequestBody = createRequestBody(
-    operationObject.requestBody,
-    components,
-    [...subpath, "request body"]
-  );
-  const maybeResponses = createResponses(
-    operationObject.responses,
-    components,
-    [...subpath, "responses"]
-  );
-  const maybeCallbacks = createCallbacks(
-    operationObject.callbacks,
-    components,
-    [...subpath, "callbacks"]
-  );
-  return {
-    ...rest,
-    ...maybeParameters && { parameters: maybeParameters },
-    ...maybeRequestBody && { requestBody: maybeRequestBody },
-    ...maybeResponses && { responses: maybeResponses },
-    ...maybeCallbacks && { callbacks: maybeCallbacks }
-  };
-};
-const createPathItem = (pathObject, components, path) => Object.entries(pathObject).reduce(
-  (acc, [key, value]) => {
-    if (!value) {
-      return acc;
-    }
-    if (key === "get" || key === "put" || key === "post" || key === "delete" || key === "options" || key === "head" || key === "patch" || key === "trace") {
-      acc[key] = createOperation(
-        value,
-        components,
-        [...path, key]
-      );
-      return acc;
-    }
-    acc[key] = value;
-    return acc;
-  },
-  {}
-);
-const createPaths = (pathsObject, components) => {
-  if (!pathsObject) {
-    return void 0;
-  }
-  return Object.entries(pathsObject).reduce(
-    (acc, [path, pathItemObject]) => {
-      if (isISpecificationExtension(path)) {
-        acc[path] = pathItemObject;
-        return acc;
-      }
-      acc[path] = createPathItem(pathItemObject, components, [path]);
-      return acc;
-    },
-    {}
-  );
-};
-const createCallback = (callbackObject, components, subpath) => {
-  const { ref, ...callbacks } = callbackObject;
-  const callback = Object.entries(
-    callbacks
-  ).reduce((acc, [callbackName, pathItemObject]) => {
-    if (isISpecificationExtension(callbackName)) {
-      acc[callbackName] = pathItemObject;
-      return acc;
-    }
-    acc[callbackName] = createPathItem(pathItemObject, components, [
-      ...subpath,
-      callbackName
-    ]);
-    return acc;
-  }, {});
-  if (ref) {
-    components.callbacks.set(callbackObject, {
-      type: "complete",
-      ref,
-      callbackObject: callback
-    });
-    return {
-      $ref: createComponentCallbackRef(ref)
-    };
-  }
-  return callback;
-};
-const createCallbacks = (callbacksObject, components, subpath) => {
-  if (!callbacksObject) {
-    return void 0;
-  }
-  return Object.entries(callbacksObject).reduce(
-    (acc, [callbackName, callbackObject]) => {
-      if (isISpecificationExtension(callbackName)) {
-        acc[callbackName] = callbackObject;
-        return acc;
-      }
-      acc[callbackName] = createCallback(callbackObject, components, [
-        ...subpath,
-        callbackName
-      ]);
-      return acc;
-    },
-    {}
-  );
-};
-const getDefaultComponents = (componentsObject, openapi = "3.1.0") => {
-  const defaultComponents = {
-    schemas: /* @__PURE__ */ new Map(),
-    parameters: /* @__PURE__ */ new Map(),
-    headers: /* @__PURE__ */ new Map(),
-    requestBodies: /* @__PURE__ */ new Map(),
-    responses: /* @__PURE__ */ new Map(),
-    callbacks: /* @__PURE__ */ new Map(),
-    openapi
-  };
-  if (!componentsObject) {
-    return defaultComponents;
-  }
-  getSchemas(componentsObject.schemas, defaultComponents);
-  getParameters(componentsObject.parameters, defaultComponents);
-  getRequestBodies(componentsObject.requestBodies, defaultComponents);
-  getHeaders(componentsObject.headers, defaultComponents);
-  getResponses(componentsObject.responses, defaultComponents);
-  getCallbacks(componentsObject.callbacks, defaultComponents);
-  return defaultComponents;
-};
-const getSchemas = (schemas, components) => {
-  if (!schemas) {
-    return;
-  }
-  Object.entries(schemas).forEach(([key, schema]) => {
-    var _a;
-    if (isAnyZodType(schema)) {
-      if (components.schemas.has(schema)) {
-        throw new Error(
-          `Schema ${JSON.stringify(schema._def)} is already registered`
-        );
-      }
-      const ref = ((_a = schema._def.openapi) == null ? void 0 : _a.ref) ?? key;
-      components.schemas.set(schema, {
-        type: "manual",
-        ref
-      });
-    }
-  });
-};
-const getParameters = (parameters, components) => {
-  if (!parameters) {
-    return;
-  }
-  Object.entries(parameters).forEach(([key, schema]) => {
-    var _a, _b, _c, _d, _e, _f;
-    if (isAnyZodType(schema)) {
-      if (components.parameters.has(schema)) {
-        throw new Error(
-          `Parameter ${JSON.stringify(schema._def)} is already registered`
-        );
-      }
-      const ref = ((_b = (_a = schema._def.openapi) == null ? void 0 : _a.param) == null ? void 0 : _b.ref) ?? key;
-      const name = (_d = (_c = schema._def.openapi) == null ? void 0 : _c.param) == null ? void 0 : _d.name;
-      const location = (_f = (_e = schema._def.openapi) == null ? void 0 : _e.param) == null ? void 0 : _f.in;
-      if (!name || !location) {
-        throw new Error("`name` or `in` missing in .openapi()");
-      }
-      components.parameters.set(schema, {
-        type: "manual",
-        ref,
-        in: location,
-        name
-      });
-    }
-  });
-};
-const getHeaders = (responseHeaders, components) => {
-  if (!responseHeaders) {
-    return;
-  }
-  Object.entries(responseHeaders).forEach(([key, schema]) => {
-    var _a, _b;
-    if (isAnyZodType(schema)) {
-      if (components.parameters.has(schema)) {
-        throw new Error(
-          `Header ${JSON.stringify(schema._def)} is already registered`
-        );
-      }
-      const ref = ((_b = (_a = schema._def.openapi) == null ? void 0 : _a.param) == null ? void 0 : _b.ref) ?? key;
-      components.headers.set(schema, {
-        type: "manual",
-        ref
-      });
-    }
-  });
-};
-const getResponses = (responses, components) => {
-  if (!responses) {
-    return;
-  }
-  Object.entries(responses).forEach(([key, responseObject]) => {
-    if (components.responses.has(responseObject)) {
-      throw new Error(
-        `Header ${JSON.stringify(responseObject)} is already registered`
-      );
-    }
-    const ref = (responseObject == null ? void 0 : responseObject.ref) ?? key;
-    components.responses.set(responseObject, {
-      type: "manual",
-      ref
-    });
-  });
-};
-const getRequestBodies = (requestBodies, components) => {
-  if (!requestBodies) {
-    return;
-  }
-  Object.entries(requestBodies).forEach(([key, requestBody]) => {
-    if (components.requestBodies.has(requestBody)) {
-      throw new Error(
-        `Header ${JSON.stringify(requestBody)} is already registered`
-      );
-    }
-    const ref = (requestBody == null ? void 0 : requestBody.ref) ?? key;
-    components.requestBodies.set(requestBody, {
-      type: "manual",
-      ref
-    });
-  });
-};
-const getCallbacks = (callbacks, components) => {
-  if (!callbacks) {
-    return;
-  }
-  Object.entries(callbacks).forEach(([key, callback]) => {
-    if (components.callbacks.has(callback)) {
-      throw new Error(
-        `Callback ${JSON.stringify(callback)} is already registered`
-      );
-    }
-    const ref = (callback == null ? void 0 : callback.ref) ?? key;
-    components.callbacks.set(callback, {
-      type: "manual",
-      ref
-    });
-  });
-};
-const createComponentSchemaRef = (schemaRef) => `#/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) => {
-  const combinedSchemas = createSchemaComponents(componentsObject, components);
-  const combinedParameters = createParamComponents(
-    componentsObject,
-    components
-  );
-  const combinedHeaders = createHeaderComponents(componentsObject, components);
-  const combinedResponses = createResponseComponents(components);
-  const combinedRequestBodies = createRequestBodiesComponents(components);
-  const combinedCallbacks = createCallbackComponents(components);
-  const { schemas, parameters, headers, responses, requestBodies, ...rest } = componentsObject;
-  const finalComponents = {
-    ...rest,
-    ...combinedSchemas && { schemas: combinedSchemas },
-    ...combinedParameters && { parameters: combinedParameters },
-    ...combinedRequestBodies && { requestBodies: combinedRequestBodies },
-    ...combinedHeaders && { headers: combinedHeaders },
-    ...combinedResponses && { responses: combinedResponses },
-    ...combinedCallbacks && { callbacks: combinedCallbacks }
-  };
-  return Object.keys(finalComponents).length ? finalComponents : void 0;
-};
-const createSchemaComponents = (componentsObject, components) => {
-  Array.from(components.schemas).forEach(([schema, { type }], index) => {
-    var _a;
-    if (type === "manual") {
-      const state = {
-        components,
-        type: ((_a = schema._def.openapi) == null ? void 0 : _a.refType) ?? "output",
-        path: [],
-        visited: /* @__PURE__ */ new Set()
-      };
-      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;
-    }
-    return acc;
-  }, customComponents);
-  return Object.keys(finalComponents).length ? finalComponents : void 0;
-};
-const createParamComponents = (componentsObject, components) => {
-  Array.from(components.parameters).forEach(([schema, component], index) => {
-    if (component.type === "manual") {
-      createParamOrRef(
-        schema,
-        components,
-        [`component parameter index ${index}`],
-        component.in,
-        component.ref
-      );
-    }
-  });
-  const customComponents = Object.entries(
-    componentsObject.parameters ?? {}
-  ).reduce(
-    (acc, [key, value]) => {
-      if (!isAnyZodType(value)) {
-        if (acc[key]) {
-          throw new Error(`Parameter "${key}" is already registered`);
-        }
-        acc[key] = value;
-      }
-      return acc;
-    },
-    {}
-  );
-  const finalComponents = Array.from(components.parameters).reduce((acc, [_zodType, component]) => {
-    if (component.type === "complete") {
-      if (acc[component.ref]) {
-        throw new Error(`Parameter "${component.ref}" is already registered`);
-      }
-      acc[component.ref] = component.paramObject;
-    }
-    return acc;
-  }, customComponents);
-  return Object.keys(finalComponents).length ? finalComponents : void 0;
-};
-const createHeaderComponents = (componentsObject, components) => {
-  Array.from(components.headers).forEach(([schema, component]) => {
-    if (component.type === "manual") {
-      createHeaderOrRef(schema, components);
-    }
-  });
-  const headers = componentsObject.headers ?? {};
-  const customComponents = Object.entries(headers).reduce((acc, [key, value]) => {
-    if (!isAnyZodType(value)) {
-      if (acc[key]) {
-        throw new Error(`Header Ref "${key}" is already registered`);
-      }
-      acc[key] = value;
-    }
-    return acc;
-  }, {});
-  const finalComponents = Array.from(components.headers).reduce((acc, [_zodType, component]) => {
-    if (component.type === "complete") {
-      if (acc[component.ref]) {
-        throw new Error(`Header "${component.ref}" is already registered`);
-      }
-      acc[component.ref] = component.headerObject;
-    }
-    return acc;
-  }, customComponents);
-  return Object.keys(finalComponents).length ? finalComponents : void 0;
-};
-const createResponseComponents = (components) => {
-  Array.from(components.responses).forEach(([schema, component], index) => {
-    if (component.type === "manual") {
-      createResponse(schema, components, [`component response index ${index}`]);
-    }
-  });
-  const finalComponents = Array.from(components.responses).reduce((acc, [_zodType, component]) => {
-    if (component.type === "complete") {
-      if (acc[component.ref]) {
-        throw new Error(`Response "${component.ref}" is already registered`);
-      }
-      acc[component.ref] = component.responseObject;
-    }
-    return acc;
-  }, {});
-  return Object.keys(finalComponents).length ? finalComponents : void 0;
-};
-const createRequestBodiesComponents = (components) => {
-  Array.from(components.requestBodies).forEach(([schema, component], index) => {
-    if (component.type === "manual") {
-      createRequestBody(schema, components, [
-        `component request body ${index}`
-      ]);
-    }
-  });
-  const finalComponents = Array.from(components.requestBodies).reduce((acc, [_zodType, component]) => {
-    if (component.type === "complete") {
-      if (acc[component.ref]) {
-        throw new Error(`RequestBody "${component.ref}" is already registered`);
-      }
-      acc[component.ref] = component.requestBodyObject;
-    }
-    return acc;
-  }, {});
-  return Object.keys(finalComponents).length ? finalComponents : void 0;
-};
-const createCallbackComponents = (components) => {
-  Array.from(components.callbacks).forEach(([schema, component], index) => {
-    if (component.type === "manual") {
-      createCallback(schema, components, [`component callback ${index}`]);
-    }
-  });
-  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 createDocument = (zodOpenApiObject) => {
   const { paths, webhooks, components = {}, ...rest } = zodOpenApiObject;
   const defaultComponents = getDefaultComponents(
@@ -2135,15 +22,7 @@ const oas30 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePropert
 const oas31 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null
 }, Symbol.toStringTag, { value: "Module" }));
-const api = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  createComponents,
-  createMediaTypeSchema,
-  createParamOrRef,
-  getDefaultComponents
-}, Symbol.toStringTag, { value: "Module" }));
 export {
-  api,
   createDocument,
   extendZodWithOpenApi,
   oas30,