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

package/dist/components-Cp63fKGN.js

@@ -0,0 +1,805 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+const zod_v4_core = __toESM(require("zod/v4/core"));
+const zod_v4 = __toESM(require("zod/v4"));
+
+//#region src/zod.ts
+const isAnyZodType = (schema) => typeof schema === "object" && schema !== null && "_zod" in schema;
+
+//#endregion
+//#region src/create/content.ts
+const createMediaTypeObject = (mediaTypeObject, ctx, path) => {
+	if (isAnyZodType(mediaTypeObject.schema)) {
+		const schemaObject = ctx.registry.addSchema(mediaTypeObject.schema, [...path, "schema"], { io: ctx.io });
+		return {
+			...mediaTypeObject,
+			schema: schemaObject
+		};
+	}
+	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) => {
+	const def = zodType._zod.def;
+	switch (def.type) {
+		case "object": return zodType;
+		case "lazy": return unwrapZodObject(def.getter(), io, path);
+		case "pipe": {
+			if (io === "input") return unwrapZodObject(def.in, io, path);
+			return unwrapZodObject(def.out, io, path);
+		}
+	}
+	throw new Error(`Failed to unwrap ZodObject from type: ${zodType._zod.def.type} at ${path.join(" > ")}`);
+};
+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) => {
+	if (!headers) return void 0;
+	if (isAnyZodType(headers)) {
+		const zodObject = unwrapZodObject(headers, "output", path);
+		const headersObject = {};
+		for (const [key, zodSchema] of Object.entries(zodObject._zod.def.shape)) {
+			const header = registry$1.addHeader(zodSchema, [...path, key]);
+			headersObject[key] = header;
+		}
+		return headersObject;
+	}
+	return headers;
+};
+
+//#endregion
+//#region src/create/parameters.ts
+const createManualParameters = (parameters, registry$1, path) => {
+	if (!parameters) return void 0;
+	const parameterObjects = [];
+	for (const parameter of parameters) {
+		if (isAnyZodType(parameter)) {
+			const paramObject = registry$1.addParameter(parameter, [...path, "parameters"]);
+			parameterObjects.push(paramObject);
+			continue;
+		}
+		parameterObjects.push(parameter);
+	}
+	return parameterObjects;
+};
+const createParameters = (requestParams, registry$1, path) => {
+	if (!requestParams) return void 0;
+	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, [
+				...path,
+				location,
+				name
+			], { location: {
+				in: location,
+				name
+			} });
+			parameterObjects.push(paramObject);
+		}
+	}
+	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) => {
+	if (!callbacks) return void 0;
+	const callbacksObject = {};
+	for (const [name, value] of Object.entries(callbacks)) {
+		if (isISpecificationExtension(name)) {
+			callbacksObject[name] = value;
+			continue;
+		}
+		callbacksObject[name] = registry$1.addCallback(value, [...path, name]);
+	}
+	return callbacksObject;
+};
+
+//#endregion
+//#region src/create/responses.ts
+const createResponses = (responses, registry$1, path) => {
+	if (!responses) return void 0;
+	const responsesObject = {};
+	for (const [statusCode, response] of Object.entries(responses)) {
+		if (!response) continue;
+		if (isISpecificationExtension(statusCode)) {
+			responsesObject[statusCode] = response;
+			continue;
+		}
+		if ("$ref" in response) {
+			responsesObject[statusCode] = response;
+			continue;
+		}
+		const responseObject = registry$1.addResponse(response, [...path, statusCode]);
+		responsesObject[statusCode] = responseObject;
+	}
+	return responsesObject;
+};
+
+//#endregion
+//#region src/create/paths.ts
+const createOperation = (operation, registry$1, 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"]);
+	if (maybeRequestParams || maybeManualParameters) operationObject.parameters = [...maybeRequestParams ?? [], ...maybeManualParameters ?? []];
+	const maybeRequestBody = requestBody && registry$1.addRequestBody(requestBody, path);
+	if (maybeRequestBody) operationObject.requestBody = maybeRequestBody;
+	const maybeResponses = createResponses(responses, registry$1, [...path, "responses"]);
+	if (maybeResponses) operationObject.responses = maybeResponses;
+	const maybeCallbacks = createCallbacks(callbacks, registry$1, [...path, "callbacks"]);
+	if (maybeCallbacks) operationObject.callbacks = maybeCallbacks;
+	return operationObject;
+};
+const createPaths = (paths, registry$1, path) => {
+	if (!paths) return void 0;
+	const pathsObject = {};
+	for (const [singlePath, pathItemObject] of Object.entries(paths)) {
+		if (isISpecificationExtension(singlePath)) {
+			pathsObject[singlePath] = pathItemObject;
+			continue;
+		}
+		pathsObject[singlePath] = registry$1.addPathItem(pathItemObject, [...path, singlePath]);
+	}
+	return pathsObject;
+};
+
+//#endregion
+//#region src/create/schema/override.ts
+const override = (ctx) => {
+	const def = ctx.zodSchema._zod.def;
+	switch (def.type) {
+		case "bigint": {
+			ctx.jsonSchema.type = "integer";
+			ctx.jsonSchema.format = "int64";
+			break;
+		}
+		case "union": {
+			if ("discriminator" in def && typeof def.discriminator === "string") {
+				ctx.jsonSchema.oneOf = ctx.jsonSchema.anyOf;
+				delete ctx.jsonSchema.anyOf;
+				ctx.jsonSchema.type = "object";
+				ctx.jsonSchema.discriminator = { propertyName: def.discriminator };
+				const mapping = {};
+				for (const [index, obj] of Object.entries(ctx.jsonSchema.oneOf)) {
+					const ref = obj.$ref;
+					if (!ref) return;
+					const discriminatorValues = def.options[Number(index)]._zod.propValues?.[def.discriminator];
+					if (!discriminatorValues?.size) return;
+					for (const value of [...discriminatorValues ?? []]) {
+						if (typeof value !== "string") return;
+						mapping[value] = ref;
+					}
+				}
+				ctx.jsonSchema.discriminator.mapping = mapping;
+			}
+			const meta = ctx.zodSchema.meta();
+			if (typeof meta?.unionOneOf === "boolean") {
+				if (meta.unionOneOf) {
+					ctx.jsonSchema.oneOf = ctx.jsonSchema.anyOf;
+					delete ctx.jsonSchema.anyOf;
+				}
+				delete ctx.jsonSchema.unionOneOf;
+			}
+			break;
+		}
+		case "date": {
+			ctx.jsonSchema.type = "string";
+			break;
+		}
+		case "literal": {
+			if (def.values.includes(void 0)) break;
+			break;
+		}
+	}
+};
+const validate = (ctx, opts) => {
+	if (Object.keys(ctx.jsonSchema).length) return;
+	const def = ctx.zodSchema._zod.def;
+	const allowEmptySchema = opts.allowEmptySchema?.[def.type];
+	if (allowEmptySchema === true || allowEmptySchema?.[ctx.io]) return;
+	switch (def.type) {
+		case "any": return;
+		case "unknown": return;
+		case "pipe": {
+			if (ctx.io === "output") throw new Error("Zod transform schemas are not supported in output schemas. Please use `.overwrite()` or wrap the schema in a `.pipe()`");
+			return;
+		}
+		case "transform": {
+			if (ctx.io === "output") return;
+			break;
+		}
+		case "literal": {
+			if (def.values.includes(void 0)) throw new Error("Zod literal schemas cannot include `undefined` as a value. Please use `z.undefined()` or `.optional()` instead.");
+			return;
+		}
+	}
+	throw new Error(`Zod schema of type \`${def.type}\` cannot be represented in OpenAPI. Please assign it metadata with \`.meta()\``);
+};
+
+//#endregion
+//#region src/create/schema/rename.ts
+const renameComponents = (components, outputIds, ctx) => {
+	const componentsToRename = /* @__PURE__ */ new Map();
+	if (ctx.io === "input") return componentsToRename;
+	const componentDependencies = /* @__PURE__ */ new Map();
+	const stringifiedComponents = /* @__PURE__ */ new Map();
+	for (const [key, value] of Object.entries(components)) {
+		const stringified = JSON.stringify(value);
+		const matches = stringified.matchAll(/"#\/components\/schemas\/([^"]+)"/g);
+		const dependencies = /* @__PURE__ */ new Set();
+		for (const match of matches) {
+			const dep = match[1];
+			if (dep !== key) dependencies.add(dep);
+		}
+		stringifiedComponents.set(key, stringified);
+		componentDependencies.set(key, { dependencies });
+	}
+	for (const [key] of stringifiedComponents) {
+		const registeredComponent = ctx.registry.components.schemas.ids.get(key);
+		if (!registeredComponent) continue;
+		if (isDependencyPure(componentDependencies, stringifiedComponents, ctx.registry, key)) continue;
+		const newName = outputIds.get(key) ?? `${key}Output`;
+		componentsToRename.set(key, newName);
+		components[newName] = components[key];
+		delete components[key];
+		continue;
+	}
+	return componentsToRename;
+};
+const isDependencyPure = (componentDependencies, stringifiedComponents, registry$1, 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);
+	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)));
+	dependencies.pure = result;
+	return result;
+};
+
+//#endregion
+//#region src/create/schema/schema.ts
+const deleteZodOpenApiMeta = (jsonSchema) => {
+	delete jsonSchema.param;
+	delete jsonSchema.header;
+	delete jsonSchema.unusedIO;
+	delete jsonSchema.override;
+	delete jsonSchema.outputId;
+};
+const createSchema = (schema, ctx = {
+	registry: createRegistry(),
+	io: "output",
+	opts: {}
+}) => {
+	ctx.registry ??= createRegistry();
+	ctx.opts ??= {};
+	ctx.io ??= "output";
+	const registrySchemas = Object.fromEntries(ctx.registry.components.schemas[ctx.io]);
+	const schemas = { zodOpenApiCreateSchema: { zodType: schema } };
+	Object.assign(schemas, registrySchemas);
+	const jsonSchemas = createSchemas(schemas, {
+		registry: ctx.registry,
+		io: ctx.io,
+		opts: ctx.opts
+	});
+	return {
+		schema: jsonSchemas.schemas.zodOpenApiCreateSchema,
+		components: jsonSchemas.components
+	};
+};
+const createSchemas = (schemas, ctx) => {
+	const entries = {};
+	for (const [name, { zodType }] of Object.entries(schemas)) entries[name] = zodType;
+	const zodRegistry = (0, zod_v4.registry)();
+	zodRegistry.add((0, zod_v4.object)(entries), { id: "zodOpenApiCreateSchema" });
+	for (const [id, { zodType }] of ctx.registry.components.schemas.manual) zodRegistry.add(zodType, { id });
+	const outputIds = /* @__PURE__ */ new Map();
+	const jsonSchema = (0, zod_v4.toJSONSchema)(zodRegistry, {
+		override(context) {
+			const meta = context.zodSchema.meta();
+			if (meta?.outputId && meta?.id) outputIds.set(meta.id, meta.outputId);
+			if (context.jsonSchema.$ref) return;
+			const enrichedContext = {
+				...context,
+				io: ctx.io
+			};
+			override(enrichedContext);
+			if (typeof ctx.opts.override === "function") ctx.opts.override(enrichedContext);
+			if (typeof meta?.override === "function") {
+				meta.override(enrichedContext);
+				delete context.jsonSchema.override;
+			}
+			if (typeof meta?.override === "object" && meta.override !== null) {
+				Object.assign(context.jsonSchema, meta.override);
+				delete context.jsonSchema.override;
+			}
+			delete context.jsonSchema.$schema;
+			delete context.jsonSchema.id;
+			deleteZodOpenApiMeta(context.jsonSchema);
+			validate(enrichedContext, ctx.opts);
+		},
+		io: ctx.io,
+		unrepresentable: "any",
+		reused: ctx.opts.reused,
+		cycles: ctx.opts.cycles,
+		uri: (id) => id === "__shared" ? `#ZOD_OPENAPI/${id}` : `#ZOD_OPENAPI/__shared#/$defs/${id}`
+	});
+	const components = jsonSchema.schemas.__shared?.$defs ?? {};
+	jsonSchema.schemas.__shared ??= { $defs: components };
+	const dynamicComponents = /* @__PURE__ */ new Map();
+	for (const [key, value] of Object.entries(components)) if (/^schema\d+$/.test(key)) {
+		const newName = `__schema${ctx.registry.components.schemas.dynamicSchemaCount++}`;
+		dynamicComponents.set(key, `"#/components/schemas/${newName}"`);
+		if (newName !== key) {
+			components[newName] = value;
+			delete components[key];
+		}
+	}
+	const manualUsed = {};
+	const parsedJsonSchema = JSON.parse(JSON.stringify(jsonSchema).replace(/"#ZOD_OPENAPI\/__shared#\/\$defs\/([^"]+)"/g, (_, match) => {
+		const dynamic = dynamicComponents.get(match);
+		if (dynamic) return dynamic;
+		const manualComponent = ctx.registry.components.schemas.manual.get(match);
+		if (manualComponent) manualUsed[match] = true;
+		return `"#/components/schemas/${match}"`;
+	}));
+	const parsedComponents = parsedJsonSchema.schemas.__shared?.$defs ?? {};
+	parsedJsonSchema.schemas.__shared ??= { $defs: parsedComponents };
+	for (const [key] of ctx.registry.components.schemas.manual) {
+		const manualComponent = parsedJsonSchema.schemas[key];
+		if (!manualComponent) continue;
+		delete manualComponent.$schema;
+		delete manualComponent.id;
+		if (manualUsed[key]) {
+			delete manualComponent.$schema;
+			delete manualComponent.id;
+			if (parsedComponents[key]) throw new Error(`Component "${key}" is already registered as a component in the registry`);
+			parsedComponents[key] = manualComponent;
+		}
+	}
+	const componentsToRename = renameComponents(parsedComponents, outputIds, ctx);
+	if (!componentsToRename.size) {
+		const parsedSchemas = parsedJsonSchema.schemas.zodOpenApiCreateSchema?.properties;
+		delete parsedJsonSchema.schemas.zodOpenApiCreateSchema;
+		delete parsedJsonSchema.schemas.__shared;
+		return {
+			schemas: parsedSchemas,
+			components: parsedComponents,
+			manual: parsedJsonSchema.schemas
+		};
+	}
+	const renamedJsonSchema = JSON.parse(JSON.stringify(parsedJsonSchema).replace(/"#\/components\/schemas\/([^"]+)"/g, (_, match) => {
+		const replacement = componentsToRename.get(match);
+		if (replacement) return `"#/components/schemas/${replacement}"`;
+		return `"#/components/schemas/${match}"`;
+	}));
+	const renamedSchemas = renamedJsonSchema.schemas.zodOpenApiCreateSchema?.properties;
+	const renamedComponents = renamedJsonSchema.schemas.__shared?.$defs ?? {};
+	delete renamedJsonSchema.schemas.zodOpenApiCreateSchema;
+	delete renamedJsonSchema.schemas.__shared;
+	return {
+		schemas: renamedSchemas,
+		components: renamedComponents,
+		manual: renamedJsonSchema.schemas
+	};
+};
+
+//#endregion
+//#region src/create/components.ts
+const createRegistry = (components) => {
+	const registry$1 = {
+		components: {
+			schemas: {
+				dynamicSchemaCount: 0,
+				input: /* @__PURE__ */ new Map(),
+				output: /* @__PURE__ */ new Map(),
+				ids: /* @__PURE__ */ new Map(),
+				manual: /* @__PURE__ */ new Map()
+			},
+			headers: {
+				ids: /* @__PURE__ */ new Map(),
+				seen: /* @__PURE__ */ new WeakMap()
+			},
+			requestBodies: {
+				ids: /* @__PURE__ */ new Map(),
+				seen: /* @__PURE__ */ new WeakMap()
+			},
+			responses: {
+				ids: /* @__PURE__ */ new Map(),
+				seen: /* @__PURE__ */ new WeakMap()
+			},
+			parameters: {
+				ids: /* @__PURE__ */ new Map(),
+				seen: /* @__PURE__ */ new WeakMap()
+			},
+			callbacks: {
+				ids: /* @__PURE__ */ new Map(),
+				seen: /* @__PURE__ */ new WeakMap()
+			},
+			pathItems: {
+				ids: /* @__PURE__ */ new Map(),
+				seen: /* @__PURE__ */ new WeakMap()
+			}
+		},
+		addSchema: (schema, path, opts) => {
+			const io = opts?.io ?? "output";
+			const schemaObject = {};
+			registry$1.components.schemas[io].set(path.join(" > "), {
+				schemaObject,
+				zodType: schema
+			});
+			return schemaObject;
+		},
+		addParameter: (parameter, path, opts) => {
+			const seenParameter = registry$1.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 (!name || !inLocation) throw new Error(`Parameter at ${path.join(" > ")} is missing \`.meta({ param: { name, in } })\` information`);
+			const schemaObject = registry$1.addSchema(parameter, [...path, "schema"], { io: "input" });
+			const { id: metaId,...rest } = meta?.param ?? {};
+			const parameterObject = {
+				...rest,
+				name,
+				in: inLocation,
+				schema: schemaObject
+			};
+			if (isRequired(parameter, "input")) parameterObject.required = true;
+			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}" 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);
+				return ref;
+			}
+			registry$1.components.parameters.seen.set(parameter, parameterObject);
+			return parameterObject;
+		},
+		addHeader: (header, path, opts) => {
+			const seenHeader = registry$1.components.headers.seen.get(header);
+			if (seenHeader) return seenHeader;
+			const meta = zod_v4_core.globalRegistry.get(header);
+			const { id: metaId,...rest } = meta?.header ?? {};
+			const id = metaId ?? opts?.manualId;
+			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"], { io: "output" });
+			if (id) {
+				if (registry$1.components.schemas.ids.has(id)) throw new Error(`Schema "${id}" 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);
+				return ref;
+			}
+			registry$1.components.headers.seen.set(header, headerObject);
+			return headerObject;
+		},
+		addRequestBody: (requestBody, path, opts) => {
+			const seenRequestBody = registry$1.components.requestBodies.seen.get(requestBody);
+			if (seenRequestBody) return seenRequestBody;
+			const { content, id: metaId,...rest } = requestBody;
+			const requestBodyObject = {
+				...rest,
+				content: createContent(content, {
+					registry: registry$1,
+					io: "input"
+				}, [...path, "content"])
+			};
+			const id = metaId ?? opts?.manualId;
+			if (id) {
+				if (registry$1.components.requestBodies.ids.has(id)) throw new Error(`RequestBody "${id}" 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);
+				return ref;
+			}
+			registry$1.components.requestBodies.seen.set(requestBody, requestBodyObject);
+			return requestBodyObject;
+		},
+		addPathItem: (pathItem, path, opts) => {
+			const seenPathItem = registry$1.components.pathItems.seen.get(pathItem);
+			if (seenPathItem) return seenPathItem;
+			const pathItemObject = {};
+			const { id: metaId,...rest } = pathItem;
+			const id = metaId ?? opts?.manualId;
+			for (const [key, value] of Object.entries(rest)) {
+				if (isISpecificationExtension(key)) {
+					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]);
+					continue;
+				}
+				if (key === "parameters") {
+					pathItemObject[key] = createManualParameters(value, registry$1, [...path, key]);
+					continue;
+				}
+				pathItemObject[key] = value;
+			}
+			if (id) {
+				if (registry$1.components.pathItems.ids.has(id)) throw new Error(`PathItem "${id}" 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);
+				return ref;
+			}
+			registry$1.components.pathItems.seen.set(pathItem, pathItemObject);
+			return pathItemObject;
+		},
+		addResponse: (response, path, opts) => {
+			const seenResponse = registry$1.components.responses.seen.get(response);
+			if (seenResponse) return seenResponse;
+			const { content, headers, id: metaId,...rest } = response;
+			const responseObject = rest;
+			const maybeHeaders = createHeaders(headers, registry$1, [...path, "headers"]);
+			if (maybeHeaders) responseObject.headers = maybeHeaders;
+			if (content) responseObject.content = createContent(content, {
+				registry: registry$1,
+				io: "output"
+			}, [...path, "content"]);
+			const id = metaId ?? opts?.manualId;
+			if (id) {
+				if (registry$1.components.responses.ids.has(id)) throw new Error(`Response "${id}" 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);
+				return ref;
+			}
+			registry$1.components.responses.seen.set(response, responseObject);
+			return responseObject;
+		},
+		addCallback: (callback, path, opts) => {
+			const seenCallback = registry$1.components.callbacks.seen.get(callback);
+			if (seenCallback) return seenCallback;
+			const { id: metaId,...rest } = callback;
+			const callbackObject = {};
+			for (const [name, pathItem] of Object.entries(rest)) {
+				if (isISpecificationExtension(name)) {
+					callbackObject[name] = pathItem;
+					continue;
+				}
+				callbackObject[name] = registry$1.addPathItem(pathItem, [...path, name]);
+			}
+			const id = metaId ?? opts?.manualId;
+			if (id) {
+				if (registry$1.components.callbacks.ids.has(id)) throw new Error(`Callback "${id}" 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);
+				return ref;
+			}
+			registry$1.components.callbacks.seen.set(callback, callbackObject);
+			return callbackObject;
+		}
+	};
+	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);
+	return registry$1;
+};
+const registerSchemas = (schemas, registry$1) => {
+	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, {
+				input: { schemaObject: {} },
+				output: { schemaObject: {} },
+				zodType: schema
+			});
+			continue;
+		}
+		registry$1.components.schemas.ids.set(key, schema);
+	}
+};
+const registerParameters = (parameters, registry$1) => {
+	if (!parameters) return;
+	for (const [key, schema] of Object.entries(parameters)) {
+		if (isAnyZodType(schema)) {
+			const path = [
+				"components",
+				"parameters",
+				key
+			];
+			registry$1.addParameter(schema, path, { manualId: key });
+			continue;
+		}
+		registry$1.components.parameters.ids.set(key, schema);
+	}
+};
+const registerHeaders = (headers, registry$1) => {
+	if (!headers) return;
+	for (const [key, schema] of Object.entries(headers)) {
+		if (isAnyZodType(schema)) {
+			const path = [
+				"components",
+				"headers",
+				key
+			];
+			registry$1.addHeader(schema, path, { manualId: key });
+			continue;
+		}
+		registry$1.components.headers.ids.set(key, schema);
+	}
+};
+const registerResponses = (responses, registry$1) => {
+	if (!responses) return;
+	for (const [key, schema] of Object.entries(responses)) {
+		const responseObject = registry$1.addResponse(schema, [
+			"components",
+			"responses",
+			key
+		], { manualId: key });
+		registry$1.components.responses.ids.set(key, responseObject);
+		registry$1.components.responses.seen.set(schema, responseObject);
+	}
+};
+const registerRequestBodies = (requestBodies, registry$1) => {
+	if (!requestBodies) return;
+	for (const [key, schema] of Object.entries(requestBodies)) {
+		if (isAnyZodType(schema)) {
+			registry$1.addRequestBody(schema, [
+				"components",
+				"requestBodies",
+				key
+			], { manualId: key });
+			continue;
+		}
+		registry$1.components.requestBodies.ids.set(key, schema);
+	}
+};
+const registerCallbacks = (callbacks, registry$1) => {
+	if (!callbacks) return;
+	for (const [key, schema] of Object.entries(callbacks)) registry$1.addCallback(schema, [
+		"components",
+		"callbacks",
+		key
+	], { manualId: key });
+};
+const registerPathItems = (pathItems, registry$1) => {
+	if (!pathItems) return;
+	for (const [key, schema] of Object.entries(pathItems)) registry$1.addPathItem(schema, [
+		"components",
+		"pathItems",
+		key
+	], { manualId: key });
+};
+const createIOSchemas = (ctx) => {
+	const { schemas, components, manual } = createSchemas(Object.fromEntries(ctx.registry.components.schemas[ctx.io]), ctx);
+	for (const [key, schema] of Object.entries(components)) {
+		if (ctx.registry.components.schemas.ids.has(key)) throw new Error(`Schema "${key}" is already registered`);
+		ctx.registry.components.schemas.ids.set(key, schema);
+	}
+	for (const [key, schema] of Object.entries(schemas)) {
+		const ioSchema = ctx.registry.components.schemas[ctx.io].get(key);
+		if (ioSchema) Object.assign(ioSchema.schemaObject, schema);
+	}
+	for (const [key, value] of Object.entries(manual)) {
+		const manualSchema = ctx.registry.components.schemas.manual.get(key);
+		if (!manualSchema) continue;
+		if (components[key]) manualSchema[ctx.io].used = true;
+		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 io = zod_v4_core.globalRegistry.get(value.zodType)?.unusedIO ?? "output";
+		const schema = value[io].schemaObject;
+		registry$1.components.schemas.ids.set(key, schema);
+	}
+};
+const createComponents = (registry$1, opts) => {
+	createIOSchemas({
+		registry: registry$1,
+		io: "input",
+		opts
+	});
+	createIOSchemas({
+		registry: registry$1,
+		io: "output",
+		opts
+	});
+	createManualSchemas(registry$1);
+	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);
+	return components;
+};
+
+//#endregion
+Object.defineProperty(exports, 'createComponents', {
+  enumerable: true,
+  get: function () {
+    return createComponents;
+  }
+});
+Object.defineProperty(exports, 'createPaths', {
+  enumerable: true,
+  get: function () {
+    return createPaths;
+  }
+});
+Object.defineProperty(exports, 'createRegistry', {
+  enumerable: true,
+  get: function () {
+    return createRegistry;
+  }
+});
+Object.defineProperty(exports, 'createSchema', {
+  enumerable: true,
+  get: function () {
+    return createSchema;
+  }
+});
+Object.defineProperty(exports, 'isAnyZodType', {
+  enumerable: true,
+  get: function () {
+    return isAnyZodType;
+  }
+});
+Object.defineProperty(exports, 'unwrapZodObject', {
+  enumerable: true,
+  get: function () {
+    return unwrapZodObject;
+  }
+});