zod-openapi 5.0.0-beta.9 → 5.0.0

package/dist/components-CB3cj8u3.js

@@ -1,855 +0,0 @@
-//#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/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 (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 (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 (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$1, path) => {
-	const { parameters, requestParams, requestBody, responses, callbacks,...rest } = operationObject;
-	const operation = rest;
-	const maybeManualParameters = createManualParameters(parameters, {
-		registry: registry$1,
-		io: "input"
-	}, [...path, "parameters"]);
-	const maybeRequestParams = createParameters(requestParams, {
-		registry: registry$1,
-		io: "input"
-	}, [...path, "requestParams"]);
-	if (maybeRequestParams || maybeManualParameters) operation.parameters = [...maybeRequestParams ?? [], ...maybeManualParameters ?? []];
-	const maybeRequestBody = createRequestBody(requestBody, {
-		registry: registry$1,
-		io: "input"
-	}, [...path, "requestBody"]);
-	if (maybeRequestBody) operation.requestBody = maybeRequestBody;
-	const maybeResponses = createResponses(responses, {
-		registry: registry$1,
-		io: "output"
-	}, [...path, "responses"]);
-	if (maybeResponses) operation.responses = maybeResponses;
-	const maybeCallbacks = createCallbacks(callbacks, registry$1, [...path, "callbacks"]);
-	if (maybeCallbacks) operation.callbacks = maybeCallbacks;
-	return operation;
-};
-const createPathItem = (pathItem, registry$1, 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$1, [...path, key]);
-			continue;
-		}
-		if (key === "parameters") {
-			pathItemObject[key] = createManualParameters(value, {
-				registry: registry$1,
-				io: "input"
-			}, [...path, key]);
-			continue;
-		}
-		pathItemObject[key] = value;
-	}
-	if (id) {
-		const ref = { $ref: `#/components/pathItems/${id}` };
-		registry$1.pathItems.ids.set(id, pathItemObject);
-		registry$1.pathItems.seen.set(pathItem, ref);
-		return ref;
-	}
-	registry$1.pathItems.seen.set(pathItem, pathItemObject);
-	return pathItemObject;
-};
-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] = createPathItem(pathItemObject, registry$1, [...path, singlePath]);
-	}
-	return pathsObject;
-};
-
-//#endregion
-//#region src/create/callbacks.ts
-const createCallback = (callbackObject, registry$1, path) => {
-	const seenCallback = registry$1.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$1, [...path, name]);
-	}
-	if (id) {
-		const ref = { $ref: `#/components/callbacks/${id}` };
-		registry$1.callbacks.ids.set(id, callback);
-		registry$1.callbacks.seen.set(callbackObject, ref);
-		return ref;
-	}
-	registry$1.callbacks.seen.set(callbackObject, callback);
-	return callback;
-};
-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] = createCallback(value, registry$1, [...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();
-	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.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.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.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.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.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.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.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 = {
-		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$1.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()
-		}
-	};
-	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 (registry$1.schemas.ids.has(key)) throw new Error(`Schema "${key}" is already registered`);
-		if (isAnyZodType(schema)) {
-			const id = zod_v4_core.globalRegistry.get(schema)?.id ?? key;
-			registry$1.schemas.manual.set(id, {
-				input: { schemaObject: {} },
-				output: { schemaObject: {} },
-				zodType: schema
-			});
-			continue;
-		}
-		registry$1.schemas.ids.set(key, schema);
-	}
-};
-const registerParameters = (parameters, registry$1) => {
-	if (!parameters) return;
-	for (const [key, schema] of Object.entries(parameters)) {
-		if (registry$1.parameters.ids.has(key)) throw new Error(`Parameter "${key}" is already registered`);
-		if (isAnyZodType(schema)) {
-			const path = [
-				"components",
-				"parameters",
-				key
-			];
-			const paramObject = createParameter(schema, void 0, {
-				registry: registry$1,
-				io: "input"
-			}, path);
-			registry$1.parameters.ids.set(key, paramObject);
-			registry$1.parameters.seen.set(schema, paramObject);
-			continue;
-		}
-		registry$1.parameters.ids.set(key, schema);
-	}
-};
-const registerHeaders = (headers, registry$1) => {
-	if (!headers) return;
-	for (const [key, schema] of Object.entries(headers)) {
-		if (registry$1.headers.ids.has(key)) throw new Error(`Header "${key}" is already registered`);
-		if (isAnyZodType(schema)) {
-			const path = [
-				"components",
-				"headers",
-				key
-			];
-			const headerObject = createHeader(schema, {
-				registry: registry$1,
-				io: "output"
-			}, path);
-			registry$1.headers.ids.set(key, headerObject);
-			registry$1.headers.seen.set(schema, headerObject);
-			continue;
-		}
-		registry$1.headers.ids.set(key, schema);
-	}
-};
-const registerResponses = (responses, registry$1) => {
-	if (!responses) return;
-	for (const [key, schema] of Object.entries(responses)) {
-		const path = [
-			"components",
-			"responses",
-			key
-		];
-		if (registry$1.responses.ids.has(key)) throw new Error(`Response "${key}" is already registered`);
-		const responseObject = createResponse(schema, {
-			registry: registry$1,
-			io: "output"
-		}, path);
-		registry$1.responses.ids.set(key, responseObject);
-		registry$1.responses.seen.set(schema, responseObject);
-	}
-};
-const registerRequestBodies = (requestBodies, registry$1) => {
-	if (!requestBodies) return;
-	for (const [key, schema] of Object.entries(requestBodies)) {
-		if (registry$1.requestBodies.ids.has(key)) throw new Error(`RequestBody "${key}" is already registered`);
-		if (isAnyZodType(schema)) {
-			const path = [
-				"components",
-				"requestBodies",
-				key
-			];
-			const requestBodyObject = createRequestBody(schema, {
-				registry: registry$1,
-				io: "input"
-			}, path);
-			registry$1.requestBodies.ids.set(key, requestBodyObject);
-			continue;
-		}
-		registry$1.requestBodies.ids.set(key, schema);
-	}
-};
-const registerCallbacks = (callbacks, registry$1) => {
-	if (!callbacks) return;
-	for (const [key, schema] of Object.entries(callbacks)) {
-		if (registry$1.callbacks.ids.has(key)) throw new Error(`Callback "${key}" is already registered`);
-		const path = [
-			"components",
-			"callbacks",
-			key
-		];
-		const callbackObject = createCallback(schema, registry$1, path);
-		registry$1.callbacks.ids.set(key, callbackObject);
-		registry$1.callbacks.seen.set(schema, callbackObject);
-	}
-};
-const registerPathItems = (pathItems, registry$1) => {
-	if (!pathItems) return;
-	for (const [key, schema] of Object.entries(pathItems)) {
-		if (registry$1.pathItems.ids.has(key)) throw new Error(`PathItem "${key}" is already registered`);
-		const path = [
-			"components",
-			"pathItems",
-			key
-		];
-		const pathItemObject = createPathItem(schema, registry$1, path);
-		registry$1.pathItems.ids.set(key, pathItemObject);
-		registry$1.pathItems.seen.set(schema, pathItemObject);
-		continue;
-	}
-};
-const createIOSchemas = (ctx) => {
-	const { schemas, components, manual } = 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);
-	}
-	for (const [key, value] of Object.entries(manual)) {
-		const manualSchema = ctx.registry.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.schemas.manual) if (!value.input.used) {
-		const io = zod_v4_core.globalRegistry.get(value.zodType)?.unusedIO ?? "output";
-		const schema = value[io].schemaObject;
-		registry$1.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.schemas.ids.size > 0) components.schemas = Object.fromEntries(registry$1.schemas.ids);
-	if (registry$1.headers.ids.size > 0) components.headers = Object.fromEntries(registry$1.headers.ids);
-	if (registry$1.requestBodies.ids.size > 0) components.requestBodies = Object.fromEntries(registry$1.requestBodies.ids);
-	if (registry$1.responses.ids.size > 0) components.responses = Object.fromEntries(registry$1.responses.ids);
-	if (registry$1.parameters.ids.size > 0) components.parameters = Object.fromEntries(registry$1.parameters.ids);
-	if (registry$1.callbacks.ids.size > 0) components.callbacks = Object.fromEntries(registry$1.callbacks.ids);
-	if (registry$1.pathItems.ids.size > 0) components.pathItems = Object.fromEntries(registry$1.pathItems.ids);
-	return components;
-};
-
-//#endregion
-Object.defineProperty(exports, 'createComponents', {
-  enumerable: true,
-  get: function () {
-    return createComponents;
-  }
-});
-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, 'isAnyZodType', {
-  enumerable: true,
-  get: function () {
-    return isAnyZodType;
-  }
-});
-Object.defineProperty(exports, 'unwrapZodObject', {
-  enumerable: true,
-  get: function () {
-    return unwrapZodObject;
-  }
-});