zod-openapi 5.0.0-beta.20 → 5.0.0-beta.4

package/dist/components-CXjVnBr-.js

@@ -0,0 +1,782 @@
+const require_zod = require('./zod-i2t01GF0.js');
+const zod_v4_core = require_zod.__toESM(require("zod/v4/core"));
+const zod_v4 = require_zod.__toESM(require("zod/v4"));
+const src_create_componentsSideEffects = require_zod.__toESM(require("./create/componentsSideEffects"));
+
+//#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/parameters.ts
+const createParameter = (parameter, location, ctx, path) => {
+	const seenParameter = ctx.registry.parameters.seen.get(parameter);
+	if (seenParameter) return seenParameter;
+	const meta = zod_v4.globalRegistry.get(parameter);
+	const name = location?.name ?? meta?.param?.name;
+	const inLocation = location?.in ?? meta?.param?.in;
+	if (!name || !inLocation) throw new Error(`Parameter at ${path.join(" > ")} is missing \`.meta({ param: { name, in } })\` information`);
+	const computedPath = [
+		...path,
+		inLocation,
+		name
+	].join(" > ");
+	const schemaObject = ctx.registry.schemas.setSchema(computedPath, parameter, ctx.io);
+	const { id,...rest } = meta?.param ?? {};
+	const parameterObject = {
+		...rest,
+		name,
+		in: inLocation,
+		schema: schemaObject
+	};
+	if (isRequired(parameter, ctx.io)) parameterObject.required = true;
+	if (!parameterObject.description && meta?.description) parameterObject.description = meta.description;
+	if (id) {
+		const ref = { $ref: `#/components/parameters/${id}` };
+		ctx.registry.parameters.seen.set(parameter, ref);
+		ctx.registry.parameters.ids.set(id, parameterObject);
+		return ref;
+	}
+	ctx.registry.parameters.seen.set(parameter, parameterObject);
+	return parameterObject;
+};
+const createManualParameters = (parameters, ctx, path) => {
+	if (!parameters) return void 0;
+	const parameterObjects = [];
+	for (const parameter of parameters) {
+		if (require_zod.isAnyZodType(parameter)) {
+			const seenParameter = ctx.registry.parameters.seen.get(parameter);
+			if (seenParameter) {
+				parameterObjects.push(seenParameter);
+				continue;
+			}
+			const paramObject = createParameter(parameter, void 0, ctx, [...path, "parameters"]);
+			parameterObjects.push(paramObject);
+			continue;
+		}
+		parameterObjects.push(parameter);
+	}
+	return parameterObjects;
+};
+const createParameters = (requestParams, ctx, path) => {
+	if (!requestParams) return void 0;
+	const parameterObjects = [];
+	for (const [location, schema] of Object.entries(requestParams ?? {})) {
+		if (!schema) continue;
+		const zodObject = unwrapZodObject(schema, ctx.io, path);
+		for (const [name, zodSchema] of Object.entries(zodObject._zod.def.shape)) {
+			const seenParameter = ctx.registry.parameters.seen.get(zodSchema);
+			if (seenParameter) {
+				parameterObjects.push(seenParameter);
+				continue;
+			}
+			const paramObject = createParameter(zodSchema, {
+				in: location,
+				name
+			}, ctx, [
+				...path,
+				location,
+				name
+			]);
+			parameterObjects.push(paramObject);
+		}
+	}
+	return parameterObjects;
+};
+
+//#endregion
+//#region src/create/content.ts
+const createMediaTypeObject = (mediaTypeObject, ctx, path) => {
+	const computedPath = path.join(" > ");
+	if (require_zod.isAnyZodType(mediaTypeObject.schema)) {
+		const schemaObject = ctx.registry.schemas.setSchema(computedPath, mediaTypeObject.schema, 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/requestBody.ts
+const createRequestBody = (requestBody, ctx, path) => {
+	if (!requestBody) return void 0;
+	const seenRequestBody = ctx.registry.requestBodies.seen.get(requestBody);
+	if (seenRequestBody) return seenRequestBody;
+	const { content, id,...rest } = requestBody;
+	const requestBodyObject = {
+		...rest,
+		content: createContent(content, ctx, [...path, "content"])
+	};
+	if (id) {
+		const ref = { $ref: `#/components/requestBodies/${id}` };
+		ctx.registry.requestBodies.ids.set(id, requestBodyObject);
+		ctx.registry.requestBodies.seen.set(requestBody, ref);
+		return ref;
+	}
+	ctx.registry.requestBodies.seen.set(requestBody, requestBodyObject);
+	return requestBodyObject;
+};
+
+//#endregion
+//#region src/create/headers.ts
+const createHeader = (header, ctx, path) => {
+	const seenHeader = ctx.registry.headers.seen.get(header);
+	if (seenHeader) return seenHeader;
+	const meta = zod_v4.globalRegistry.get(header);
+	const { id,...rest } = meta?.header ?? {};
+	const headerObject = rest;
+	if (isRequired(header, ctx.io)) headerObject.required = true;
+	if (!headerObject.description && meta?.description) headerObject.description = meta.description;
+	const computedPath = path.join(" > ");
+	headerObject.schema = ctx.registry.schemas.setSchema(computedPath, header, ctx.io);
+	if (id) {
+		const ref = { $ref: `#/components/headers/${id}` };
+		ctx.registry.headers.ids.set(id, headerObject);
+		ctx.registry.headers.seen.set(header, ref);
+		return ref;
+	}
+	ctx.registry.headers.seen.set(header, headerObject);
+	return headerObject;
+};
+const createHeaders = (headers, ctx, path) => {
+	if (!headers) return void 0;
+	if (require_zod.isAnyZodType(headers)) {
+		const zodObject = unwrapZodObject(headers, ctx.io, path);
+		const headersObject = {};
+		for (const [key, zodSchema] of Object.entries(zodObject._zod.def.shape)) {
+			const header = createHeader(zodSchema, ctx, [...path, key]);
+			headersObject[key] = header;
+		}
+		return headersObject;
+	}
+	return headers;
+};
+
+//#endregion
+//#region src/create/specificationExtension.ts
+const isISpecificationExtension = (key) => key.startsWith("x-");
+
+//#endregion
+//#region src/create/responses.ts
+const createResponse = (response, ctx, path) => {
+	const seenResponse = ctx.registry.responses.seen.get(response);
+	if (seenResponse) return seenResponse;
+	const { content, headers, id,...rest } = response;
+	const responseObject = rest;
+	const maybeHeaders = createHeaders(headers, ctx, [...path, "headers"]);
+	if (maybeHeaders) responseObject.headers = maybeHeaders;
+	if (content) responseObject.content = createContent(content, ctx, [...path, "content"]);
+	if (id) {
+		const ref = { $ref: `#/components/responses/${id}` };
+		ctx.registry.responses.ids.set(id, responseObject);
+		ctx.registry.responses.seen.set(response, ref);
+		return ref;
+	}
+	ctx.registry.responses.seen.set(response, responseObject);
+	return responseObject;
+};
+const createResponses = (responses, ctx, 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 = createResponse(response, ctx, [...path, statusCode]);
+		responsesObject[statusCode] = responseObject;
+	}
+	return responsesObject;
+};
+
+//#endregion
+//#region src/create/paths.ts
+const createOperation = (operationObject, registry, path) => {
+	const { parameters, requestParams, requestBody, responses, callbacks,...rest } = operationObject;
+	const operation = rest;
+	const maybeManualParameters = createManualParameters(parameters, {
+		registry,
+		io: "input"
+	}, [...path, "parameters"]);
+	const maybeRequestParams = createParameters(requestParams, {
+		registry,
+		io: "input"
+	}, [...path, "requestParams"]);
+	if (maybeRequestParams || maybeManualParameters) operation.parameters = [...maybeRequestParams ?? [], ...maybeManualParameters ?? []];
+	const maybeRequestBody = createRequestBody(requestBody, {
+		registry,
+		io: "input"
+	}, [...path, "requestBody"]);
+	if (maybeRequestBody) operation.requestBody = maybeRequestBody;
+	const maybeResponses = createResponses(responses, {
+		registry,
+		io: "output"
+	}, [...path, "responses"]);
+	if (maybeResponses) operation.responses = maybeResponses;
+	const maybeCallbacks = createCallbacks(callbacks, registry, [...path, "callbacks"]);
+	if (maybeCallbacks) operation.callbacks = maybeCallbacks;
+	return operation;
+};
+const createPathItem = (pathItem, registry, path) => {
+	const pathItemObject = {};
+	const { id,...rest } = pathItem;
+	for (const [key, value] of Object.entries(rest)) {
+		if (key === "get" || key === "put" || key === "post" || key === "delete" || key === "options" || key === "head" || key === "patch" || key === "trace") {
+			pathItemObject[key] = createOperation(value, registry, [...path, key]);
+			continue;
+		}
+		if (key === "parameters") {
+			pathItemObject[key] = createManualParameters(value, {
+				registry,
+				io: "input"
+			}, [...path, key]);
+			continue;
+		}
+		pathItemObject[key] = value;
+	}
+	if (id) {
+		const ref = { $ref: `#/components/pathItems/${id}` };
+		registry.pathItems.ids.set(id, pathItemObject);
+		registry.pathItems.seen.set(pathItem, ref);
+		return ref;
+	}
+	registry.pathItems.seen.set(pathItem, pathItemObject);
+	return pathItemObject;
+};
+const createPaths = (paths, registry, 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] = createPathItem(pathItemObject, registry, [...path, singlePath]);
+	}
+	return pathsObject;
+};
+
+//#endregion
+//#region src/create/callbacks.ts
+const createCallback = (callbackObject, registry, path) => {
+	const seenCallback = registry.callbacks.seen.get(callbackObject);
+	if (seenCallback) return seenCallback;
+	const { id,...rest } = callbackObject;
+	const callback = {};
+	for (const [name, pathItem] of Object.entries(rest)) {
+		if (isISpecificationExtension(name)) {
+			callback[name] = pathItem;
+			continue;
+		}
+		callback[name] = createPathItem(pathItem, registry, [...path, name]);
+	}
+	if (id) {
+		const ref = { $ref: `#/components/callbacks/${id}` };
+		registry.callbacks.ids.set(id, callback);
+		registry.callbacks.seen.set(callbackObject, ref);
+		return ref;
+	}
+	registry.callbacks.seen.set(callbackObject, callback);
+	return callback;
+};
+const createCallbacks = (callbacks, registry, 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] = createCallback(value, registry, [...path, name]);
+	}
+	return callbacksObject;
+};
+
+//#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();
+	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.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, 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.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, 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.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 schemaRegistry = (0, zod_v4.object)(entries);
+	const outputIds = /* @__PURE__ */ new Map();
+	const jsonSchema = (0, zod_v4.toJSONSchema)(schemaRegistry, {
+		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
+	});
+	const components = jsonSchema.$defs ?? {};
+	const dynamicComponents = /* @__PURE__ */ new Map();
+	for (const [key, value] of Object.entries(components)) if (/^__schema\d+$/.test(key)) {
+		const newName = `__schema${ctx.registry.schemas.dynamicSchemaCount++}`;
+		dynamicComponents.set(key, `"#/components/schemas/${newName}"`);
+		if (newName !== key) {
+			components[newName] = value;
+			delete components[key];
+		}
+	}
+	const parsedJsonSchema = JSON.parse(JSON.stringify(jsonSchema).replace(/"#\/\$defs\/([^"]+)"/g, (_, match) => {
+		const dynamic = dynamicComponents.get(match);
+		if (dynamic) return dynamic;
+		const manualComponent = ctx.registry.schemas.manual.get(match);
+		if (manualComponent) manualComponent.io[ctx.io].used++;
+		return `"#/components/schemas/${match}"`;
+	}));
+	for (const [key, value] of ctx.registry.schemas.manual) if (value.io[ctx.io].used === 1 && parsedJsonSchema.properties?.[value.identifier] && parsedJsonSchema.$defs?.[key]) {
+		parsedJsonSchema.properties[value.identifier] = parsedJsonSchema.$defs[key];
+		delete parsedJsonSchema.$defs[key];
+		continue;
+	}
+	const renamedComponents = renameComponents(parsedJsonSchema.$defs ?? {}, outputIds, ctx);
+	if (!renamedComponents.size) return {
+		schemas: parsedJsonSchema.properties,
+		components: parsedJsonSchema.$defs ?? {}
+	};
+	const renamedJsonSchema = JSON.parse(JSON.stringify(parsedJsonSchema).replace(/"#\/components\/schemas\/([^"]+)"/g, (_, match) => {
+		const replacement = renamedComponents.get(match);
+		if (replacement) return `"#/components/schemas/${replacement}"`;
+		return `"#/components/schemas/${match}"`;
+	}));
+	return {
+		schemas: renamedJsonSchema.properties,
+		components: renamedJsonSchema.$defs ?? {}
+	};
+};
+
+//#endregion
+//#region src/create/components.ts
+const createRegistry = (components) => {
+	const registry = {
+		schemas: {
+			dynamicSchemaCount: 0,
+			input: /* @__PURE__ */ new Map(),
+			output: /* @__PURE__ */ new Map(),
+			ids: /* @__PURE__ */ new Map(),
+			manual: /* @__PURE__ */ new Map(),
+			setSchema: (key, schema, io) => {
+				const schemaObject = {};
+				registry.schemas[io].set(key, {
+					schemaObject,
+					zodType: schema
+				});
+				return schemaObject;
+			}
+		},
+		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()
+		}
+	};
+	(0, src_create_componentsSideEffects.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);
+	return registry;
+};
+const registerParameters = (parameters, registry) => {
+	if (!parameters) return;
+	for (const [key, schema] of Object.entries(parameters)) {
+		if (registry.parameters.ids.has(key)) throw new Error(`Parameter "${key}" is already registered`);
+		if (require_zod.isAnyZodType(schema)) {
+			const path = [
+				"components",
+				"parameters",
+				key
+			];
+			const paramObject = createParameter(schema, void 0, {
+				registry,
+				io: "input"
+			}, path);
+			registry.parameters.ids.set(key, paramObject);
+			registry.parameters.seen.set(schema, paramObject);
+			continue;
+		}
+		registry.parameters.ids.set(key, schema);
+	}
+};
+const registerHeaders = (headers, registry) => {
+	if (!headers) return;
+	for (const [key, schema] of Object.entries(headers)) {
+		if (registry.headers.ids.has(key)) throw new Error(`Header "${key}" is already registered`);
+		if (require_zod.isAnyZodType(schema)) {
+			const path = [
+				"components",
+				"headers",
+				key
+			];
+			const headerObject = createHeader(schema, {
+				registry,
+				io: "output"
+			}, path);
+			registry.headers.ids.set(key, headerObject);
+			registry.headers.seen.set(schema, headerObject);
+			continue;
+		}
+		registry.headers.ids.set(key, schema);
+	}
+};
+const registerResponses = (responses, registry) => {
+	if (!responses) return;
+	for (const [key, schema] of Object.entries(responses)) {
+		const path = [
+			"components",
+			"responses",
+			key
+		];
+		if (registry.responses.ids.has(key)) throw new Error(`Response "${key}" is already registered`);
+		const responseObject = createResponse(schema, {
+			registry,
+			io: "output"
+		}, path);
+		registry.responses.ids.set(key, responseObject);
+		registry.responses.seen.set(schema, responseObject);
+	}
+};
+const registerRequestBodies = (requestBodies, registry) => {
+	if (!requestBodies) return;
+	for (const [key, schema] of Object.entries(requestBodies)) {
+		if (registry.requestBodies.ids.has(key)) throw new Error(`RequestBody "${key}" is already registered`);
+		if (require_zod.isAnyZodType(schema)) {
+			const path = [
+				"components",
+				"requestBodies",
+				key
+			];
+			const requestBodyObject = createRequestBody(schema, {
+				registry,
+				io: "input"
+			}, path);
+			registry.requestBodies.ids.set(key, requestBodyObject);
+			continue;
+		}
+		registry.requestBodies.ids.set(key, schema);
+	}
+};
+const registerCallbacks = (callbacks, registry) => {
+	if (!callbacks) return;
+	for (const [key, schema] of Object.entries(callbacks)) {
+		if (registry.callbacks.ids.has(key)) throw new Error(`Callback "${key}" is already registered`);
+		const path = [
+			"components",
+			"callbacks",
+			key
+		];
+		const callbackObject = createCallback(schema, registry, path);
+		registry.callbacks.ids.set(key, callbackObject);
+		registry.callbacks.seen.set(schema, callbackObject);
+	}
+};
+const registerPathItems = (pathItems, registry) => {
+	if (!pathItems) return;
+	for (const [key, schema] of Object.entries(pathItems)) {
+		if (registry.pathItems.ids.has(key)) throw new Error(`PathItem "${key}" is already registered`);
+		const path = [
+			"components",
+			"pathItems",
+			key
+		];
+		const pathItemObject = createPathItem(schema, registry, path);
+		registry.pathItems.ids.set(key, pathItemObject);
+		registry.pathItems.seen.set(schema, pathItemObject);
+		continue;
+	}
+};
+const createIOSchemas = (ctx) => {
+	const { schemas, components } = createSchemas(Object.fromEntries(ctx.registry.schemas[ctx.io]), ctx);
+	for (const [key, schema] of Object.entries(components)) ctx.registry.schemas.ids.set(key, schema);
+	for (const [key, schema] of Object.entries(schemas)) {
+		const ioSchema = ctx.registry.schemas[ctx.io].get(key);
+		if (ioSchema) Object.assign(ioSchema.schemaObject, schema);
+	}
+};
+const createManualSchemas = (registry) => {
+	for (const [key, value] of registry.schemas.manual) if (value.io.input.used === 1) {
+		const io = zod_v4_core.globalRegistry.get(value.zodType)?.unusedIO ?? "output";
+		const schema = value.io[io].schemaObject;
+		registry.schemas.ids.set(key, schema);
+	}
+};
+const createComponents = (registry, opts) => {
+	createIOSchemas({
+		registry,
+		io: "input",
+		opts
+	});
+	createIOSchemas({
+		registry,
+		io: "output",
+		opts
+	});
+	createManualSchemas(registry);
+	const components = {};
+	if (registry.schemas.ids.size > 0) components.schemas = Object.fromEntries(registry.schemas.ids);
+	if (registry.headers.ids.size > 0) components.headers = Object.fromEntries(registry.headers.ids);
+	if (registry.requestBodies.ids.size > 0) components.requestBodies = Object.fromEntries(registry.requestBodies.ids);
+	if (registry.responses.ids.size > 0) components.responses = Object.fromEntries(registry.responses.ids);
+	if (registry.parameters.ids.size > 0) components.parameters = Object.fromEntries(registry.parameters.ids);
+	if (registry.callbacks.ids.size > 0) components.callbacks = Object.fromEntries(registry.callbacks.ids);
+	if (registry.pathItems.ids.size > 0) components.pathItems = Object.fromEntries(registry.pathItems.ids);
+	return components;
+};
+
+//#endregion
+Object.defineProperty(exports, 'createComponents', {
+  enumerable: true,
+  get: function () {
+    return createComponents;
+  }
+});
+Object.defineProperty(exports, 'createMediaTypeObject', {
+  enumerable: true,
+  get: function () {
+    return createMediaTypeObject;
+  }
+});
+Object.defineProperty(exports, 'createParameter', {
+  enumerable: true,
+  get: function () {
+    return createParameter;
+  }
+});
+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, 'unwrapZodObject', {
+  enumerable: true,
+  get: function () {
+    return unwrapZodObject;
+  }
+});