zod-openapi 5.4.6 → 6.0.0

package/{dist/components-ZWafjNVh.cjs → lib/components-BDEwP6Uu.cjs}

@@ -1,37 +1,15 @@
 let zod_v4_core = require("zod/v4/core");
 let zod_v4 = require("zod/v4");
-
 //#region src/zod.ts
 const isAnyZodType = (schema) => typeof schema === "object" && schema !== null && "_zod" in schema;
-
 //#endregion
 //#region src/create/examples.ts
-const createExamples = (examples, registry$1, path) => {
+const createExamples = (examples, registry, path) => {
 	if (!examples) return;
 	const examplesObject = {};
-	for (const [name, example] of Object.entries(examples)) examplesObject[name] = registry$1.addExample(example, [...path, name]);
+	for (const [name, example] of Object.entries(examples)) examplesObject[name] = registry.addExample(example, [...path, name]);
 	return examplesObject;
 };
-
-//#endregion
-//#region src/create/content.ts
-const createMediaTypeObject = (mediaType, ctx, path) => {
-	const { schema, examples, ...rest } = mediaType;
-	const mediaTypeObject = rest;
-	if (isAnyZodType(schema)) mediaTypeObject.schema = ctx.registry.addSchema(schema, [...path, "schema"], {
-		io: ctx.io,
-		source: { type: "mediaType" }
-	});
-	else mediaTypeObject.schema = schema;
-	if (examples) mediaTypeObject.examples = createExamples(examples, ctx.registry, [...path, "examples"]);
-	return mediaTypeObject;
-};
-const createContent = (content, ctx, path) => {
-	const contentObject = {};
-	for (const [mediaType, mediaTypeObject] of Object.entries(content)) if (mediaTypeObject) contentObject[mediaType] = createMediaTypeObject(mediaTypeObject, ctx, [...path, mediaType]);
-	return contentObject;
-};
-
 //#endregion
 //#region src/create/object.ts
 const unwrapZodObject = (zodType, io, path) => {
@@ -49,37 +27,83 @@ const isRequired = (zodType, io) => {
 	if (io === "input") return zodType._zod.optin === void 0;
 	return zodType._zod.optout === void 0;
 };
-
 //#endregion
 //#region src/create/headers.ts
-const createHeaders = (headers, registry$1, path) => {
+const createHeaders = (headers, registry, path) => {
 	if (!headers) return;
 	if (isAnyZodType(headers)) {
 		const zodObject = unwrapZodObject(headers, "output", path);
 		const headersObject = {};
-		for (const [key, zodSchema] of Object.entries(zodObject._zod.def.shape)) headersObject[key] = registry$1.addHeader(zodSchema, [...path, key]);
+		for (const [key, zodSchema] of Object.entries(zodObject._zod.def.shape)) headersObject[key] = registry.addHeader(zodSchema, [...path, key]);
 		return headersObject;
 	}
 	return headers;
 };
-
+//#endregion
+//#region src/create/specificationExtension.ts
+const isISpecificationExtension = (key) => key.startsWith("x-");
+//#endregion
+//#region src/create/content.ts
+const createMediaTypeObject = (mediaType, ctx, path) => {
+	const { schema, itemSchema, examples, encoding, itemEncoding, prefixEncoding, ...rest } = mediaType;
+	const mediaTypeObject = rest;
+	if (isAnyZodType(schema)) mediaTypeObject.schema = ctx.registry.addSchema(schema, [...path, "schema"], {
+		io: ctx.io,
+		source: { type: "mediaType" }
+	});
+	else if (schema) mediaTypeObject.schema = schema;
+	if (isAnyZodType(itemSchema)) mediaTypeObject.itemSchema = ctx.registry.addSchema(itemSchema, [...path, "itemSchema"], {
+		io: ctx.io,
+		source: { type: "mediaType" }
+	});
+	else if (itemSchema) mediaTypeObject.itemSchema = itemSchema;
+	if (examples) mediaTypeObject.examples = createExamples(examples, ctx.registry, [...path, "examples"]);
+	if (encoding) mediaTypeObject.encoding = createEncodingObject(encoding, ctx, [...path, "encoding"]);
+	if (itemEncoding) mediaTypeObject.itemEncoding = createEncodingProperty(itemEncoding, ctx, [...path, "itemEncoding"]);
+	if (prefixEncoding) mediaTypeObject.prefixEncoding = prefixEncoding.map((encodingPrefix) => createEncodingProperty(encodingPrefix, ctx, [...path, "prefixEncoding"]));
+	return mediaTypeObject;
+};
+const createContent = (content, ctx, path) => {
+	const contentObject = {};
+	for (const [mediaType, mediaTypeObject] of Object.entries(content)) if (mediaTypeObject) contentObject[mediaType] = createMediaTypeObject(mediaTypeObject, ctx, [...path, mediaType]);
+	return contentObject;
+};
+const createEncodingObject = (encoding, ctx, path) => {
+	const encodingObject = {};
+	for (const [property, encodingProperty] of Object.entries(encoding)) {
+		if (isISpecificationExtension(property)) {
+			encodingObject[property] = encodingProperty;
+			continue;
+		}
+		encodingObject[property] = createEncodingProperty(encodingProperty, ctx, [...path, property]);
+	}
+	return encodingObject;
+};
+const createEncodingProperty = (encodingProperty, ctx, path) => {
+	const { headers, encoding, prefixEncoding, itemEncoding, ...rest } = encodingProperty;
+	const encodingPropertyObject = rest;
+	if (headers) encodingPropertyObject.headers = createHeaders(headers, ctx.registry, [...path, "headers"]);
+	if (encoding) encodingPropertyObject.encoding = createEncodingObject(encoding, ctx, [...path, "encoding"]);
+	if (prefixEncoding) encodingPropertyObject.prefixEncoding = prefixEncoding.map((encodingPrefix) => createEncodingProperty(encodingPrefix, ctx, [...path, "prefixEncoding"]));
+	if (itemEncoding) encodingPropertyObject.itemEncoding = createEncodingProperty(itemEncoding, ctx, [...path, "itemEncoding"]);
+	return encodingPropertyObject;
+};
 //#endregion
 //#region src/create/links.ts
-const createLinks = (links, registry$1, path) => {
+const createLinks = (links, registry, path) => {
 	if (!links) return;
 	const linksObject = {};
-	for (const [name, link] of Object.entries(links)) linksObject[name] = registry$1.addLink(link, [...path, name]);
+	for (const [name, link] of Object.entries(links)) linksObject[name] = registry.addLink(link, [...path, name]);
 	return linksObject;
 };
-
 //#endregion
 //#region src/create/parameters.ts
-const createManualParameters = (parameters, registry$1, path) => {
+const createManualParameters = (parameters, registry, path) => {
 	if (!parameters) return;
 	const parameterObjects = [];
 	for (const parameter of parameters) {
 		if (isAnyZodType(parameter)) {
-			const paramObject = registry$1.addParameter(parameter, [...path, "parameters"]);
+			const paramObject = registry.addParameter(parameter, [...path, "parameters"]);
 			parameterObjects.push(paramObject);
 			continue;
 		}
@@ -87,13 +111,13 @@ const createManualParameters = (parameters, registry$1, path) => {
 	}
 	return parameterObjects;
 };
-const createParameters = (requestParams, registry$1, path) => {
+const createParameters = (requestParams, registry, path) => {
 	if (!requestParams) return;
 	const parameterObjects = [];
 	for (const [location, schema] of Object.entries(requestParams ?? {})) {
 		const zodObject = unwrapZodObject(schema, "input", path);
 		for (const [name, zodSchema] of Object.entries(zodObject._zod.def.shape)) {
-			const paramObject = registry$1.addParameter(zodSchema, [
+			const paramObject = registry.addParameter(zodSchema, [
 				...path,
 				location,
 				name
@@ -106,14 +130,9 @@ const createParameters = (requestParams, registry$1, path) => {
 	}
 	return parameterObjects;
 };
-
-//#endregion
-//#region src/create/specificationExtension.ts
-const isISpecificationExtension = (key) => key.startsWith("x-");
-
 //#endregion
 //#region src/create/callbacks.ts
-const createCallbacks = (callbacks, registry$1, path) => {
+const createCallbacks = (callbacks, registry, path) => {
 	if (!callbacks) return;
 	const callbacksObject = {};
 	for (const [name, value] of Object.entries(callbacks)) {
@@ -121,14 +140,13 @@ const createCallbacks = (callbacks, registry$1, path) => {
 			callbacksObject[name] = value;
 			continue;
 		}
-		callbacksObject[name] = registry$1.addCallback(value, [...path, name]);
+		callbacksObject[name] = registry.addCallback(value, [...path, name]);
 	}
 	return callbacksObject;
 };
-
 //#endregion
 //#region src/create/responses.ts
-const createResponses = (responses, registry$1, path) => {
+const createResponses = (responses, registry, path) => {
 	if (!responses) return;
 	const responsesObject = {};
 	for (const [statusCode, response] of Object.entries(responses)) {
@@ -141,28 +159,27 @@ const createResponses = (responses, registry$1, path) => {
 			responsesObject[statusCode] = response;
 			continue;
 		}
-		responsesObject[statusCode] = registry$1.addResponse(response, [...path, statusCode]);
+		responsesObject[statusCode] = registry.addResponse(response, [...path, statusCode]);
 	}
 	return responsesObject;
 };
-
 //#endregion
 //#region src/create/paths.ts
-const createOperation = (operation, registry$1, path) => {
+const createOperation = (operation, registry, path) => {
 	const { parameters, requestParams, requestBody, responses, callbacks, ...rest } = operation;
 	const operationObject = rest;
-	const maybeManualParameters = createManualParameters(parameters, registry$1, [...path, "parameters"]);
-	const maybeRequestParams = createParameters(requestParams, registry$1, [...path, "requestParams"]);
+	const maybeManualParameters = createManualParameters(parameters, registry, [...path, "parameters"]);
+	const maybeRequestParams = createParameters(requestParams, registry, [...path, "requestParams"]);
 	if (maybeRequestParams || maybeManualParameters) operationObject.parameters = [...maybeRequestParams ?? [], ...maybeManualParameters ?? []];
-	const maybeRequestBody = requestBody && registry$1.addRequestBody(requestBody, path);
+	const maybeRequestBody = requestBody && registry.addRequestBody(requestBody, path);
 	if (maybeRequestBody) operationObject.requestBody = maybeRequestBody;
-	const maybeResponses = createResponses(responses, registry$1, [...path, "responses"]);
+	const maybeResponses = createResponses(responses, registry, [...path, "responses"]);
 	if (maybeResponses) operationObject.responses = maybeResponses;
-	const maybeCallbacks = createCallbacks(callbacks, registry$1, [...path, "callbacks"]);
+	const maybeCallbacks = createCallbacks(callbacks, registry, [...path, "callbacks"]);
 	if (maybeCallbacks) operationObject.callbacks = maybeCallbacks;
 	return operationObject;
 };
-const createPaths = (paths, registry$1, path) => {
+const createPaths = (paths, registry, path) => {
 	if (!paths) return;
 	const pathsObject = {};
 	for (const [singlePath, pathItemObject] of Object.entries(paths)) {
@@ -170,11 +187,10 @@ const createPaths = (paths, registry$1, path) => {
 			pathsObject[singlePath] = pathItemObject;
 			continue;
 		}
-		pathsObject[singlePath] = registry$1.addPathItem(pathItemObject, [...path, singlePath]);
+		pathsObject[singlePath] = registry.addPathItem(pathItemObject, [...path, singlePath]);
 	}
 	return pathsObject;
 };
-
 //#endregion
 //#region src/openapi.ts
 const openApiVersions = [
@@ -183,10 +199,10 @@ const openApiVersions = [
 	"3.0.2",
 	"3.0.3",
 	"3.1.0",
-	"3.1.1"
+	"3.1.1",
+	"3.2.0"
 ];
 const satisfiesVersion = (test, against) => openApiVersions.indexOf(test) >= openApiVersions.indexOf(against);
-
 //#endregion
 //#region src/create/schema/override.ts
 const override = (ctx) => {
@@ -279,7 +295,6 @@ const validate = (ctx, opts, previousContext) => {
 	}
 	throw new Error(`Zod schema of type \`${def.type}\` at ${ctx.path.join(" > ")} cannot be represented in OpenAPI. Please assign it metadata with \`.meta()\``);
 };
-
 //#endregion
 //#region src/create/schema/rename.ts
 const renameComponents = (components, outputIds, ctx, refPath) => {
@@ -309,22 +324,21 @@ const renameComponents = (components, outputIds, ctx, refPath) => {
 	}
 	return componentsToRename;
 };
-const isDependencyPure = (componentDependencies, stringifiedComponents, registry$1, key, visited = /* @__PURE__ */ new Set()) => {
+const isDependencyPure = (componentDependencies, stringifiedComponents, registry, key, visited = /* @__PURE__ */ new Set()) => {
 	if (visited.has(key)) return true;
 	const dependencies = componentDependencies.get(key);
 	if (dependencies.pure !== void 0) return dependencies.pure;
 	const stringified = stringifiedComponents.get(key);
-	const component = registry$1.components.schemas.ids.get(key);
+	const component = registry.components.schemas.ids.get(key);
 	if (component && stringified !== JSON.stringify(component)) {
 		dependencies.pure = false;
 		return false;
 	}
 	visited.add(key);
-	const result = [...dependencies.dependencies].every((dep) => isDependencyPure(componentDependencies, stringifiedComponents, registry$1, dep, new Set(visited)));
+	const result = [...dependencies.dependencies].every((dep) => isDependencyPure(componentDependencies, stringifiedComponents, registry, dep, new Set(visited)));
 	dependencies.pure = result;
 	return result;
 };
-
 //#endregion
 //#region src/create/schema/schema.ts
 const createSchema = (schema, ctx = {}) => {
@@ -467,11 +481,10 @@ const createSchemas = (schemas, ctx) => {
 		manual: renamedJsonSchema.schemas
 	};
 };
-
 //#endregion
 //#region src/create/components.ts
 const createRegistry = (components) => {
-	const registry$1 = {
+	const registry = {
 		components: {
 			schemas: {
 				dynamicSchemaCount: 0,
@@ -519,7 +532,7 @@ const createRegistry = (components) => {
 		},
 		addSchema: (schema, path, opts) => {
 			const schemaObject = {};
-			registry$1.components.schemas[opts.io].set(path.join(" > "), {
+			registry.components.schemas[opts.io].set(path.join(" > "), {
 				schemaObject,
 				zodType: schema,
 				source: {
@@ -530,14 +543,14 @@ const createRegistry = (components) => {
 			return schemaObject;
 		},
 		addParameter: (parameter, path, opts) => {
-			const seenParameter = registry$1.components.parameters.seen.get(parameter);
+			const seenParameter = registry.components.parameters.seen.get(parameter);
 			if (seenParameter) return seenParameter;
 			const meta = zod_v4_core.globalRegistry.get(parameter);
 			const name = opts?.location?.name ?? meta?.param?.name;
 			const inLocation = opts?.location?.in ?? meta?.param?.in;
 			if (opts?.location?.name && meta?.param?.name || opts?.location?.in && meta?.param?.in) throw new Error(`Parameter at ${path.join(" > ")} has both \`.meta({ param: { name, in } })\` and \`.meta({ param: { location: { in, name } } })\` information`);
 			if (!name || !inLocation) throw new Error(`Parameter at ${path.join(" > ")} is missing \`.meta({ param: { name, in } })\` information`);
-			const schemaObject = registry$1.addSchema(parameter, [
+			const schemaObject = registry.addSchema(parameter, [
 				...path,
 				inLocation,
 				name,
@@ -559,7 +572,7 @@ const createRegistry = (components) => {
 				schema: schemaObject,
 				...rest
 			};
-			const examplesObject = createExamples(examples, registry$1, [
+			const examplesObject = createExamples(examples, registry, [
 				...path,
 				inLocation,
 				name,
@@ -570,19 +583,19 @@ const createRegistry = (components) => {
 			if (!parameterObject.description && meta?.description) parameterObject.description = meta.description;
 			const id = metaId ?? opts?.manualId;
 			if (id) {
-				if (registry$1.components.parameters.ids.has(id)) throw new Error(`Schema "${id}" at ${path.join(" > ")} is already registered`);
+				if (registry.components.parameters.ids.has(id)) throw new Error(`Schema "${id}" at ${path.join(" > ")} is already registered`);
 				const ref = { $ref: `#/components/parameters/${id}` };
-				registry$1.components.parameters.seen.set(parameter, ref);
-				registry$1.components.parameters.ids.set(id, parameterObject);
+				registry.components.parameters.seen.set(parameter, ref);
+				registry.components.parameters.ids.set(id, parameterObject);
 				if (opts?.manualId) return parameterObject;
 				return ref;
 			}
 			if (opts?.location?.name || opts?.location?.in) return parameterObject;
-			registry$1.components.parameters.seen.set(parameter, parameterObject);
+			registry.components.parameters.seen.set(parameter, parameterObject);
 			return parameterObject;
 		},
 		addHeader: (header, path, opts) => {
-			const seenHeader = registry$1.components.headers.seen.get(header);
+			const seenHeader = registry.components.headers.seen.get(header);
 			if (seenHeader) return seenHeader;
 			const meta = zod_v4_core.globalRegistry.get(header);
 			const { id: metaId, ...rest } = meta?.header ?? {};
@@ -590,46 +603,46 @@ const createRegistry = (components) => {
 			const headerObject = rest;
 			if (isRequired(header, "output")) headerObject.required = true;
 			if (!headerObject.description && meta?.description) headerObject.description = meta.description;
-			headerObject.schema = registry$1.addSchema(header, [...path, "schema"], {
+			headerObject.schema = registry.addSchema(header, [...path, "schema"], {
 				io: "output",
 				source: { type: "header" }
 			});
 			if (id) {
-				if (registry$1.components.schemas.ids.has(id)) throw new Error(`Schema "${id}" at ${path.join(" > ")} is already registered`);
+				if (registry.components.schemas.ids.has(id)) throw new Error(`Schema "${id}" at ${path.join(" > ")} is already registered`);
 				const ref = { $ref: `#/components/headers/${id}` };
-				registry$1.components.headers.ids.set(id, headerObject);
-				registry$1.components.headers.seen.set(header, ref);
+				registry.components.headers.ids.set(id, headerObject);
+				registry.components.headers.seen.set(header, ref);
 				if (opts?.manualId) return headerObject;
 				return ref;
 			}
-			registry$1.components.headers.seen.set(header, headerObject);
+			registry.components.headers.seen.set(header, headerObject);
 			return headerObject;
 		},
 		addRequestBody: (requestBody, path, opts) => {
-			const seenRequestBody = registry$1.components.requestBodies.seen.get(requestBody);
+			const seenRequestBody = registry.components.requestBodies.seen.get(requestBody);
 			if (seenRequestBody) return seenRequestBody;
 			const { content, id: metaId, ...rest } = requestBody;
 			const requestBodyObject = {
 				...rest,
 				content: createContent(content, {
-					registry: registry$1,
+					registry,
 					io: "input"
 				}, [...path, "content"])
 			};
 			const id = metaId ?? opts?.manualId;
 			if (id) {
-				if (registry$1.components.requestBodies.ids.has(id)) throw new Error(`RequestBody "${id}" at ${path.join(" > ")} is already registered`);
+				if (registry.components.requestBodies.ids.has(id)) throw new Error(`RequestBody "${id}" at ${path.join(" > ")} is already registered`);
 				const ref = { $ref: `#/components/requestBodies/${id}` };
-				registry$1.components.requestBodies.ids.set(id, requestBodyObject);
-				registry$1.components.requestBodies.seen.set(requestBody, ref);
+				registry.components.requestBodies.ids.set(id, requestBodyObject);
+				registry.components.requestBodies.seen.set(requestBody, ref);
 				if (opts?.manualId) return requestBodyObject;
 				return ref;
 			}
-			registry$1.components.requestBodies.seen.set(requestBody, requestBodyObject);
+			registry.components.requestBodies.seen.set(requestBody, requestBodyObject);
 			return requestBodyObject;
 		},
 		addPathItem: (pathItem, path, opts) => {
-			const seenPathItem = registry$1.components.pathItems.seen.get(pathItem);
+			const seenPathItem = registry.components.pathItems.seen.get(pathItem);
 			if (seenPathItem) return seenPathItem;
 			const pathItemObject = {};
 			const { id: metaId, ...rest } = pathItem;
@@ -639,53 +652,63 @@ const createRegistry = (components) => {
 					pathItemObject[key] = value;
 					continue;
 				}
-				if (key === "get" || key === "put" || key === "post" || key === "delete" || key === "options" || key === "head" || key === "patch" || key === "trace") {
-					pathItemObject[key] = createOperation(value, registry$1, [...path, key]);
+				if (key === "get" || key === "put" || key === "post" || key === "delete" || key === "options" || key === "head" || key === "patch" || key === "trace" || key === "query") {
+					pathItemObject[key] = createOperation(value, registry, [...path, key]);
 					continue;
 				}
 				if (key === "parameters") {
-					pathItemObject[key] = createManualParameters(value, registry$1, [...path, key]);
+					pathItemObject[key] = createManualParameters(value, registry, [...path, key]);
+					continue;
+				}
+				if (key === "additionalOperations") {
+					const additionalOperations = {};
+					for (const [method, operation] of Object.entries(value)) additionalOperations[method] = createOperation(operation, registry, [
+						...path,
+						key,
+						method
+					]);
+					pathItemObject.additionalOperations = additionalOperations;
 					continue;
 				}
 				pathItemObject[key] = value;
 			}
 			if (id) {
-				if (registry$1.components.pathItems.ids.has(id)) throw new Error(`PathItem "${id}" at ${path.join(" > ")} is already registered`);
+				if (registry.components.pathItems.ids.has(id)) throw new Error(`PathItem "${id}" at ${path.join(" > ")} is already registered`);
 				const ref = { $ref: `#/components/pathItems/${id}` };
-				registry$1.components.pathItems.ids.set(id, pathItemObject);
-				registry$1.components.pathItems.seen.set(pathItem, ref);
+				registry.components.pathItems.ids.set(id, pathItemObject);
+				registry.components.pathItems.seen.set(pathItem, ref);
 				if (opts?.manualId) return pathItemObject;
 				return ref;
 			}
-			registry$1.components.pathItems.seen.set(pathItem, pathItemObject);
+			registry.components.pathItems.seen.set(pathItem, pathItemObject);
 			return pathItemObject;
 		},
 		addResponse: (response, path, opts) => {
-			const seenResponse = registry$1.components.responses.seen.get(response);
+			const seenResponse = registry.components.responses.seen.get(response);
 			if (seenResponse) return seenResponse;
 			const { content, headers, links, id: metaId, ...rest } = response;
 			const responseObject = rest;
-			const maybeHeaders = createHeaders(headers, registry$1, [...path, "headers"]);
+			const maybeHeaders = createHeaders(headers, registry, [...path, "headers"]);
 			if (maybeHeaders) responseObject.headers = maybeHeaders;
 			if (content) responseObject.content = createContent(content, {
-				registry: registry$1,
+				registry,
 				io: "output"
 			}, [...path, "content"]);
-			if (links) responseObject.links = createLinks(links, registry$1, [...path, "links"]);
+			if (links) responseObject.links = createLinks(links, registry, [...path, "links"]);
 			const id = metaId ?? opts?.manualId;
 			if (id) {
-				if (registry$1.components.responses.ids.has(id)) throw new Error(`Response "${id}" at ${path.join(" > ")} is already registered`);
+				if (registry.components.responses.ids.has(id)) throw new Error(`Response "${id}" at ${path.join(" > ")} is already registered`);
 				const ref = { $ref: `#/components/responses/${id}` };
-				registry$1.components.responses.ids.set(id, responseObject);
-				registry$1.components.responses.seen.set(response, ref);
+				registry.components.responses.ids.set(id, responseObject);
+				registry.components.responses.seen.set(response, ref);
 				if (opts?.manualId) return responseObject;
 				return ref;
 			}
-			registry$1.components.responses.seen.set(response, responseObject);
+			registry.components.responses.seen.set(response, responseObject);
 			return responseObject;
 		},
 		addCallback: (callback, path, opts) => {
-			const seenCallback = registry$1.components.callbacks.seen.get(callback);
+			const seenCallback = registry.components.callbacks.seen.get(callback);
 			if (seenCallback) return seenCallback;
 			const { id: metaId, ...rest } = callback;
 			const callbackObject = {};
@@ -694,100 +717,100 @@ const createRegistry = (components) => {
 					callbackObject[name] = pathItem;
 					continue;
 				}
-				callbackObject[name] = registry$1.addPathItem(pathItem, [...path, name]);
+				callbackObject[name] = registry.addPathItem(pathItem, [...path, name]);
 			}
 			const id = metaId ?? opts?.manualId;
 			if (id) {
-				if (registry$1.components.callbacks.ids.has(id)) throw new Error(`Callback "${id}" at ${path.join(" > ")} is already registered`);
+				if (registry.components.callbacks.ids.has(id)) throw new Error(`Callback "${id}" at ${path.join(" > ")} is already registered`);
 				const ref = { $ref: `#/components/callbacks/${id}` };
-				registry$1.components.callbacks.ids.set(id, callbackObject);
-				registry$1.components.callbacks.seen.set(callback, ref);
+				registry.components.callbacks.ids.set(id, callbackObject);
+				registry.components.callbacks.seen.set(callback, ref);
 				if (opts?.manualId) return callbackObject;
 				return ref;
 			}
-			registry$1.components.callbacks.seen.set(callback, callbackObject);
+			registry.components.callbacks.seen.set(callback, callbackObject);
 			return callbackObject;
 		},
 		addSecurityScheme: (securityScheme, path, opts) => {
-			const seenSecurityScheme = registry$1.components.securitySchemes.seen.get(securityScheme);
+			const seenSecurityScheme = registry.components.securitySchemes.seen.get(securityScheme);
 			if (seenSecurityScheme) return seenSecurityScheme;
 			const { id: metaId, ...rest } = securityScheme;
 			const securitySchemeObject = rest;
 			const id = metaId ?? opts?.manualId;
 			if (id) {
-				if (registry$1.components.securitySchemes.ids.has(id)) throw new Error(`SecurityScheme "${id}" at ${path.join(" > ")} is already registered`);
+				if (registry.components.securitySchemes.ids.has(id)) throw new Error(`SecurityScheme "${id}" at ${path.join(" > ")} is already registered`);
 				const ref = { $ref: `#/components/securitySchemes/${id}` };
-				registry$1.components.securitySchemes.ids.set(id, securitySchemeObject);
-				registry$1.components.securitySchemes.seen.set(securityScheme, ref);
+				registry.components.securitySchemes.ids.set(id, securitySchemeObject);
+				registry.components.securitySchemes.seen.set(securityScheme, ref);
 				if (opts?.manualId) return securitySchemeObject;
 				return ref;
 			}
-			registry$1.components.securitySchemes.seen.set(securityScheme, securitySchemeObject);
+			registry.components.securitySchemes.seen.set(securityScheme, securitySchemeObject);
 			return securitySchemeObject;
 		},
 		addLink: (link, path, opts) => {
-			const seenLink = registry$1.components.links.seen.get(link);
+			const seenLink = registry.components.links.seen.get(link);
 			if (seenLink) return seenLink;
 			const { id: metaId, ...rest } = link;
 			const linkObject = rest;
 			const id = metaId ?? opts?.manualId;
 			if (id) {
-				if (registry$1.components.links.ids.has(id)) throw new Error(`Link "${id}" at ${path.join(" > ")} is already registered`);
+				if (registry.components.links.ids.has(id)) throw new Error(`Link "${id}" at ${path.join(" > ")} is already registered`);
 				const ref = { $ref: `#/components/links/${id}` };
-				registry$1.components.links.ids.set(id, linkObject);
-				registry$1.components.links.seen.set(link, ref);
+				registry.components.links.ids.set(id, linkObject);
+				registry.components.links.seen.set(link, ref);
 				if (opts?.manualId) return linkObject;
 				return ref;
 			}
-			registry$1.components.links.seen.set(link, linkObject);
+			registry.components.links.seen.set(link, linkObject);
 			return linkObject;
 		},
 		addExample: (example, path, opts) => {
-			const seenExample = registry$1.components.examples.seen.get(example);
+			const seenExample = registry.components.examples.seen.get(example);
 			if (seenExample) return seenExample;
 			const { id: metaId, ...rest } = example;
 			const exampleObject = rest;
 			const id = metaId ?? opts?.manualId;
 			if (id) {
-				if (registry$1.components.examples.ids.has(id)) throw new Error(`Example "${id}" at ${path.join(" > ")} is already registered`);
+				if (registry.components.examples.ids.has(id)) throw new Error(`Example "${id}" at ${path.join(" > ")} is already registered`);
 				const ref = { $ref: `#/components/examples/${id}` };
-				registry$1.components.examples.ids.set(id, exampleObject);
-				registry$1.components.examples.seen.set(example, ref);
+				registry.components.examples.ids.set(id, exampleObject);
+				registry.components.examples.seen.set(example, ref);
 				if (opts?.manualId) return exampleObject;
 				return ref;
 			}
-			registry$1.components.examples.seen.set(example, exampleObject);
+			registry.components.examples.seen.set(example, exampleObject);
 			return exampleObject;
 		}
 	};
-	registerSchemas(components?.schemas, registry$1);
-	registerParameters(components?.parameters, registry$1);
-	registerHeaders(components?.headers, registry$1);
-	registerResponses(components?.responses, registry$1);
-	registerPathItems(components?.pathItems, registry$1);
-	registerRequestBodies(components?.requestBodies, registry$1);
-	registerCallbacks(components?.callbacks, registry$1);
-	registerSecuritySchemes(components?.securitySchemes, registry$1);
-	registerLinks(components?.links, registry$1);
-	registerExamples(components?.examples, registry$1);
-	return registry$1;
-};
-const registerSchemas = (schemas, registry$1) => {
+	registerSchemas(components?.schemas, registry);
+	registerParameters(components?.parameters, registry);
+	registerHeaders(components?.headers, registry);
+	registerResponses(components?.responses, registry);
+	registerPathItems(components?.pathItems, registry);
+	registerRequestBodies(components?.requestBodies, registry);
+	registerCallbacks(components?.callbacks, registry);
+	registerSecuritySchemes(components?.securitySchemes, registry);
+	registerLinks(components?.links, registry);
+	registerExamples(components?.examples, registry);
+	return registry;
+};
+const registerSchemas = (schemas, registry) => {
 	if (!schemas) return;
 	for (const [key, schema] of Object.entries(schemas)) {
 		if (isAnyZodType(schema)) {
 			const id = zod_v4_core.globalRegistry.get(schema)?.id ?? key;
-			registry$1.components.schemas.manual.set(id, {
+			registry.components.schemas.manual.set(id, {
 				input: { schemaObject: {} },
 				output: { schemaObject: {} },
 				zodType: schema
 			});
 			continue;
 		}
-		registry$1.components.schemas.ids.set(key, schema);
+		registry.components.schemas.ids.set(key, schema);
 	}
 };
-const registerParameters = (parameters, registry$1) => {
+const registerParameters = (parameters, registry) => {
 	if (!parameters) return;
 	for (const [key, schema] of Object.entries(parameters)) {
 		if (isAnyZodType(schema)) {
@@ -796,13 +819,13 @@ const registerParameters = (parameters, registry$1) => {
 				"parameters",
 				key
 			];
-			registry$1.addParameter(schema, path, { manualId: key });
+			registry.addParameter(schema, path, { manualId: key });
 			continue;
 		}
-		registry$1.components.parameters.ids.set(key, schema);
+		registry.components.parameters.ids.set(key, schema);
 	}
 };
-const registerHeaders = (headers, registry$1) => {
+const registerHeaders = (headers, registry) => {
 	if (!headers) return;
 	for (const [key, schema] of Object.entries(headers)) {
 		if (isAnyZodType(schema)) {
@@ -811,73 +834,73 @@ const registerHeaders = (headers, registry$1) => {
 				"headers",
 				key
 			];
-			registry$1.addHeader(schema, path, { manualId: key });
+			registry.addHeader(schema, path, { manualId: key });
 			continue;
 		}
-		registry$1.components.headers.ids.set(key, schema);
+		registry.components.headers.ids.set(key, schema);
 	}
 };
-const registerResponses = (responses, registry$1) => {
+const registerResponses = (responses, registry) => {
 	if (!responses) return;
 	for (const [key, schema] of Object.entries(responses)) {
-		const responseObject = registry$1.addResponse(schema, [
+		const responseObject = registry.addResponse(schema, [
 			"components",
 			"responses",
 			key
 		], { manualId: key });
-		registry$1.components.responses.ids.set(key, responseObject);
-		registry$1.components.responses.seen.set(schema, responseObject);
+		registry.components.responses.ids.set(key, responseObject);
+		registry.components.responses.seen.set(schema, responseObject);
 	}
 };
-const registerRequestBodies = (requestBodies, registry$1) => {
+const registerRequestBodies = (requestBodies, registry) => {
 	if (!requestBodies) return;
 	for (const [key, schema] of Object.entries(requestBodies)) {
 		if (isAnyZodType(schema)) {
-			registry$1.addRequestBody(schema, [
+			registry.addRequestBody(schema, [
 				"components",
 				"requestBodies",
 				key
 			], { manualId: key });
 			continue;
 		}
-		registry$1.components.requestBodies.ids.set(key, schema);
+		registry.components.requestBodies.ids.set(key, schema);
 	}
 };
-const registerCallbacks = (callbacks, registry$1) => {
+const registerCallbacks = (callbacks, registry) => {
 	if (!callbacks) return;
-	for (const [key, schema] of Object.entries(callbacks)) registry$1.addCallback(schema, [
+	for (const [key, schema] of Object.entries(callbacks)) registry.addCallback(schema, [
 		"components",
 		"callbacks",
 		key
 	], { manualId: key });
 };
-const registerPathItems = (pathItems, registry$1) => {
+const registerPathItems = (pathItems, registry) => {
 	if (!pathItems) return;
-	for (const [key, schema] of Object.entries(pathItems)) registry$1.addPathItem(schema, [
+	for (const [key, schema] of Object.entries(pathItems)) registry.addPathItem(schema, [
 		"components",
 		"pathItems",
 		key
 	], { manualId: key });
 };
-const registerSecuritySchemes = (securitySchemes, registry$1) => {
+const registerSecuritySchemes = (securitySchemes, registry) => {
 	if (!securitySchemes) return;
-	for (const [key, schema] of Object.entries(securitySchemes)) registry$1.addSecurityScheme(schema, [
+	for (const [key, schema] of Object.entries(securitySchemes)) registry.addSecurityScheme(schema, [
 		"components",
 		"securitySchemes",
 		key
 	], { manualId: key });
 };
-const registerLinks = (links, registry$1) => {
+const registerLinks = (links, registry) => {
 	if (!links) return;
-	for (const [key, schema] of Object.entries(links)) registry$1.addLink(schema, [
+	for (const [key, schema] of Object.entries(links)) registry.addLink(schema, [
 		"components",
 		"links",
 		key
 	], { manualId: key });
 };
-const registerExamples = (examples, registry$1) => {
+const registerExamples = (examples, registry) => {
 	if (!examples) return;
-	for (const [key, schema] of Object.entries(examples)) registry$1.components.examples.ids.set(key, schema);
+	for (const [key, schema] of Object.entries(examples)) registry.components.examples.ids.set(key, schema);
 };
 const createIOSchemas = (ctx) => {
 	const { schemas, components, manual } = createSchemas(Object.fromEntries(ctx.registry.components.schemas[ctx.io]), ctx);
@@ -893,74 +916,73 @@ const createIOSchemas = (ctx) => {
 		Object.assign(manualSchema[ctx.io].schemaObject, value);
 	}
 };
-const createManualSchemas = (registry$1) => {
-	for (const [key, value] of registry$1.components.schemas.manual) if (!value.input.used) {
+const createManualSchemas = (registry) => {
+	for (const [key, value] of registry.components.schemas.manual) if (!value.input.used) {
 		const schema = value[zod_v4_core.globalRegistry.get(value.zodType)?.unusedIO ?? "output"].schemaObject;
-		registry$1.components.schemas.ids.set(key, schema);
+		registry.components.schemas.ids.set(key, schema);
 	}
 };
-const createComponents = (registry$1, opts, openapiVersion) => {
+const createComponents = (registry, opts, openapiVersion) => {
 	createIOSchemas({
-		registry: registry$1,
+		registry,
 		io: "input",
 		opts,
 		openapiVersion
 	});
 	createIOSchemas({
-		registry: registry$1,
+		registry,
 		io: "output",
 		opts,
 		openapiVersion
 	});
-	createManualSchemas(registry$1);
+	createManualSchemas(registry);
 	const components = {};
-	if (registry$1.components.schemas.ids.size > 0) components.schemas = Object.fromEntries(registry$1.components.schemas.ids);
-	if (registry$1.components.headers.ids.size > 0) components.headers = Object.fromEntries(registry$1.components.headers.ids);
-	if (registry$1.components.requestBodies.ids.size > 0) components.requestBodies = Object.fromEntries(registry$1.components.requestBodies.ids);
-	if (registry$1.components.responses.ids.size > 0) components.responses = Object.fromEntries(registry$1.components.responses.ids);
-	if (registry$1.components.parameters.ids.size > 0) components.parameters = Object.fromEntries(registry$1.components.parameters.ids);
-	if (registry$1.components.callbacks.ids.size > 0) components.callbacks = Object.fromEntries(registry$1.components.callbacks.ids);
-	if (registry$1.components.pathItems.ids.size > 0) components.pathItems = Object.fromEntries(registry$1.components.pathItems.ids);
-	if (registry$1.components.securitySchemes.ids.size > 0) components.securitySchemes = Object.fromEntries(registry$1.components.securitySchemes.ids);
-	if (registry$1.components.links.ids.size > 0) components.links = Object.fromEntries(registry$1.components.links.ids);
-	if (registry$1.components.examples.ids.size > 0) components.examples = Object.fromEntries(registry$1.components.examples.ids);
+	if (registry.components.schemas.ids.size > 0) components.schemas = Object.fromEntries(registry.components.schemas.ids);
+	if (registry.components.headers.ids.size > 0) components.headers = Object.fromEntries(registry.components.headers.ids);
+	if (registry.components.requestBodies.ids.size > 0) components.requestBodies = Object.fromEntries(registry.components.requestBodies.ids);
+	if (registry.components.responses.ids.size > 0) components.responses = Object.fromEntries(registry.components.responses.ids);
+	if (registry.components.parameters.ids.size > 0) components.parameters = Object.fromEntries(registry.components.parameters.ids);
+	if (registry.components.callbacks.ids.size > 0) components.callbacks = Object.fromEntries(registry.components.callbacks.ids);
+	if (registry.components.pathItems.ids.size > 0) components.pathItems = Object.fromEntries(registry.components.pathItems.ids);
+	if (registry.components.securitySchemes.ids.size > 0) components.securitySchemes = Object.fromEntries(registry.components.securitySchemes.ids);
+	if (registry.components.links.ids.size > 0) components.links = Object.fromEntries(registry.components.links.ids);
+	if (registry.components.examples.ids.size > 0) components.examples = Object.fromEntries(registry.components.examples.ids);
 	return components;
 };
-
 //#endregion
-Object.defineProperty(exports, 'createComponents', {
-  enumerable: true,
-  get: function () {
-    return createComponents;
-  }
+Object.defineProperty(exports, "createComponents", {
+	enumerable: true,
+	get: function() {
+		return createComponents;
+	}
 });
-Object.defineProperty(exports, 'createPaths', {
-  enumerable: true,
-  get: function () {
-    return createPaths;
-  }
+Object.defineProperty(exports, "createPaths", {
+	enumerable: true,
+	get: function() {
+		return createPaths;
+	}
+});
+Object.defineProperty(exports, "createRegistry", {
+	enumerable: true,
+	get: function() {
+		return createRegistry;
+	}
 });
-Object.defineProperty(exports, 'createRegistry', {
-  enumerable: true,
-  get: function () {
-    return createRegistry;
-  }
+Object.defineProperty(exports, "createSchema", {
+	enumerable: true,
+	get: function() {
+		return createSchema;
+	}
 });
-Object.defineProperty(exports, 'createSchema', {
-  enumerable: true,
-  get: function () {
-    return createSchema;
-  }
+Object.defineProperty(exports, "isAnyZodType", {
+	enumerable: true,
+	get: function() {
+		return isAnyZodType;
+	}
 });
-Object.defineProperty(exports, 'isAnyZodType', {
-  enumerable: true,
-  get: function () {
-    return isAnyZodType;
-  }
+Object.defineProperty(exports, "unwrapZodObject", {
+	enumerable: true,
+	get: function() {
+		return unwrapZodObject;
+	}
 });
-Object.defineProperty(exports, 'unwrapZodObject', {
-  enumerable: true,
-  get: function () {
-    return unwrapZodObject;
-  }
-});