@povio/openapi-codegen-cli 3.3.0-rc.1 → 4.0.0-rc.1

package/dist/getDataFromOpenAPIDoc-fJCwtr-2.mjs

@@ -0,0 +1,2016 @@
+import { $t as isPrimitiveType, Bn as getMostCommonAdjacentCombinationSplit, Ct as getParamZodSchemaName, Et as getZodSchemaOperationName, Fn as isTagIncluded, Gt as getParameterEnumNames, Hn as removeWord, Ht as getNamespaceName, Jt as isErrorStatus, Kt as getSchemaNameByRef, Mn as formatTag, Nn as getEndpointTag, On as BODY_PARAMETER_NAME, Ot as isNamedZodSchema, Pn as getOperationTag, Qt as isPathExcluded, Rn as capitalize, Sn as VOID_SCHEMA, St as getEnumZodSchemaName, Tt as getZodSchemaName, Un as snakeToCamel, Ut as autocorrectRef, Wn as Profiler, Wt as escapeControlCharacters, Xt as isMediaTypeAllowed, Yt as isMainResponseStatus, Zt as isParamMediaTypeAllowed, _n as INT_SCHEMA, an as wrapWithQuotesIfNeeded, bn as URL_SCHEMA, bt as invalidVariableNameCharactersToCamel, cn as isReferenceObject, d as isQuery, dn as ALLOWED_PATH_IN, en as isSortingParameterObject, fn as ANY_SCHEMA, gn as ENUM_SCHEMA, hn as EMAIL_SCHEMA, in as unwrapQuotesIfNeeded, kn as JSON_APPLICATION_FORMAT, ln as isSchemaObject, lt as iterateSchema, mn as DATETIME_SCHEMA, nn as pathToVariableName, on as inferRequiredSchema, pn as BLOB_SCHEMA, qt as getSchemaRef, rn as replaceHyphenatedPath, s as pick, sn as isArraySchemaObject, tn as pathParamToVariableName, un as ALLOWED_METHODS, ut as getUniqueArray, vn as NUMBER_SCHEMA, wt as getResponseZodSchemaName, xn as UUID_SCHEMA, xt as getBodyZodSchemaName, yn as STRING_SCHEMA, zn as decapitalize } from "./generate.runner-BtPpBVj9.mjs";
+//#region src/generators/const/validation.const.ts
+const HTTP_STATUS_CODES = {
+	"100": "Continue",
+	"101": "Switching Protocols",
+	"102": "Processing",
+	"103": "Early Hints",
+	"200": "OK",
+	"201": "Created",
+	"202": "Accepted",
+	"203": "Non-Authoritative Information",
+	"204": "No Content",
+	"205": "Reset Content",
+	"206": "Partial Content",
+	"300": "Ambiguous",
+	"301": "Moved Permanently",
+	"302": "Found",
+	"303": "See Other",
+	"304": "Not Modified",
+	"307": "Temporary Redirect",
+	"308": "Permanent Redirect",
+	"400": "Bad Request",
+	"401": "Unauthorized",
+	"402": "Payment Required",
+	"403": "Forbidden",
+	"404": "Not Found",
+	"405": "Method Not Allowed",
+	"406": "Not Acceptable",
+	"407": "Proxy Authentication Required",
+	"408": "Request Timeout",
+	"409": "Conflict",
+	"410": "Gone",
+	"411": "Length Required",
+	"412": "Precondition Failed",
+	"413": "Payload Too Large",
+	"414": "URI Too Long",
+	"415": "Unsupported Media Type",
+	"416": "Requested Range Not Satisfiable",
+	"417": "Expectation Failed",
+	"418": "I Am a Teapot",
+	"421": "Misdirected Request",
+	"422": "Unprocessable Entity",
+	"424": "Failed Dependency",
+	"428": "Precondition Required",
+	"429": "Too Many Requests",
+	"500": "Internal Server Error",
+	"501": "Not Implemented",
+	"502": "Bad Gateway",
+	"503": "Service Unavailable",
+	"504": "Gateway Timeout",
+	"505": "HTTP Version Not Supported"
+};
+const VALIDATION_ERROR_TYPE_TITLE = {
+	"invalid-schema": "Invalid OpenAPI Schemas",
+	"invalid-operation-id": "Invalid Operation IDs",
+	"missing-path-parameter": "Missing Path Parameters",
+	"not-allowed-inline-enum": "Not Allowed Inline Enums",
+	"not-allowed-circular-schema": "Not Allowed Circular Schemas",
+	"missing-acl-condition-property": "Missing x-acl Condition Properties",
+	"missing-status-code": "Missing HTTP Status Codes",
+	"invalid-status-code": "Invalid HTTP Status Codes",
+	"multiple-success-status-codes": "Multiple Success HTTP Status Codes"
+};
+//#endregion
+//#region src/generators/core/zod/getZodChain.ts
+const zodChainCache = /* @__PURE__ */ new WeakMap();
+function getZodChain({ schema, meta, options }) {
+	let optionsCache = zodChainCache.get(options);
+	if (!optionsCache) {
+		optionsCache = /* @__PURE__ */ new WeakMap();
+		zodChainCache.set(options, optionsCache);
+	}
+	let schemaCache = optionsCache.get(schema);
+	if (!schemaCache) {
+		schemaCache = /* @__PURE__ */ new Map();
+		optionsCache.set(schema, schemaCache);
+	}
+	const cacheKey = `${Boolean(meta?.isRequired)}|${Boolean(meta?.isParentPartial)}`;
+	const cached = schemaCache.get(cacheKey);
+	if (cached !== void 0) return cached;
+	const chains = [];
+	if (schema.type === "string") chains.push(getZodChainableStringValidations(schema));
+	else if (schema.type === "number" || schema.type === "integer") chains.push(getZodChainableNumberValidations(schema));
+	else if (schema.type === "array") chains.push(getZodChainableArrayValidations(schema));
+	if (typeof schema.description === "string" && schema.description !== "" && options.withDescription) chains.push(`describe(${JSON.stringify(schema.description)})`);
+	const output = chains.concat(getZodChainablePresence({
+		schema,
+		meta,
+		options
+	}), options.withDefaultValues !== false ? getZodChainableDefault(schema) : []).filter(Boolean).join(".");
+	const chain = output ? `.${output}` : "";
+	schemaCache.set(cacheKey, chain);
+	return chain;
+}
+function getZodChainablePresence({ schema, meta, options }) {
+	if (schema.nullable && !meta?.isRequired) return "nullish()";
+	if (schema.nullable || options.replaceOptionalWithNullish && meta?.isParentPartial) return "nullable()";
+	if (!meta?.isRequired) return options.replaceOptionalWithNullish ? "nullish()" : "optional()";
+	return "";
+}
+function getZodChainableDefault(schema) {
+	if (schema.default !== void 0) return `default(${schema.type === "number" || schema.type === "integer" ? unwrapQuotesIfNeeded(schema.default) : JSON.stringify(schema.default)})`;
+	return "";
+}
+function getZodChainableStringValidations(schema) {
+	const validations = [];
+	if (!schema.enum) {
+		if (schema.minLength !== void 0) validations.push(`min(${schema.minLength})`);
+		if (schema.maxLength !== void 0) validations.push(`max(${schema.maxLength})`);
+	}
+	if (schema.pattern) validations.push(`regex(${formatPatternIfNeeded(schema.pattern)})`);
+	return validations.join(".");
+}
+function formatPatternIfNeeded(pattern) {
+	if (pattern.startsWith("/") && pattern.endsWith("/")) pattern = pattern.slice(1, -1);
+	pattern = escapeControlCharacters(pattern);
+	return `/${pattern}/`;
+}
+function getZodChainableNumberValidations(schema) {
+	const validations = [];
+	if (schema.enum) return "";
+	if (schema.minimum !== void 0) {
+		if (schema.exclusiveMinimum === true) validations.push(`gt(${schema.minimum})`);
+		else validations.push(`gte(${schema.minimum})`);
+	} else if (typeof schema.exclusiveMinimum === "number") validations.push(`gt(${schema.exclusiveMinimum})`);
+	if (schema.maximum !== void 0) {
+		if (schema.exclusiveMaximum === true) validations.push(`lt(${schema.maximum})`);
+		else validations.push(`lte(${schema.maximum})`);
+	} else if (typeof schema.exclusiveMaximum === "number") validations.push(`lt(${schema.exclusiveMaximum})`);
+	if (schema.multipleOf) validations.push(`multipleOf(${schema.multipleOf})`);
+	return validations.join(".");
+}
+function getZodChainableArrayValidations(schema) {
+	const validations = [];
+	if (schema.minItems) validations.push(`min(${schema.minItems})`);
+	if (schema.maxItems) validations.push(`max(${schema.maxItems})`);
+	return validations.join(".");
+}
+//#endregion
+//#region src/generators/core/zod/getZodSchemaRefs.ts
+function getZodSchemaRefs(resolver, zodSchemaName) {
+	const schemaRef = resolver.getRefByZodSchemaName(zodSchemaName);
+	if (schemaRef) {
+		const refs = Array.from(resolver.dependencyGraph.refsDependencyGraph[schemaRef] ?? []).map((ref) => resolver.getZodSchemaNameByRef(ref));
+		const enumRefs = resolver.getExtractedEnumZodSchemaNamesReferencedBySchemaRef(schemaRef);
+		return [...refs, ...enumRefs];
+	}
+	const zodSchema = resolver.getCompositeZodSchemaByZodSchemaName(zodSchemaName);
+	if (zodSchema) return Array.from(getSchemaRefs(zodSchema)).map((schemaRef) => resolver.getZodSchemaNameByRef(schemaRef));
+	return [];
+}
+function getSchemaRefs(zodSchema, { skipObjectSchema = false } = {}) {
+	return zodSchema.children.reduce((acc, child) => {
+		const ref = child.ref ?? child.enumRef;
+		if (ref) acc.add(ref);
+		if (child.children.length > 0 && (!skipObjectSchema || !isSchemaObject(child.schema) || child.schema.type !== "object")) getSchemaRefs(child).forEach((ref) => acc.add(ref));
+		return acc;
+	}, /* @__PURE__ */ new Set());
+}
+//#endregion
+//#region src/generators/utils/math.utils.ts
+const sum = (arr) => arr.reduce((acc, item) => acc + item, 0);
+//#endregion
+//#region src/generators/core/openapi/getOpenAPISchemaComplexity.ts
+function getOpenAPISchemaComplexity(current, schema) {
+	if (!schema) return current;
+	if (isReferenceObject(schema)) return current + 2;
+	if (Array.isArray(schema.type)) {
+		if (schema.type.length === 1) return complexityByComposite("oneOf") + getOpenAPISchemaComplexity(current, {
+			...schema,
+			type: schema.type[0]
+		});
+		return current + complexityByComposite("oneOf") + sum(schema.type.map((prop) => getOpenAPISchemaComplexity(0, {
+			...schema,
+			type: prop
+		})));
+	}
+	if (schema.oneOf) {
+		if (schema.oneOf.length === 1) return complexityByComposite("oneOf") + getOpenAPISchemaComplexity(current, schema.oneOf[0]);
+		return current + complexityByComposite("oneOf") + sum(schema.oneOf.map((prop) => getOpenAPISchemaComplexity(0, prop)));
+	}
+	if (schema.anyOf) {
+		if (schema.anyOf.length === 1) return complexityByComposite("anyOf") + getOpenAPISchemaComplexity(current, schema.anyOf[0]);
+		return current + complexityByComposite("anyOf") + sum(schema.anyOf.map((prop) => getOpenAPISchemaComplexity(0, prop)));
+	}
+	if (schema.allOf) {
+		if (schema.allOf.length === 1) return complexityByComposite("allOf") + getOpenAPISchemaComplexity(current, schema.allOf[0]);
+		return current + complexityByComposite("allOf") + sum(schema.allOf.map((prop) => getOpenAPISchemaComplexity(0, prop)));
+	}
+	if (!schema.type) return current;
+	if (isPrimitiveType(schema.type)) {
+		if (schema.enum) return current + complexityByType(schema) + complexityByComposite("enum") + sum(schema.enum.map((prop) => getOpenAPISchemaComplexity(0, prop)));
+		return current + complexityByType(schema);
+	}
+	if (schema.type === "array") {
+		if (schema.items) return complexityByComposite("array") + getOpenAPISchemaComplexity(current, schema.items);
+		return complexityByComposite("array") + getOpenAPISchemaComplexity(current);
+	}
+	if (schema.type === "object" || schema.properties || schema.additionalProperties) {
+		if (schema.properties) {
+			const props = Object.values(schema.properties);
+			current += complexityByComposite("object") + sum(props.map((prop) => getOpenAPISchemaComplexity(0, prop)));
+		} else current += complexityByComposite("empty-object");
+		if (schema.additionalProperties) {
+			if (typeof schema.additionalProperties === "object") current += getOpenAPISchemaComplexity(0, schema.additionalProperties);
+			else current += getOpenAPISchemaComplexity(1);
+		}
+	}
+	return current;
+}
+function complexityByType(schema) {
+	return schema.type === "string" || schema.type === "number" || schema.type === "integer" || schema.type === "boolean" ? 1 : 0;
+}
+function complexityByComposite(type) {
+	switch (type) {
+		case "anyOf": return 3;
+		case "oneOf":
+		case "allOf":
+		case "object": return 2;
+		case "enum":
+		case "array":
+		case "empty-object": return 1;
+		default: return 0;
+	}
+}
+//#endregion
+//#region src/generators/core/zod/ZodSchema.class.ts
+var ZodSchema = class {
+	schema;
+	resolver;
+	code;
+	ref;
+	enumRef;
+	children = [];
+	meta;
+	constructor(schema, resolver, meta = { referencedBy: [] }, enumRef) {
+		this.schema = schema;
+		this.resolver = resolver;
+		if (isReferenceObject(schema)) this.ref = schema.$ref;
+		if (enumRef) this.enumRef = enumRef;
+		this.meta = {
+			...meta,
+			referencedBy: [...meta?.referencedBy ?? []]
+		};
+		if (this.ref) this.meta.referencedBy.push(this);
+	}
+	getCodeString(tag, options) {
+		if (!this.ref && this.code) return this.code;
+		if (!this.ref) throw new Error("Zod schema is missing both ref and code");
+		const zodSchemaName = this.resolver?.getZodSchemaNameByRef(this.ref);
+		if (!zodSchemaName) return this.ref;
+		const zodSchemaTag = this.resolver?.getTagByZodSchemaName(zodSchemaName);
+		if (options?.tsNamespaces && zodSchemaTag && zodSchemaTag !== tag) return `${getNamespaceName({
+			type: "models",
+			tag: zodSchemaTag,
+			options
+		})}.${zodSchemaName}`;
+		return zodSchemaName;
+	}
+	get complexity() {
+		return getOpenAPISchemaComplexity(0, this.schema);
+	}
+	assign(code) {
+		this.code = code;
+		return this;
+	}
+	inherit(parent) {
+		if (parent) parent.children.push(this);
+		return this;
+	}
+};
+function getParentRef(meta) {
+	if (!meta) return;
+	if (meta.parent?.ref) return meta.parent.ref;
+	return getParentRef(meta.parent?.meta);
+}
+//#endregion
+//#region src/generators/core/zod/getZodSchema.ts
+/**
+* @see https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.3.md#schemaObject
+* @see https://github.com/colinhacks/zod
+*/
+function getZodSchema({ schema, resolver, meta: inheritedMeta, tag }) {
+	const zodSchema = new ZodSchema(schema, resolver, inheritedMeta);
+	const meta = {
+		parent: zodSchema.inherit(inheritedMeta?.parent),
+		referencedBy: [...zodSchema.meta.referencedBy]
+	};
+	const params = {
+		resolver,
+		meta,
+		tag
+	};
+	if (isReferenceObject(schema)) return getReferenceZodSchema({
+		schema,
+		zodSchema,
+		resolver,
+		meta,
+		tag
+	});
+	const arrayZodSchema = getArrayZodSchema({
+		schema,
+		zodSchema,
+		resolver,
+		meta,
+		tag
+	});
+	if (arrayZodSchema) return arrayZodSchema;
+	const oneOfZodSchema = getOneOfZodSchema({
+		schema,
+		zodSchema,
+		resolver,
+		meta,
+		tag
+	});
+	if (oneOfZodSchema) return oneOfZodSchema;
+	const anyOfZodSchema = getAnyOfZodSchema({
+		schema,
+		zodSchema,
+		resolver,
+		meta,
+		tag
+	});
+	if (anyOfZodSchema) return anyOfZodSchema;
+	const allOfZodSchema = getAllOfZodSchema({
+		schema,
+		zodSchema,
+		resolver,
+		meta,
+		tag
+	});
+	if (allOfZodSchema) return allOfZodSchema;
+	const primitiveZodSchema = getPrimitiveZodSchema({
+		schema,
+		zodSchema,
+		resolver,
+		meta,
+		tag
+	});
+	if (primitiveZodSchema) return primitiveZodSchema;
+	const readonly = resolver.options.allReadonly ? ".readonly()" : "";
+	if (isArraySchemaObject(schema)) {
+		if (schema.items) return zodSchema.assign(`z.array(${getZodSchema({
+			...params,
+			schema: schema.items
+		}).getCodeString(tag, resolver.options)}${getZodChain({
+			schema: schema.items,
+			meta: {
+				...meta,
+				isRequired: true
+			},
+			options: resolver.options
+		})})${readonly}`);
+		return zodSchema.assign(`z.array(${ANY_SCHEMA})${readonly}`);
+	}
+	const schemaType = schema.type ? schema.type.toLowerCase() : void 0;
+	if (schemaType === "object" || schema.properties || schema.additionalProperties) {
+		const hasRequiredArray = schema.required && schema.required.length > 0;
+		const isPartial = resolver.options.withImplicitRequiredProps ? false : schema.properties && !schema.required?.length;
+		let properties = "{}";
+		if (schema.properties) properties = `{ ${Object.entries(schema.properties).map(([prop, propSchema]) => {
+			const propMetadata = {
+				...meta,
+				isRequired: isPartial ? true : hasRequiredArray ? schema.required?.includes(prop) : resolver.options.withImplicitRequiredProps,
+				name: prop,
+				isParentPartial: isPartial
+			};
+			let propActualSchema = propSchema;
+			if (isReferenceObject(propSchema) && resolver) {
+				propActualSchema = resolver.getSchemaByRef(propSchema.$ref);
+				if (!propActualSchema) throw new Error(`Schema ${propSchema.$ref} not found`);
+			}
+			const zodSchema = getZodSchema({
+				...params,
+				schema: propSchema,
+				meta: propMetadata
+			});
+			const propZodSchema = zodSchema.getCodeString(tag, resolver.options) + getZodChain({
+				schema: propActualSchema,
+				meta: propMetadata,
+				options: resolver.options
+			});
+			let isCircular = false;
+			const parentRef = getParentRef(inheritedMeta);
+			if (parentRef) isCircular = [...isReferenceObject(propSchema) ? [propSchema.$ref] : [], ...getSchemaRefs(zodSchema, { skipObjectSchema: true })].some((ref) => resolver.dependencyGraph.deepDependencyGraph[ref]?.has(parentRef));
+			return [
+				prop,
+				propZodSchema,
+				isCircular
+			];
+		}).map(([prop, propSchema, isCircular]) => isCircular ? `${wrapWithQuotesIfNeeded(prop)}: z.lazy(() => ${propSchema})` : `${wrapWithQuotesIfNeeded(prop)}: ${propSchema}`).join(", ")} }`;
+		let additionalPropsSchema = "";
+		if (schema.additionalProperties) additionalPropsSchema = `.catchall(${typeof schema.additionalProperties === "object" && Object.keys(schema.additionalProperties).length > 0 ? getZodSchema({
+			...params,
+			schema: schema.additionalProperties
+		}).getCodeString(tag, resolver.options) + getZodChain({
+			schema: schema.additionalProperties,
+			meta: {
+				...meta,
+				isRequired: true
+			},
+			options: resolver.options
+		}) : ANY_SCHEMA})`;
+		const zodObject = `z.object(${properties})${isPartial ? ".partial()" : ""}${additionalPropsSchema}${readonly}`;
+		return zodSchema.assign(zodObject);
+	}
+	if (schemaType === "any") return zodSchema.assign(ANY_SCHEMA);
+	if (schemaType === "null") return zodSchema.assign("z.null()");
+	if (!schemaType) return zodSchema.assign("z.unknown()");
+	throw new Error(`Unsupported schema type: ${schemaType}`);
+}
+function getReferenceZodSchema({ schema, zodSchema, resolver, meta, tag }) {
+	if (!isReferenceObject(schema)) return;
+	const zodSchemaName = resolver.getZodSchemaNameByRef(schema.$ref);
+	if (zodSchema.meta.referencedBy.length > 2) {
+		const refsPath = zodSchema.meta.referencedBy.slice(0, -1).map((prev) => prev.ref ? resolver.getZodSchemaNameByRef(prev.ref) ?? prev.ref : void 0).filter(Boolean);
+		if (refsPath.length > 1 && refsPath.includes(zodSchemaName)) return zodSchema.assign(resolver.getCodeByZodSchemaName(zodSchema.ref));
+	}
+	let result = resolver.getCodeByZodSchemaName(schema.$ref);
+	if (!result) {
+		const actualSchema = resolver.getSchemaByRef(schema.$ref);
+		if (!actualSchema) throw new Error(`Schema ${schema.$ref} not found`);
+		result = getZodSchema({
+			schema: actualSchema,
+			resolver,
+			meta,
+			tag
+		}).getCodeString(tag, resolver.options);
+	}
+	if (resolver.getCodeByZodSchemaName(zodSchemaName)) return zodSchema;
+	resolver.setZodSchema(zodSchemaName, result, tag);
+	return zodSchema;
+}
+function getOneOfZodSchema({ schema, zodSchema, resolver, meta, tag }) {
+	if (!isSchemaObject(schema) || !schema.oneOf) return;
+	if (schema.oneOf.length === 1) {
+		const type = getZodSchema({
+			schema: schema.oneOf[0],
+			resolver,
+			meta,
+			tag
+		});
+		return zodSchema.assign(type.getCodeString(tag, resolver.options));
+	}
+	const hasMultipleAllOf = schema.oneOf?.some((obj) => isSchemaObject(obj) && (obj?.allOf || []).length > 1);
+	if (schema.discriminator && !hasMultipleAllOf) {
+		const propertyName = schema.discriminator.propertyName;
+		return zodSchema.assign(`
+      z.discriminatedUnion("${propertyName}", [${schema.oneOf.map((schema) => getZodSchema({
+			schema,
+			resolver,
+			meta,
+			tag
+		}).getCodeString(tag, resolver.options)).join(", ")}])
+        `);
+	}
+	return zodSchema.assign(`z.union([${schema.oneOf.map((schema) => getZodSchema({
+		schema,
+		resolver,
+		meta,
+		tag
+	}).getCodeString(tag, resolver.options)).join(", ")}])`);
+}
+function getArrayZodSchema({ schema, zodSchema, resolver, meta, tag }) {
+	if (!isSchemaObject(schema) || !Array.isArray(schema.type)) return;
+	if (schema.type.length === 1) return getZodSchema({
+		schema: {
+			...schema,
+			type: schema.type[0]
+		},
+		resolver,
+		meta,
+		tag
+	});
+	return zodSchema.assign(`z.union([${schema.type.map((prop) => getZodSchema({
+		schema: {
+			...schema,
+			type: prop
+		},
+		resolver,
+		meta,
+		tag
+	}).getCodeString(tag, resolver.options)).join(", ")}])`);
+}
+function getAnyOfZodSchema({ schema, zodSchema, resolver, meta, tag }) {
+	if (!isSchemaObject(schema) || !schema.anyOf) return;
+	if (schema.anyOf.length === 1) {
+		const type = getZodSchema({
+			schema: schema.anyOf[0],
+			resolver,
+			meta,
+			tag
+		});
+		return zodSchema.assign(type.getCodeString(tag, resolver.options));
+	}
+	const types = schema.anyOf.map((schema) => getZodSchema({
+		schema,
+		resolver,
+		meta,
+		tag
+	})).map((type) => type.getCodeString(tag, resolver.options)).join(", ");
+	return zodSchema.assign(`z.union([${types}])`);
+}
+function getAllOfZodSchema({ schema, zodSchema, resolver, meta, tag }) {
+	if (!isSchemaObject(schema) || !schema.allOf) return;
+	if (schema.allOf.length === 1) {
+		const type = getZodSchema({
+			schema: schema.allOf[0],
+			resolver,
+			meta,
+			tag
+		});
+		return zodSchema.assign(type.getCodeString(tag, resolver.options));
+	}
+	const { patchRequiredSchemaInLoop, noRequiredOnlyAllof, composedRequiredSchema } = inferRequiredSchema(schema);
+	const types = noRequiredOnlyAllof.map((schema) => {
+		const type = getZodSchema({
+			schema,
+			resolver,
+			meta,
+			tag
+		});
+		if (resolver) patchRequiredSchemaInLoop(schema, resolver.getSchemaByRef.bind(resolver));
+		return type;
+	});
+	if (composedRequiredSchema.required.length) types.push(getZodSchema({
+		schema: composedRequiredSchema,
+		resolver,
+		meta,
+		tag
+	}));
+	const first = types.at(0);
+	const rest = types.slice(1).map((type) => `...${type.getCodeString(tag, resolver.options)}.shape`).join(", ");
+	return zodSchema.assign(`z.object({ ...${first.getCodeString(tag, resolver.options)}.shape, ${rest} })`);
+}
+function getPrimitiveZodSchema({ schema, zodSchema, resolver, meta, tag }) {
+	if (!isSchemaObject(schema)) return;
+	const schemaType = schema.type ? schema.type.toLowerCase() : void 0;
+	if (schemaType && isPrimitiveType(schemaType)) {
+		if (schema.enum) {
+			if (schemaType === "string") return getEnumZodSchema({
+				schema,
+				zodSchema,
+				resolver,
+				meta,
+				tag
+			});
+			if (schema.enum.some((e) => typeof e === "string")) return zodSchema.assign("z.never()");
+			if (schema.enum.length === 1) {
+				const value = schema.enum[0];
+				return zodSchema.assign(`z.literal(${value === null ? "null" : value})`);
+			}
+			return zodSchema.assign(`z.union([${schema.enum.map((value) => `z.literal(${value === null ? "null" : value})`).join(", ")}])`);
+		}
+		if (schemaType === "integer") return zodSchema.assign(schema.type === "integer" ? INT_SCHEMA : NUMBER_SCHEMA);
+		if (schemaType === "string") {
+			let stringSchema = STRING_SCHEMA;
+			switch (schema.format) {
+				case "binary":
+					stringSchema = BLOB_SCHEMA;
+					break;
+				case "email":
+					stringSchema = EMAIL_SCHEMA;
+					break;
+				case "hostname":
+				case "uri":
+					stringSchema = URL_SCHEMA;
+					break;
+				case "uuid":
+					stringSchema = UUID_SCHEMA;
+					break;
+				case "date-time": stringSchema = DATETIME_SCHEMA;
+			}
+			return zodSchema.assign(stringSchema);
+		}
+		return zodSchema.assign(`z.${schemaType}()`);
+	}
+}
+function getEnumZodSchema({ resolver, schema, zodSchema, meta, tag }) {
+	if (!isSchemaObject(schema)) return;
+	const code = getEnumZodSchemaCode(schema);
+	if (!resolver.options.extractEnums || resolver.options.modelsInModules && schema.enum?.length === 1) return zodSchema.assign(code);
+	const enumZodSchema = resolver.getEnumZodSchemaDataByCode(code);
+	if (enumZodSchema) {
+		if (zodSchema.meta.parent?.ref === resolver.getRefByZodSchemaName(enumZodSchema.zodSchemaName)) return zodSchema.assign(enumZodSchema.code);
+		return new ZodSchema({ $ref: resolver.getRefByZodSchemaName(enumZodSchema.zodSchemaName) }, resolver, meta).inherit(zodSchema).assign(code);
+	}
+	const extractedEnumZodSchema = resolver.getExtractedEnumZodSchemaDataByCode(code);
+	if (!extractedEnumZodSchema) return zodSchema.assign(code);
+	if (!extractedEnumZodSchema.zodSchemaName || !extractedEnumZodSchema.tag) throw new Error(`Enum zod schema name or tag not resolved for code: ${code}`);
+	const namespacePrefix = resolver.options.tsNamespaces && extractedEnumZodSchema.tag !== tag ? `${getNamespaceName({
+		type: "models",
+		tag: extractedEnumZodSchema.tag,
+		options: resolver.options
+	})}.` : "";
+	return zodSchema.assign(`${namespacePrefix}${extractedEnumZodSchema.zodSchemaName}`);
+}
+function getEnumZodSchemaCode(schema) {
+	const values = schema.enum?.filter((value) => value !== null) ?? [];
+	return `${ENUM_SCHEMA}([${values.map((value) => `"${value}"`).join(", ")}])`;
+}
+function getEnumZodSchemaCodeFromEnumNames(enumNames) {
+	return `${ENUM_SCHEMA}([${enumNames.map((value) => `"${value}"`).join(", ")}])`;
+}
+//#endregion
+//#region src/generators/core/zod/resolveZodSchemaName.ts
+const resolverResolveZodSchemaNameCache = /* @__PURE__ */ new WeakMap();
+function resolveZodSchemaName({ schema, zodSchema, fallbackName, resolver, tag }) {
+	const result = zodSchema.getCodeString();
+	const cacheKey = `${zodSchema.ref ?? ""}|${fallbackName ?? ""}|${tag}|${zodSchema.complexity}|${result}`;
+	let cacheForResolver = resolverResolveZodSchemaNameCache.get(resolver);
+	if (!cacheForResolver) {
+		cacheForResolver = /* @__PURE__ */ new Map();
+		resolverResolveZodSchemaNameCache.set(resolver, cacheForResolver);
+	}
+	const cachedName = cacheForResolver.get(cacheKey);
+	if (cachedName) return cachedName;
+	if ((!isNamedZodSchema(result) || zodSchema.ref === void 0) && fallbackName) {
+		if (zodSchema.complexity < 2) return result;
+		const zodSchemaName = getZodSchemaName(fallbackName, resolver.options.schemaSuffix);
+		while (resolver.getCodeByZodSchemaName(zodSchemaName)) if (resolver.getZodSchemaNamesByCompositeCode(result)?.includes(zodSchemaName)) return zodSchemaName;
+		else if (resolver.getCodeByZodSchemaName(zodSchemaName) === zodSchemaName) return zodSchemaName;
+		else throw new Error(`Can't uniquely resolve zod schema name: ${zodSchemaName}`);
+		resolver.setZodSchema(zodSchemaName, result, tag);
+		resolver.addZodSchemaForCompositeCode(result, zodSchema, zodSchemaName, schema);
+		cacheForResolver.set(cacheKey, zodSchemaName);
+		return zodSchemaName;
+	}
+	let resolvedSchema = resolver.getCodeByZodSchemaName(result);
+	if (!resolvedSchema && zodSchema.ref) resolvedSchema = resolver.getCodeByZodSchemaName(resolver.getZodSchemaNameByRef(zodSchema.ref));
+	if (zodSchema.ref && resolvedSchema) {
+		if (getOpenAPISchemaComplexity(0, resolver.getSchemaByRef(zodSchema.ref)) < 2) {
+			const resolvedName = resolver.getCodeByZodSchemaName(result);
+			cacheForResolver.set(cacheKey, resolvedName);
+			return resolvedName;
+		}
+		cacheForResolver.set(cacheKey, result);
+		return result;
+	}
+	if (zodSchema.ref) {
+		const resolvedRefName = resolver.getZodSchemaNameByRef(zodSchema.ref);
+		cacheForResolver.set(cacheKey, resolvedRefName);
+		return resolvedRefName;
+	}
+	throw new Error(`Invalid ref: ${zodSchema.ref}`);
+}
+//#endregion
+//#region src/generators/utils/validation.utils.ts
+function getInvalidSchemaError(message) {
+	return {
+		type: "invalid-schema",
+		message
+	};
+}
+function getInvalidOperationIdError(operationId) {
+	return {
+		type: "invalid-operation-id",
+		message: `Operation ${operationId}`
+	};
+}
+function getMissingPathParameterError(params, path) {
+	return {
+		type: "missing-path-parameter",
+		message: `Path ${path} is missing [${params.map(({ name }) => name).join(", ")}]`
+	};
+}
+function getNotAllowedInlineEnumError(enumProperty) {
+	return {
+		type: "not-allowed-inline-enum",
+		message: `${enumProperty} is missing @IsEnum() and @ApiProperty(enum:, enumName:)`
+	};
+}
+function getMissingAclConditionPropertyError(propertyName, operation, endpoint) {
+	return {
+		type: "missing-acl-condition-property",
+		message: `Condition property ${propertyName} is not found in parameters or body in operation ${getOperationDescriptor(operation, endpoint)}`
+	};
+}
+function getMissingStatusCodeError(statusCode, operation, endpoint) {
+	return {
+		type: "missing-status-code",
+		message: `Missing HTTP status code ${getStatusCodeDescription(statusCode)} in operation ${getOperationDescriptor(operation, endpoint)}`
+	};
+}
+function getInvalidStatusCodeError(statusCode, operation, endpoint) {
+	return {
+		type: "invalid-status-code",
+		message: `Operation ${getOperationDescriptor(operation, endpoint)} expected HTTP status code ${getStatusCodeDescription(statusCode.expected)} but received ${getStatusCodeDescription(statusCode.received)}`
+	};
+}
+function getMultipleSuccessStatusCodesError(statusCodes, operation, endpoint) {
+	return {
+		type: "multiple-success-status-codes",
+		message: `Operation ${getOperationDescriptor(operation, endpoint)} has multiple success HTTP status codes: ${statusCodes.map(getStatusCodeDescription).join(", ")}`
+	};
+}
+function getOperationDescriptor(operation, endpoint) {
+	return operation.operationId ?? `${endpoint.method} ${endpoint.path}`;
+}
+function getStatusCodeDescription(statusCode) {
+	return `${statusCode} (${HTTP_STATUS_CODES[statusCode]})`;
+}
+function groupByType(validationErrors) {
+	return validationErrors.reduce((acc, err) => ({
+		...acc,
+		[err.type]: [...acc[err.type] ?? [], err.message]
+	}), {});
+}
+//#endregion
+//#region src/generators/core/endpoints/getEndpointAcl.ts
+function getEndpointAcl({ resolver, endpoint, operation }) {
+	const acl = operation["x-acl"];
+	return acl?.map((item) => {
+		const conditionsTypes = Object.keys(item.conditions ?? {}).reduce((acc, name) => {
+			const propertyType = getEndpointAclConditionPropertyType({
+				resolver,
+				endpoint,
+				acl,
+				name
+			});
+			if (!propertyType) {
+				resolver.validationErrors.push(getMissingAclConditionPropertyError(name, operation, endpoint));
+				return acc;
+			}
+			return [...acc, propertyType];
+		}, []);
+		return {
+			...item,
+			conditionsTypes
+		};
+	});
+}
+function getEndpointAclConditionPropertyType({ resolver, endpoint, acl, name }) {
+	const conditionPropertyPath = acl[0]?.conditions?.[name];
+	if (!conditionPropertyPath) return;
+	const pathSplits = conditionPropertyPath.replace(/^\$[^.]*\./, "").split(".");
+	let schema = void 0;
+	let required = void 0;
+	let info = void 0;
+	let index = 0;
+	const parameter = endpoint.parameters.find(({ name }) => name === pathSplits[index]);
+	if (parameter) {
+		required = parameter.parameterObject?.required;
+		schema = parameter.parameterObject?.schema;
+		info = `${parameter.name} ${decapitalize(parameter.type)} parameter`;
+		index++;
+	} else {
+		const bodyParameter = endpoint.parameters.find(({ bodyObject }) => !!bodyObject);
+		const matchingMediaType = Object.keys(bodyParameter?.bodyObject?.content ?? {}).find(isParamMediaTypeAllowed);
+		if (matchingMediaType) {
+			schema = bodyParameter?.bodyObject?.content?.[matchingMediaType]?.schema;
+			required = bodyParameter?.bodyObject?.required;
+			info = `${isQuery(endpoint) ? "query" : "mutation"} data`;
+			if (pathSplits[index]?.startsWith("$")) index++;
+		}
+	}
+	while (schema && index < pathSplits.length) {
+		const resolvedSchema = resolver.resolveObject(schema);
+		schema = Object.entries(resolvedSchema.properties ?? {}).find(([key]) => key === pathSplits[index])?.[1];
+		required = resolvedSchema.required?.includes(pathSplits[index]) ?? false;
+		index++;
+	}
+	if (!schema) return;
+	return {
+		name,
+		type: isReferenceObject(schema) ? void 0 : schema.type,
+		zodSchemaName: isReferenceObject(schema) ? resolver.getZodSchemaNameByRef(schema.$ref) : void 0,
+		required,
+		info
+	};
+}
+//#endregion
+//#region src/generators/core/endpoints/resolveEndpointZodSchema.ts
+const resolverEndpointZodSchemaCache = /* @__PURE__ */ new WeakMap();
+function getResolverSchemaCache(resolver) {
+	let schemaCache = resolverEndpointZodSchemaCache.get(resolver);
+	if (!schemaCache) {
+		schemaCache = {
+			byObject: /* @__PURE__ */ new WeakMap(),
+			byRef: /* @__PURE__ */ new Map()
+		};
+		resolverEndpointZodSchemaCache.set(resolver, schemaCache);
+	}
+	return schemaCache;
+}
+function getOrCreateSchemaEntries(schemaCache, schema) {
+	if (isReferenceObject(schema)) {
+		let entries = schemaCache.byRef.get(schema.$ref);
+		if (!entries) {
+			entries = /* @__PURE__ */ new Map();
+			schemaCache.byRef.set(schema.$ref, entries);
+		}
+		return entries;
+	}
+	let entries = schemaCache.byObject.get(schema);
+	if (!entries) {
+		entries = /* @__PURE__ */ new Map();
+		schemaCache.byObject.set(schema, entries);
+	}
+	return entries;
+}
+function resolveEndpointZodSchema({ resolver, schema, meta, tag, fallbackName, composeBeforeResolve }) {
+	const entries = getOrCreateSchemaEntries(getResolverSchemaCache(resolver), schema);
+	const isRefSchema = isReferenceObject(schema);
+	const normalizedFallbackName = isRefSchema ? "" : fallbackName ?? "";
+	const normalizedTag = isRefSchema ? "" : tag;
+	const metaKey = `required:${Boolean(meta.isRequired)}|name:${meta.name ?? ""}|parentPartial:${Boolean(meta.isParentPartial)}|fallback:${normalizedFallbackName}|tag:${normalizedTag}|compose:${composeBeforeResolve ? 1 : 0}`;
+	const cached = entries.get(metaKey);
+	if (cached) return cached;
+	const zodSchema = getZodSchema({
+		schema,
+		resolver,
+		meta,
+		tag
+	});
+	const schemaObject = resolver.resolveObject(schema);
+	const zodChain = getZodChain({
+		schema: schemaObject,
+		meta: zodSchema.meta,
+		options: resolver.options
+	});
+	const resolved = composeBeforeResolve ? resolveZodSchemaName({
+		schema: schemaObject,
+		zodSchema: zodSchema.assign(zodSchema.getCodeString(tag) + zodChain),
+		fallbackName,
+		resolver,
+		tag
+	}) : (() => {
+		const name = resolveZodSchemaName({
+			schema: schemaObject,
+			zodSchema,
+			fallbackName,
+			resolver,
+			tag
+		});
+		return isNamedZodSchema(name) ? name : name + zodChain;
+	})();
+	entries.set(metaKey, resolved);
+	return resolved;
+}
+//#endregion
+//#region src/generators/core/endpoints/getEndpointBody.ts
+function getEndpointBody({ resolver, operation, operationName, isUniqueOperationName, tag }) {
+	const requestBodyObj = resolver.resolveObject(operation.requestBody);
+	if (!requestBodyObj) return;
+	const matchingMediaType = Object.keys(requestBodyObj.content ?? {}).find(isParamMediaTypeAllowed);
+	if (!matchingMediaType) return;
+	const schema = requestBodyObj.content?.[matchingMediaType]?.schema;
+	if (!schema) return;
+	const zodSchema = resolveEndpointZodSchema({
+		resolver,
+		schema,
+		meta: { isRequired: requestBodyObj.required ?? true },
+		tag,
+		fallbackName: getBodyZodSchemaName(getZodSchemaOperationName(operationName, isUniqueOperationName, tag)),
+		composeBeforeResolve: false
+	});
+	return {
+		endpointParameter: {
+			name: BODY_PARAMETER_NAME,
+			type: "Body",
+			description: requestBodyObj.description,
+			zodSchema,
+			bodyObject: requestBodyObj
+		},
+		requestFormat: matchingMediaType
+	};
+}
+//#endregion
+//#region src/generators/core/endpoints/getEndpointParameter.ts
+function getEndpointParameter({ resolver, param, operationName, isUniqueOperationName, tag }) {
+	const paramObj = resolver.resolveObject(param);
+	if (!ALLOWED_PATH_IN.includes(paramObj.in)) return;
+	let schema = {};
+	if (paramObj.content) {
+		const mediaTypes = Object.keys(paramObj.content ?? {});
+		const matchingMediaType = mediaTypes.find(isParamMediaTypeAllowed);
+		if (!matchingMediaType) throw new Error(`Unsupported media type for param ${paramObj.name}: ${mediaTypes.join(", ")}`);
+		const mediaTypeObject = paramObj.content?.[matchingMediaType];
+		if (!mediaTypeObject) throw new Error(`No content with media type for param ${paramObj.name}: ${matchingMediaType}`);
+		schema = mediaTypeObject?.schema ?? mediaTypeObject;
+	} else if (paramObj.schema) schema = paramObj.schema;
+	if (resolver.options.withDescription && schema) schema.description = (paramObj.description ?? "").trim();
+	const fallbackName = getParamZodSchemaName(getZodSchemaOperationName(operationName, isUniqueOperationName, tag), paramObj.name);
+	let parameterSortingEnumSchemaName = void 0;
+	if (isSortingParameterObject(paramObj, schema, resolver)) {
+		const enumZodSchemaName = getEnumZodSchemaName(fallbackName, resolver.options.enumSuffix, resolver.options.schemaSuffix);
+		const code = getEnumZodSchemaCodeFromEnumNames(getParameterEnumNames(paramObj, schema) ?? []);
+		resolver.setZodSchema(enumZodSchemaName, code, tag);
+		parameterSortingEnumSchemaName = enumZodSchemaName;
+	}
+	const zodSchema = getZodSchema({
+		schema,
+		resolver,
+		meta: { isRequired: paramObj.in === "path" ? true : paramObj.required ?? false },
+		tag
+	});
+	const schemaObject = resolver.resolveObject(schema);
+	const zodChain = getZodChain({
+		schema: schemaObject,
+		meta: (paramObj.in === "query" || paramObj.in === "header") && !paramObj.required && isSchemaObject(schemaObject) && (schemaObject.type === "object" || !!schemaObject.properties && Object.keys(schemaObject.properties).length > 0) ? {
+			...zodSchema.meta,
+			isRequired: true
+		} : zodSchema.meta,
+		options: resolver.options
+	});
+	const zodSchemaName = resolveZodSchemaName({
+		schema: schemaObject,
+		zodSchema: zodSchema.assign(zodSchema.getCodeString(tag) + zodChain),
+		fallbackName,
+		resolver,
+		tag
+	});
+	return {
+		name: paramObj.in === "path" ? pathParamToVariableName(paramObj.name) : paramObj.name,
+		type: paramObj.in === "header" ? "Header" : paramObj.in === "query" ? "Query" : "Path",
+		zodSchema: zodSchemaName,
+		parameterObject: paramObj,
+		...parameterSortingEnumSchemaName !== void 0 ? { parameterSortingEnumSchemaName } : {}
+	};
+}
+//#endregion
+//#region src/generators/core/endpoints/getEndpointsFromOpenAPIDoc.ts
+function getEndpointsFromOpenAPIDoc(resolver, profiler = new Profiler(false)) {
+	const endpoints = [];
+	const responseSchemaByRefAndTag = /* @__PURE__ */ new Map();
+	for (const context of resolver.getOperationContexts()) {
+		const { path, method, operation, operationName, isUniqueOperationName, tag, parameters, responses } = context;
+		const invalidOperationId = operation.operationId && operation.operationId !== invalidVariableNameCharactersToCamel(operation.operationId);
+		if (operation.operationId && invalidOperationId) resolver.validationErrors.push(getInvalidOperationIdError(operation.operationId));
+		const endpoint = {
+			method,
+			path: replaceHyphenatedPath(path),
+			operationName,
+			description: operation.description,
+			summary: operation.summary,
+			tags: operation.tags?.map(formatTag),
+			requestFormat: JSON_APPLICATION_FORMAT,
+			parameters: [],
+			response: "",
+			errors: [],
+			responseStatusCodes: [],
+			mediaUpload: !!operation["x-media-upload"],
+			mediaDownload: !!operation["x-media-download"]
+		};
+		if (operation.requestBody) {
+			const body = profiler.runSync("endpoints.body", () => getEndpointBody({
+				resolver,
+				operation,
+				operationName,
+				isUniqueOperationName,
+				tag
+			}));
+			if (body) {
+				endpoint.parameters.push(body.endpointParameter);
+				endpoint.requestFormat = body.requestFormat;
+			}
+		}
+		for (const param of parameters) {
+			const endpointParameter = profiler.runSync("endpoints.parameter", () => getEndpointParameter({
+				resolver,
+				param,
+				operationName,
+				isUniqueOperationName,
+				tag
+			}));
+			if (endpointParameter) endpoint.parameters.push(endpointParameter);
+		}
+		const missingPathParameters = getMissingPathParameters(endpoint.path, endpoint.parameters);
+		endpoint.parameters.push(...missingPathParameters);
+		if (missingPathParameters.length > 0) resolver.validationErrors.push(getMissingPathParameterError(missingPathParameters, path));
+		for (const { statusCode, responseObj, matchingMediaType, schema } of responses) {
+			endpoint.responseStatusCodes.push(statusCode);
+			if (matchingMediaType) {
+				const statusNum = Number(statusCode);
+				if (isMainResponseStatus(statusNum) || statusCode === "default" && !endpoint.responseFormat) endpoint.responseFormat = matchingMediaType;
+			} else if (statusCode === "200") resolver.validationErrors.push(getInvalidStatusCodeError({
+				received: "200",
+				expected: "204"
+			}, operation, endpoint));
+			if (schema) {
+				const responseCacheKey = isReferenceObject(schema) ? `${schema.$ref}|${tag}` : void 0;
+				let resolvedResponse = responseCacheKey ? responseSchemaByRefAndTag.get(responseCacheKey) : void 0;
+				if (!resolvedResponse) {
+					const zodSchema = profiler.runSync("endpoints.response.zod", () => getZodSchema({
+						schema,
+						resolver,
+						meta: { isRequired: true },
+						tag
+					}));
+					const schemaObject = resolver.resolveObject(schema);
+					resolvedResponse = {
+						schemaObject,
+						responseZodSchema: resolveZodSchemaName({
+							schema: schemaObject,
+							zodSchema,
+							fallbackName: zodSchema.ref ? void 0 : getResponseZodSchemaName({
+								statusCode,
+								operationName,
+								isUniqueOperationName,
+								tag
+							}),
+							resolver,
+							tag
+						}) + getZodChain({
+							schema: schemaObject,
+							meta: zodSchema.meta,
+							options: resolver.options
+						})
+					};
+					if (responseCacheKey) responseSchemaByRefAndTag.set(responseCacheKey, resolvedResponse);
+				}
+				const { schemaObject, responseZodSchema } = resolvedResponse;
+				const status = Number(statusCode);
+				if (isMainResponseStatus(status) && !endpoint.response) {
+					endpoint.response = responseZodSchema;
+					endpoint.responseObject = responseObj;
+					endpoint.responseDescription = responseObj?.description;
+				} else if (statusCode === "default" && !endpoint.response) {
+					endpoint.response = responseZodSchema;
+					endpoint.responseObject = responseObj;
+					endpoint.responseDescription = responseObj?.description;
+				} else if (statusCode !== "default" && !Number.isNaN(status) && isErrorStatus(status)) {
+					const rawSchema = schemaObject;
+					const domainStr = rawSchema["x-domain-error-domain"];
+					const domainName = rawSchema["x-domain-error-name"];
+					const codeEnumArr = ((rawSchema?.properties)?.code)?.enum;
+					const domainCode = Array.isArray(codeEnumArr) && codeEnumArr.length === 1 && (typeof codeEnumArr[0] === "number" || typeof codeEnumArr[0] === "string") ? codeEnumArr[0] : void 0;
+					endpoint.errors.push({
+						zodSchema: responseZodSchema,
+						status,
+						description: responseObj?.description,
+						...typeof domainStr === "string" && domainCode !== void 0 ? { domainError: {
+							domain: domainStr,
+							code: domainCode,
+							...typeof domainName === "string" ? { name: domainName } : {}
+						} } : {}
+					});
+				}
+			} else {
+				const status = Number(statusCode);
+				const responseZodSchema = VOID_SCHEMA;
+				if (statusCode !== "default" && !Number.isNaN(status) && isErrorStatus(status)) endpoint.errors.push({
+					zodSchema: responseZodSchema,
+					status,
+					description: responseObj?.description
+				});
+			}
+		}
+		if (!endpoint.response) endpoint.response = VOID_SCHEMA;
+		const mainStatusCodes = [];
+		for (const { statusCode } of responses) {
+			const status = Number(statusCode);
+			if (isMainResponseStatus(status)) mainStatusCodes.push(status);
+		}
+		if (mainStatusCodes.length > 1) resolver.validationErrors.push(getMultipleSuccessStatusCodesError(mainStatusCodes.map(String), operation, endpoint));
+		const resolvedAcl = getEndpointAcl({
+			resolver,
+			endpoint,
+			operation
+		});
+		if (resolvedAcl?.length) endpoint.acl = resolvedAcl;
+		if (operation.security?.[0].Authorization && !endpoint.responseStatusCodes.includes("401")) resolver.validationErrors.push(getMissingStatusCodeError("401", operation, endpoint));
+		if (endpoint.acl?.[0] && !endpoint.responseStatusCodes.includes("403")) resolver.validationErrors.push(getMissingStatusCodeError("403", operation, endpoint));
+		endpoints.push(endpoint);
+	}
+	return endpoints;
+}
+function getMissingPathParameters(path, parameters) {
+	if (!path.includes(":")) return [];
+	const parameterNames = new Set(parameters.map(({ name }) => name));
+	const missingParameters = [];
+	for (const match of path.matchAll(/:([a-zA-Z0-9_]+)/g)) {
+		const name = match[1];
+		if (name && !parameterNames.has(name)) missingParameters.push(getPathParameterFromName(name));
+	}
+	return missingParameters;
+}
+function getPathParameterFromName(name) {
+	return {
+		name,
+		type: "Path",
+		zodSchema: STRING_SCHEMA,
+		parameterObject: {
+			name,
+			required: true,
+			in: "path",
+			schema: { type: "string" }
+		}
+	};
+}
+//#endregion
+//#region src/generators/const/js.const.ts
+const RESERVED_WORDS = [
+	"break",
+	"case",
+	"catch",
+	"class",
+	"const",
+	"continue",
+	"debugger",
+	"default",
+	"delete",
+	"do",
+	"else",
+	"export",
+	"extends",
+	"false",
+	"finally",
+	"for",
+	"function",
+	"if",
+	"import",
+	"in",
+	"instanceof",
+	"new",
+	"null",
+	"return",
+	"super",
+	"switch",
+	"this",
+	"throw",
+	"true",
+	"try",
+	"typeof",
+	"var",
+	"void",
+	"while",
+	"with"
+];
+//#endregion
+//#region src/generators/utils/operation.utils.ts
+function isOperationExcluded(operation, options) {
+	const isDeprecated = operation.deprecated && !options.withDeprecatedEndpoints;
+	const tag = getOperationTag(operation, options);
+	const isIncluded = isTagIncluded(tag, options);
+	return isDeprecated || !isIncluded;
+}
+function getOperationName({ path, method, operation, options, tag, keepOperationTag, keepOperationPrefix }) {
+	return resolveOperationName({
+		path,
+		method,
+		operation,
+		options,
+		tag,
+		keepOperationTag,
+		keepOperationPrefix
+	}).name;
+}
+function resolveOperationName({ path, method, operation, options, tag, keepOperationTag, keepOperationPrefix }) {
+	const usesPathAsSource = !operation.operationId;
+	let pathOperationName;
+	let operationName;
+	if (operation.operationId) operationName = invalidVariableNameCharactersToCamel(operation.operationId);
+	else {
+		pathOperationName = `${method}${pathToVariableName(path)}`;
+		operationName = pathOperationName;
+	}
+	if (options.removeOperationPrefixEndingWith && keepOperationPrefix) operationName = operationName.split(options.removeOperationPrefixEndingWith).map((split, index) => index === 0 ? split : capitalize(split)).join("");
+	else if (options.removeOperationPrefixEndingWith && !keepOperationPrefix) {
+		const regex = new RegExp(`^.*${options.removeOperationPrefixEndingWith}`);
+		operationName = operationName.replace(regex, "");
+	}
+	if ((options.tsNamespaces || options.treeShakeableNamespaces) && !keepOperationTag) {
+		const operationNameWithoutTag = removeWord(operationName, tag);
+		if (operationNameWithoutTag === "") operationName = method.toLowerCase();
+		else if (!RESERVED_WORDS.includes(operationNameWithoutTag)) operationName = operationNameWithoutTag;
+	}
+	const usesReservedWordFallback = RESERVED_WORDS.includes(operationName);
+	if (usesReservedWordFallback && pathOperationName === void 0) pathOperationName = `${method}${pathToVariableName(path)}`;
+	return {
+		name: usesReservedWordFallback ? pathOperationName : operationName,
+		usesPathAsSource,
+		usesReservedWordFallback
+	};
+}
+function createOperationNameIndex({ operations, options, tag, keepOperationTag }) {
+	const index = {
+		stableCounts: /* @__PURE__ */ new Map(),
+		pathSourceCount: 0,
+		reservedFallbackCount: 0
+	};
+	for (const operation of operations) {
+		if (!operation.operationId) {
+			index.pathSourceCount++;
+			continue;
+		}
+		const result = resolveOperationName({
+			path: "",
+			method: "",
+			operation,
+			options,
+			tag,
+			keepOperationTag
+		});
+		if (result.usesReservedWordFallback) index.reservedFallbackCount++;
+		else index.stableCounts.set(result.name, (index.stableCounts.get(result.name) ?? 0) + 1);
+	}
+	return index;
+}
+function getUniqueOperationName({ operationsByTag, nameIndexes, ...params }) {
+	const { operation, options } = params;
+	const tag = options.splitByTags ? getOperationTag(operation, options) : options.defaultTag;
+	const operationName = (keepOperationTag, nameIndex) => {
+		const name = getOperationName({
+			...params,
+			tag,
+			keepOperationTag
+		});
+		if (nameIndex) {
+			const pathSourceMatches = nameIndex.pathSourceCount > 0 && getOperationName({
+				...params,
+				operation: {},
+				tag,
+				keepOperationTag
+			}) === name;
+			const pathFallbackMatches = nameIndex.reservedFallbackCount > 0 && `${params.method}${pathToVariableName(params.path)}` === name;
+			return (nameIndex.stableCounts.get(name) ?? 0) + (pathSourceMatches ? nameIndex.pathSourceCount : 0) + (pathFallbackMatches ? nameIndex.reservedFallbackCount : 0) === 1 ? name : void 0;
+		}
+		let matchingOperations = 0;
+		for (const candidate of operationsByTag[tag]) if (getOperationName({
+			...params,
+			operation: candidate,
+			tag,
+			keepOperationTag
+		}) === name) {
+			matchingOperations++;
+			if (matchingOperations > 1) return;
+		}
+		if (matchingOperations === 1) return name;
+	};
+	return operationName(void 0, nameIndexes?.[0]) ?? operationName(true, nameIndexes?.[1]) ?? getOperationName({
+		...params,
+		tag,
+		keepOperationTag: true,
+		keepOperationPrefix: true
+	});
+}
+function getUniqueOperationNamesFromIndex(indexedOperations, operationsByTag, options, operationNameByOperation) {
+	const operationNames = [];
+	const nameIndexesByTag = /* @__PURE__ */ new Map();
+	for (const { path, method, operation, tag } of indexedOperations) {
+		let nameIndexes = nameIndexesByTag.get(tag);
+		if (!nameIndexes) {
+			const operations = operationsByTag[tag];
+			nameIndexes = [createOperationNameIndex({
+				operations,
+				options,
+				tag
+			}), createOperationNameIndex({
+				operations,
+				options,
+				tag,
+				keepOperationTag: true
+			})];
+			nameIndexesByTag.set(tag, nameIndexes);
+		}
+		const operationName = getUniqueOperationName({
+			path,
+			method,
+			operation,
+			operationsByTag,
+			options,
+			nameIndexes
+		});
+		operationNameByOperation?.set(operation, operationName);
+		operationNames.push(operationName);
+	}
+	return operationNames;
+}
+function getOperationIndex(openApiDoc, options) {
+	const operationsByTag = {};
+	const indexedOperations = [];
+	for (const path in openApiDoc.paths) {
+		if (isPathExcluded(path, options)) continue;
+		const pathItemObj = openApiDoc.paths[path];
+		const pathItem = pick(pathItemObj, ALLOWED_METHODS);
+		for (const method in pathItem) {
+			const operation = pathItem[method];
+			if (!operation || isOperationExcluded(operation, options)) continue;
+			const tag = options.splitByTags ? getOperationTag(operation, options) : options.defaultTag;
+			(operationsByTag[tag] ??= []).push(operation);
+			indexedOperations.push({
+				path,
+				method,
+				operation,
+				tag,
+				pathParameters: pathItemObj.parameters
+			});
+		}
+	}
+	const operationNameByOperation = /* @__PURE__ */ new WeakMap();
+	return {
+		operationsByTag,
+		operationNames: getUniqueOperationNamesFromIndex(indexedOperations, operationsByTag, options, operationNameByOperation),
+		operationNameByOperation,
+		indexedOperations
+	};
+}
+//#endregion
+//#region src/generators/core/openapi/getOpenAPISchemaDependencyGraph.ts
+function getOpenAPISchemaDependencyGraph(schemaRef, getSchemaByRef) {
+	const refsDependencyGraph = getRefsDependencyGraph(schemaRef, getSchemaByRef);
+	return {
+		refsDependencyGraph,
+		deepDependencyGraph: getDeepRefsDependencyGraph(schemaRef, refsDependencyGraph)
+	};
+}
+function getRefsDependencyGraph(schemaRef, getSchemaByRef) {
+	const visitedRefs = {};
+	const refsDependencyGraph = {};
+	schemaRef.forEach((ref) => getSchemaRefsDependencyGraph({
+		schema: getSchemaByRef(ref),
+		fromRef: ref,
+		getSchemaByRef,
+		visitedRefs,
+		refsDependencyGraph
+	}));
+	return refsDependencyGraph;
+}
+function getDeepRefsDependencyGraph(schemaRef, refsDependencyGraph) {
+	const visitedDeepRefs = {};
+	const deepDependencyGraph = {};
+	const visit = (dep, ref) => {
+		deepDependencyGraph[ref].add(dep);
+		if (refsDependencyGraph[dep] && ref !== dep) refsDependencyGraph[dep].forEach((transitive) => {
+			const refName = `${ref}__${transitive}`;
+			if (visitedDeepRefs[refName]) return;
+			visitedDeepRefs[refName] = true;
+			visit(transitive, ref);
+		});
+	};
+	schemaRef.forEach((ref) => {
+		const deps = refsDependencyGraph[ref];
+		if (!deps) return;
+		if (!deepDependencyGraph[ref]) deepDependencyGraph[ref] = /* @__PURE__ */ new Set();
+		deps.forEach((dep) => visit(dep, ref));
+	});
+	return deepDependencyGraph;
+}
+function getSchemaRefsDependencyGraph({ schema, fromRef, getSchemaByRef, visitedRefs = {}, refsDependencyGraph = {} }) {
+	const onSchema = (callbackData) => {
+		if (callbackData.type !== "reference" || !callbackData.data) return;
+		const { schema, data } = callbackData;
+		if (!refsDependencyGraph[data.fromRef]) refsDependencyGraph[data.fromRef] = /* @__PURE__ */ new Set();
+		refsDependencyGraph[data.fromRef].add(schema.$ref);
+		if (visitedRefs[schema.$ref]) return true;
+		visitedRefs[data.fromRef] = true;
+		iterateSchema(getSchemaByRef(schema.$ref), {
+			data: { fromRef: schema.$ref },
+			onSchema
+		});
+	};
+	iterateSchema(schema, {
+		data: { fromRef },
+		onSchema
+	});
+	return {
+		visitedRefs,
+		refsDependencyGraph
+	};
+}
+//#endregion
+//#region src/generators/core/openapi/getSchemaRefObjs.ts
+function getSchemaRefObjs(resolver, schema, schemaInfo) {
+	const schemaRefObjs = [];
+	const onSchema = (data) => {
+		if (data.type === "reference") schemaRefObjs.push(data.schema);
+		else if (isReferenceObject(data.parentSchema)) {
+			if (data.type === "property") resolver.validationErrors.push(getInvalidSchemaError(`${schemaInfo} has both reference and properties`));
+			else if (data.type === "additionalProperties") resolver.validationErrors.push(getInvalidSchemaError(`${schemaInfo} has both reference and additionalProperties`));
+			else if (data.type === "array") resolver.validationErrors.push(getInvalidSchemaError(`${schemaInfo} is both reference and array schema`));
+			else if (data.type === "composite") resolver.validationErrors.push(getInvalidSchemaError(`${schemaInfo} has both reference and composite keyword`));
+		}
+	};
+	iterateSchema(schema, { onSchema });
+	return schemaRefObjs;
+}
+function getDeepSchemaRefObjs(resolver, schemaRefs) {
+	return schemaRefs.map((schemaRef) => autocorrectRef(schemaRef.$ref)).reduce((acc, schemaRef) => {
+		const refs = resolver.dependencyGraph.deepDependencyGraph[schemaRef];
+		return [
+			...acc,
+			schemaRef,
+			...Array.from(refs ?? [])
+		];
+	}, []);
+}
+//#endregion
+//#region src/generators/core/zod/enumExtraction/resolveExtractedEnumZodSchemaNames.ts
+function resolveExtractedEnumZodSchemaNames(resolver) {
+	resolver.extractedEnumZodSchemaData.forEach((enumData) => {
+		const lastSegements = enumData.meta.zodSchemaNameSegments.map((arr) => arr[arr.length - 1]).filter(Boolean);
+		const mostCommonLastSegment = getMostCommonAdjacentCombinationSplit(lastSegements);
+		if (!mostCommonLastSegment) throw new Error(`No common last segment found for enum: ${enumData.code}`);
+		enumData.zodSchemaName = getEnumZodSchemaName(mostCommonLastSegment, resolver.options.enumSuffix, resolver.options.schemaSuffix);
+	});
+	let nameResolutionIterationsCounter = 0;
+	while (nameResolutionIterationsCounter < 5) {
+		if (allExtractedEnumZodSchemaNamesAreUnique(resolver)) break;
+		additionalResolveExtractedEnumZodSchemaName(resolver, nameResolutionIterationsCounter + 2);
+		nameResolutionIterationsCounter++;
+	}
+	if (!allExtractedEnumZodSchemaNamesAreUnique(resolver)) resolver.extractedEnumZodSchemaData.filter((enumData) => !isUnique(resolver, enumData)).forEach((enumData) => {
+		enumData.zodSchemaName = getEnumZodSchemaName(enumData.meta.zodSchemaNameSegments[0].map((name) => sanitizeName(capitalize(name))).join(""), resolver.options.enumSuffix, resolver.options.schemaSuffix);
+	});
+	if (!allExtractedEnumZodSchemaNamesAreUnique(resolver)) throw new Error("Failed to resolve unique names for enum zod schemas");
+}
+function allExtractedEnumZodSchemaNamesAreUnique(resolver) {
+	return resolver.extractedEnumZodSchemaData.every((enumData) => isUnique(resolver, enumData));
+}
+function additionalResolveExtractedEnumZodSchemaName(resolver, index) {
+	resolver.extractedEnumZodSchemaData.forEach((enumData) => {
+		const enumsDataWithSameName = resolver.extractedEnumZodSchemaData.filter(({ zodSchemaName }) => enumData.zodSchemaName === zodSchemaName);
+		if (enumsDataWithSameName.length === 1) return;
+		suffixWithPreviousSegmentName(enumsDataWithSameName, index);
+	});
+}
+function suffixWithPreviousSegmentName(enumsData, index = 2) {
+	enumsData.forEach((data) => {
+		const precedingLastFragments = data.meta.zodSchemaNameSegments.map((arr) => arr[arr.length - index]).filter(Boolean);
+		if (precedingLastFragments.length === 1) data.zodSchemaName = [sanitizeName(capitalize(precedingLastFragments[0])), data.zodSchemaName].filter(Boolean).join("");
+		else {
+			const secondLastFragmentSplit = getMostCommonAdjacentCombinationSplit(precedingLastFragments);
+			data.zodSchemaName = [secondLastFragmentSplit ? sanitizeName(capitalize(secondLastFragmentSplit)) : "", data.zodSchemaName].filter(Boolean).join("");
+		}
+	});
+}
+function isUnique(resolver, enumData) {
+	return resolver.extractedEnumZodSchemaData.filter(({ zodSchemaName }) => enumData.zodSchemaName === zodSchemaName).length === 1;
+}
+function sanitizeName(name) {
+	return name.replace(/(Dto|DTO|Response|Request)/g, "");
+}
+//#endregion
+//#region src/generators/core/zod/enumExtraction/resolveExtractedEnumZodSchemaTags.ts
+function resolveExtractedEnumZodSchemaTags(resolver) {
+	resolver.extractedEnumZodSchemaData.forEach((enumData) => {
+		const tags = getUniqueArray(enumData.meta.tags);
+		enumData.tag = tags.length === 1 ? tags[0] : resolver.options.defaultTag;
+	});
+}
+//#endregion
+//#region src/generators/core/zod/enumExtraction/updateExtractedEnumZodSchemaData.ts
+function updateExtractedEnumZodSchemaData({ schema, nameSegments = [], includeSelf, ...params }) {
+	if (!isReferenceObject(schema) && schema?.["x-domain-error-domain"]) return;
+	if (includeSelf) handleExtractedEnumZodSchemaDataUpdate({
+		schema,
+		nameSegments,
+		...params
+	});
+	const onSchema = (data) => {
+		if (data.type === "reference") return true;
+		const segments = [...data.data?.nameSegments ?? []];
+		if (data.type === "property") segments.push(data.propertyName);
+		handleExtractedEnumZodSchemaDataUpdate({
+			schema: data.schema,
+			nameSegments: [...segments],
+			...params
+		});
+	};
+	iterateSchema(schema, {
+		data: { nameSegments },
+		onSchema
+	});
+}
+function handleExtractedEnumZodSchemaDataUpdate({ resolver, schema, schemaRef, schemaInfo, tags, nameSegments = [] }) {
+	if (!schema || isReferenceObject(schema) || !schema.enum) return;
+	const code = getEnumZodSchemaCode(schema);
+	const enumZodSchema = resolver.extractedEnumZodSchemaData.find((data) => data.code === code);
+	if (enumZodSchema) {
+		enumZodSchema.meta.zodSchemaNameSegments.push(nameSegments);
+		enumZodSchema.meta.tags.push(...tags);
+		enumZodSchema.meta.schemaRefs.push(...schemaRef ? [schemaRef] : []);
+		enumZodSchema.meta.schemas.push(...schema ? [schema] : []);
+	} else resolver.extractedEnumZodSchemaData.push({
+		code,
+		meta: {
+			zodSchemaNameSegments: [nameSegments],
+			tags: [...tags],
+			schemaRefs: schemaRef ? [schemaRef] : [],
+			schemas: schema ? [schema] : []
+		}
+	});
+	resolver.validationErrors.push(getNotAllowedInlineEnumError(schemaRef ? `${getSchemaNameByRef(schemaRef)}.${nameSegments[nameSegments.length - 1]}` : schemaInfo ?? nameSegments.join(".")));
+}
+//#endregion
+//#region src/generators/core/zod/getZodSchemasFromOpenAPIDoc.ts
+function getZodSchemasFromOpenAPIDoc(resolver, profiler) {
+	const p = profiler ?? new Profiler(false);
+	const zodSchemas = {};
+	const enumZodSchemas = {};
+	Object.entries(resolver.openApiDoc.components?.schemas ?? {}).forEach(([name, schema]) => p.runSync("zod.extract.schemaEntry", () => {
+		const schemaData = resolver.getSchemaDataByName(name);
+		if (resolver.options.excludeRedundantZodSchemas && (!schemaData || schemaData.deepRefOperations.length === 0 && schemaData.tags.length === 0)) return;
+		const zodSchemaName = getZodSchemaName(name, resolver.options.schemaSuffix);
+		if (zodSchemas[zodSchemaName]) return;
+		const tag = resolver.getTagByZodSchemaName(zodSchemaName);
+		const schemaObject = resolver.resolveObject(schema);
+		if (schemaObject.enum) enumZodSchemas[zodSchemaName] = getEnumZodSchemaCode(schemaObject);
+		else {
+			const existingCode = resolver.getCodeByZodSchemaName(zodSchemaName);
+			if (existingCode !== void 0) {
+				zodSchemas[zodSchemaName] = existingCode;
+				return;
+			}
+			zodSchemas[zodSchemaName] = p.runSync("zod.extract.schemaToCode", () => getZodSchema({
+				schema,
+				resolver,
+				tag
+			}).getCodeString(tag));
+		}
+	}));
+	return {
+		zodSchemas,
+		enumZodSchemas
+	};
+}
+function getEnumZodSchemasFromOpenAPIDoc(resolver) {
+	const enumZodSchemas = [];
+	Object.entries(resolver.openApiDoc.components?.schemas ?? {}).forEach(([name, schema]) => {
+		const zodSchemaName = getZodSchemaName(name, resolver.options.schemaSuffix);
+		const schemaObject = resolver.resolveObject(schema);
+		if (schemaObject.enum) enumZodSchemas.push({
+			zodSchemaName,
+			code: getEnumZodSchemaCode(schemaObject)
+		});
+	});
+	return enumZodSchemas;
+}
+//#endregion
+//#region src/generators/core/SchemaResolver.class.ts
+var SchemaResolver = class {
+	openApiDoc;
+	options;
+	profiler;
+	schemaData = [];
+	zodSchemaData = [];
+	compositeZodSchemaData = [];
+	schemaRefs;
+	schemaByRef = /* @__PURE__ */ new Map();
+	schemaDataByRef = /* @__PURE__ */ new Map();
+	schemaDataByName = /* @__PURE__ */ new Map();
+	refByZodSchemaName = /* @__PURE__ */ new Map();
+	zodSchemaDataByName = /* @__PURE__ */ new Map();
+	compositeByCode = /* @__PURE__ */ new Map();
+	compositeSchemaByZodSchemaName = /* @__PURE__ */ new Map();
+	dependencyGraph;
+	enumZodSchemas = [];
+	extractedEnumZodSchemaData = [];
+	operationsByTag = {};
+	operationNames = [];
+	operationNameCounts = /* @__PURE__ */ new Map();
+	operationNameByOperation;
+	indexedOperations;
+	operationContexts = [];
+	zodSchemaTagCache;
+	validationErrors = [];
+	get docSchemas() {
+		return this.openApiDoc.components?.schemas ?? {};
+	}
+	constructor(openApiDoc, options, profiler) {
+		this.openApiDoc = openApiDoc;
+		this.options = options;
+		this.profiler = profiler;
+		const p = profiler ?? new Profiler(false);
+		this.schemaRefs = p.runSync("resolver.construct.schemaRefs", () => Object.keys(this.docSchemas).map(getSchemaRef));
+		this.dependencyGraph = p.runSync("resolver.construct.dependencyGraph", () => getOpenAPISchemaDependencyGraph(this.schemaRefs, this.getSchemaByRef.bind(this)));
+		this.enumZodSchemas = p.runSync("resolver.construct.enums", () => getEnumZodSchemasFromOpenAPIDoc(this));
+		const operationIndex = p.runSync("resolver.construct.operationIndex", () => getOperationIndex(openApiDoc, options));
+		this.operationsByTag = operationIndex.operationsByTag;
+		this.operationNames = operationIndex.operationNames;
+		this.operationNameByOperation = operationIndex.operationNameByOperation;
+		this.indexedOperations = operationIndex.indexedOperations;
+		p.runSync("resolver.construct.operationNameCounts", () => {
+			for (const name of this.operationNames) this.operationNameCounts.set(name, (this.operationNameCounts.get(name) ?? 0) + 1);
+		});
+		this.initialize();
+	}
+	getSchemaByRef(ref) {
+		const correctRef = autocorrectRef(ref);
+		const cachedSchema = this.schemaByRef.get(correctRef);
+		if (cachedSchema) return cachedSchema;
+		const schema = this.docSchemas[getSchemaNameByRef(correctRef)];
+		this.schemaByRef.set(correctRef, schema);
+		return schema;
+	}
+	getSchemaDataByName(name) {
+		return this.schemaDataByName.get(name);
+	}
+	getZodSchemaNameByRef(ref) {
+		const zodSchemaName = this.getSchemaDataByRef(autocorrectRef(ref))?.zodSchemaName ?? this.extractedEnumZodSchemaData.find((data) => data.zodSchemaName === ref)?.zodSchemaName;
+		if (!zodSchemaName) throw new Error(`Zod schema not found for ref: ${ref}`);
+		return zodSchemaName;
+	}
+	getRefByZodSchemaName(zodSchemaName) {
+		return this.refByZodSchemaName.get(zodSchemaName);
+	}
+	getTagByZodSchemaName(zodSchemaName) {
+		const cachedTag = this.zodSchemaTagCache?.get(zodSchemaName);
+		if (cachedTag) return cachedTag;
+		const tag = this.resolveTagByZodSchemaName(zodSchemaName);
+		this.zodSchemaTagCache?.set(zodSchemaName, tag);
+		return tag;
+	}
+	getTagsByZodSchemaName(zodSchemaName) {
+		if (!this.options.splitByTags) return [formatTag(this.options.defaultTag)];
+		const extractedEnum = this.extractedEnumZodSchemaData.find((data) => data.zodSchemaName === zodSchemaName);
+		if (extractedEnum) {
+			const tags = getUniqueArray(extractedEnum.meta.tags);
+			return (tags.length > 0 ? tags : [extractedEnum.tag ?? this.options.defaultTag]).map(formatTag);
+		}
+		const schemaRef = this.getRefByZodSchemaName(zodSchemaName);
+		const tags = getUniqueArray(schemaRef ? this.getSchemaDataByRef(schemaRef)?.tags ?? [] : [], this.zodSchemaDataByName.get(zodSchemaName)?.tags ?? []);
+		return (tags.length > 0 ? tags : [this.options.defaultTag]).map(formatTag);
+	}
+	enableZodSchemaTagCache() {
+		this.zodSchemaTagCache = /* @__PURE__ */ new Map();
+	}
+	resolveTagByZodSchemaName(zodSchemaName) {
+		if (!this.options.splitByTags) return this.options.defaultTag;
+		if (this.options.modelsInCommon) return formatTag(this.options.defaultTag);
+		const extractedEnumZodSchema = this.extractedEnumZodSchemaData.find((data) => data.zodSchemaName === zodSchemaName);
+		if (extractedEnumZodSchema) return formatTag(extractedEnumZodSchema.tag ?? this.options.defaultTag);
+		const schemaRef = this.getRefByZodSchemaName(zodSchemaName);
+		const schemaTags = schemaRef ? this.getSchemaDataByRef(schemaRef)?.tags ?? [] : [];
+		const zodSchemaTags = this.zodSchemaDataByName.get(zodSchemaName)?.tags ?? [];
+		const tags = getUniqueArray(schemaTags, zodSchemaTags);
+		const tag = tags.length === 1 ? tags[0] : this.options.defaultTag;
+		return formatTag(tag ?? this.options.defaultTag);
+	}
+	getCodeByZodSchemaName(name) {
+		return this.zodSchemaDataByName.get(name)?.code;
+	}
+	getZodSchemaNamesByCompositeCode(code) {
+		return this.compositeByCode.get(code)?.zodSchemas.map((schema) => schema.zodSchemaName);
+	}
+	setZodSchema(name, code, tag) {
+		const zodSchema = this.zodSchemaDataByName.get(name);
+		if (zodSchema) {
+			zodSchema.code = code;
+			zodSchema.tags = (zodSchema.tags ?? []).concat(tag);
+		} else {
+			const newZodSchemaData = {
+				zodSchemaName: name,
+				code,
+				tags: [tag]
+			};
+			this.zodSchemaData.push(newZodSchemaData);
+			this.zodSchemaDataByName.set(name, newZodSchemaData);
+		}
+	}
+	addZodSchemaForCompositeCode(code, zodSchema, zodSchemaName, schema) {
+		const compositeZodSchema = {
+			zodSchemaName,
+			zodSchema,
+			schema
+		};
+		const compositeData = this.compositeByCode.get(code);
+		if (compositeData) compositeData.zodSchemas.push(compositeZodSchema);
+		else {
+			const newCompositeData = {
+				code,
+				zodSchemas: [compositeZodSchema]
+			};
+			this.compositeZodSchemaData.push(newCompositeData);
+			this.compositeByCode.set(code, newCompositeData);
+		}
+		this.compositeSchemaByZodSchemaName.set(zodSchemaName, {
+			zodSchema,
+			schema
+		});
+	}
+	getCompositeZodSchemaByZodSchemaName(zodSchemaName) {
+		return this.compositeSchemaByZodSchemaName.get(zodSchemaName)?.zodSchema;
+	}
+	getSchemaByCompositeZodSchemaName(compositeZodSchemaName) {
+		return this.compositeSchemaByZodSchemaName.get(compositeZodSchemaName)?.schema;
+	}
+	getEnumZodSchemaDataByCode(code) {
+		return this.enumZodSchemas.find((data) => data.code === code);
+	}
+	getExtractedEnumZodSchemaDataByCode(code) {
+		return this.extractedEnumZodSchemaData.find((data) => data.code === code);
+	}
+	getExtractedEnumZodSchemaNamesReferencedBySchemaRef(schemaRef) {
+		return this.extractedEnumZodSchemaData.reduce((acc, { zodSchemaName, meta }) => {
+			if (zodSchemaName && meta.schemaRefs.includes(schemaRef)) return [...acc, zodSchemaName];
+			return acc;
+		}, []);
+	}
+	getZodSchemas() {
+		const zodSchemas = {};
+		for (const { zodSchemaName, code } of this.zodSchemaData) zodSchemas[zodSchemaName] = code;
+		return zodSchemas;
+	}
+	getExtractedEnumZodSchemas() {
+		const zodSchemas = {};
+		for (const { zodSchemaName, code } of this.extractedEnumZodSchemaData) if (zodSchemaName) zodSchemas[zodSchemaName] = code;
+		return zodSchemas;
+	}
+	resolveObject(obj) {
+		return isReferenceObject(obj) ? this.getSchemaByRef(obj.$ref) : obj;
+	}
+	isSchemaCircular(ref) {
+		return this.dependencyGraph.deepDependencyGraph[ref]?.has(ref);
+	}
+	getCircularSchemaChain(ref, currentRef = ref, chain = [], visited = []) {
+		if (visited.includes(currentRef)) return [];
+		visited.push(currentRef);
+		if (this.dependencyGraph.refsDependencyGraph[currentRef]?.has(ref)) return [
+			...chain,
+			currentRef,
+			ref
+		];
+		return Array.from(this.dependencyGraph.refsDependencyGraph[currentRef]?.values() ?? []).flatMap((childRef) => {
+			const childChain = this.getCircularSchemaChain(ref, childRef, chain, visited);
+			return childChain.length > 0 ? [currentRef, ...childChain] : childChain;
+		});
+	}
+	getBaseUrl() {
+		const serverUrl = this.openApiDoc.servers?.[0]?.url;
+		if (this.options.baseUrl === "" && serverUrl) return serverUrl;
+		return this.options.baseUrl;
+	}
+	isOperationNameUnique(operationName) {
+		return (this.operationNameCounts.get(operationName) ?? 0) <= 1;
+	}
+	getOperationContexts() {
+		return this.operationContexts;
+	}
+	getZodSchemaObj(zodSchemaName) {
+		const ref = this.getRefByZodSchemaName(zodSchemaName);
+		if (ref) return this.getSchemaByRef(ref);
+		const schema = this.getSchemaByCompositeZodSchemaName(zodSchemaName);
+		if (schema) return schema;
+		const enumZodSchemaData = this.getExtractedEnumZodSchemaDataByName(zodSchemaName);
+		if (enumZodSchemaData) {
+			const schemaObject = {};
+			for (const schema of enumZodSchemaData.meta.schemas) Object.assign(schemaObject, this.resolveObject(schema));
+			return schemaObject;
+		}
+	}
+	getSchemaDataByRef(ref) {
+		return this.schemaDataByRef.get(ref);
+	}
+	getExtractedEnumZodSchemaDataByName(enumZodSchemaName) {
+		return this.extractedEnumZodSchemaData.find(({ zodSchemaName }) => zodSchemaName === enumZodSchemaName);
+	}
+	initialize() {
+		const p = this.profiler ?? new Profiler(false);
+		p.runSync("resolver.init.seedSchemas", () => {
+			this.schemaRefs.forEach((ref) => {
+				const correctRef = autocorrectRef(ref);
+				const name = getSchemaNameByRef(correctRef);
+				const zodSchemaName = getZodSchemaName(name, this.options.schemaSuffix);
+				const data = {
+					ref: correctRef,
+					name,
+					zodSchemaName,
+					tags: [],
+					deepRefOperations: []
+				};
+				this.schemaData.push(data);
+				this.schemaDataByRef.set(correctRef, data);
+				this.schemaDataByName.set(name, data);
+				this.refByZodSchemaName.set(zodSchemaName, correctRef);
+			});
+		});
+		p.runSync("resolver.init.operationsLoop", () => {
+			let currentPath = "";
+			let pathParameters = {};
+			for (const { path, method, operation, pathParameters: rawPathParameters } of this.indexedOperations) {
+				if (path !== currentPath) {
+					currentPath = path;
+					pathParameters = this.getParameters(rawPathParameters ?? []);
+				}
+				const tag = getOperationTag(operation, this.options);
+				const operationName = this.operationNameByOperation.get(operation);
+				const isUniqueOperationName = this.isOperationNameUnique(operationName);
+				const parameters = p.runSync("resolver.init.parameters.mergeResolve", () => Object.entries({
+					...pathParameters,
+					...this.getParameters(operation.parameters ?? [])
+				}).map(([, param]) => this.resolveObject(param)));
+				const responses = p.runSync("resolver.init.responses.prepare", () => Object.entries(operation.responses).map(([statusCode, response]) => {
+					const responseObj = this.resolveObject(response);
+					const mediaTypes = Object.keys(responseObj?.content ?? {});
+					const matchingMediaType = mediaTypes.find((mediaType) => responseObj.content?.[mediaType]?.schema) ?? mediaTypes.find(isMediaTypeAllowed);
+					return {
+						statusCode,
+						responseObj,
+						matchingMediaType,
+						schema: matchingMediaType ? responseObj.content?.[matchingMediaType]?.schema : void 0
+					};
+				}));
+				const zodSchemaOperationName = snakeToCamel(getZodSchemaOperationName(operationName, isUniqueOperationName, tag));
+				const schemaRefObjs = [];
+				p.runSync("resolver.init.parameters.refs", () => {
+					parameters.forEach((parameter) => {
+						const parameterObject = this.resolveObject(parameter);
+						const parameterSchema = parameterObject.schema;
+						const schemaInfo = `Operation ${operation.operationId ?? path} parameter ${parameterObject.name}`;
+						schemaRefObjs.push(...getSchemaRefObjs(this, parameterSchema, schemaInfo));
+						if (this.options.extractEnums) updateExtractedEnumZodSchemaData({
+							resolver: this,
+							schema: parameterSchema,
+							schemaInfo,
+							tags: [tag],
+							nameSegments: [zodSchemaOperationName, parameterObject.name],
+							includeSelf: true
+						});
+					});
+				});
+				p.runSync("resolver.init.requestBody.refs", () => {
+					if (operation.requestBody) {
+						const requestBodyObj = this.resolveObject(operation.requestBody);
+						const matchingMediaType = Object.keys(requestBodyObj.content ?? {}).find(isParamMediaTypeAllowed);
+						if (matchingMediaType) {
+							const matchingMediaSchema = requestBodyObj.content?.[matchingMediaType]?.schema;
+							const schemaInfo = `Operation ${operation.operationId} request body`;
+							schemaRefObjs.push(...getSchemaRefObjs(this, matchingMediaSchema, schemaInfo));
+							if (this.options.extractEnums) updateExtractedEnumZodSchemaData({
+								resolver: this,
+								schema: matchingMediaSchema,
+								schemaInfo,
+								tags: [tag],
+								nameSegments: [getBodyZodSchemaName(zodSchemaOperationName)]
+							});
+						}
+					}
+				});
+				p.runSync("resolver.init.responses.refs", () => {
+					for (const responseData of responses) {
+						if (!responseData.matchingMediaType) continue;
+						const schemaInfo = `Operation ${operation.operationId} response body`;
+						schemaRefObjs.push(...getSchemaRefObjs(this, responseData.schema, schemaInfo));
+						if (this.options.extractEnums) updateExtractedEnumZodSchemaData({
+							resolver: this,
+							schema: responseData.schema,
+							schemaInfo,
+							tags: [tag],
+							nameSegments: [getResponseZodSchemaName({
+								statusCode: responseData.statusCode,
+								operationName,
+								isUniqueOperationName,
+								tag
+							})]
+						});
+					}
+				});
+				const deepRefs = p.runSync("resolver.init.deepRefs", () => getDeepSchemaRefObjs(this, schemaRefObjs));
+				const operationContext = {
+					path,
+					method,
+					operation,
+					tag,
+					operationName,
+					isUniqueOperationName,
+					parameters,
+					deepRefs,
+					responses
+				};
+				this.operationContexts.push(operationContext);
+				deepRefs.forEach((schemaRef) => {
+					const schemaData = this.getSchemaDataByRef(schemaRef);
+					if (schemaData) {
+						schemaData.tags.push(tag);
+						schemaData.deepRefOperations.push(operation);
+					}
+				});
+			}
+		});
+		if (this.options.extractEnums) p.runSync("resolver.init.enums.finalize", () => {
+			this.schemaRefs.forEach((ref) => {
+				const schemaRef = autocorrectRef(ref);
+				updateExtractedEnumZodSchemaData({
+					resolver: this,
+					schema: this.getSchemaByRef(schemaRef),
+					schemaRef,
+					tags: this.getSchemaDataByRef(schemaRef)?.tags ?? [],
+					nameSegments: [getSchemaNameByRef(schemaRef)]
+				});
+			});
+			resolveExtractedEnumZodSchemaTags(this);
+			this.handleDuplicateEnumZodSchemas();
+			resolveExtractedEnumZodSchemaNames(this);
+		});
+	}
+	handleDuplicateEnumZodSchemas() {
+		const codes = new Set(this.enumZodSchemas.map(({ code }) => code));
+		const duplicates = this.enumZodSchemas.filter(({ code }) => codes.has(code));
+		this.schemaData.forEach((schemaData) => {
+			const duplicateCode = duplicates.find(({ zodSchemaName }) => zodSchemaName === schemaData.zodSchemaName)?.code;
+			if (!duplicateCode) return;
+			const duplicate = this.extractedEnumZodSchemaData.find(({ code }) => code === duplicateCode);
+			if (!duplicate || this.getEnumZodSchemaDataByCode(duplicate.code)?.zodSchemaName !== schemaData.zodSchemaName) return;
+			schemaData.tags.push(...duplicate.meta.tags ?? []);
+			duplicate.meta.schemaRefs.forEach((ref) => {
+				if (!this.dependencyGraph.refsDependencyGraph[ref]) this.dependencyGraph.refsDependencyGraph[ref] = /* @__PURE__ */ new Set();
+				this.dependencyGraph.refsDependencyGraph[ref].add(schemaData.ref);
+				if (!this.dependencyGraph.deepDependencyGraph[ref]) this.dependencyGraph.deepDependencyGraph[ref] = /* @__PURE__ */ new Set();
+				this.dependencyGraph.deepDependencyGraph[ref].add(schemaData.ref);
+			});
+		});
+		this.extractedEnumZodSchemaData.splice(0, this.extractedEnumZodSchemaData.length, ...this.extractedEnumZodSchemaData.filter(({ code }) => !codes.has(code)));
+	}
+	getParameters(parameters) {
+		return Object.fromEntries((parameters ?? []).map((param) => [isReferenceObject(param) ? param.$ref : param.name, param]));
+	}
+};
+//#endregion
+//#region src/generators/utils/sort.utils.ts
+/** @see https://gist.github.com/RubyTuesdayDONO/5006455 */
+function topologicalSort(graph) {
+	const sorted = [];
+	const sortedNames = /* @__PURE__ */ new Set();
+	const visited = /* @__PURE__ */ new Set();
+	function visit(name, ancestors) {
+		ancestors.add(name);
+		visited.add(name);
+		if (graph[name]) graph[name].forEach((dep) => {
+			if (ancestors.has(dep)) return;
+			if (visited.has(dep)) return;
+			visit(dep, ancestors);
+		});
+		ancestors.delete(name);
+		if (!sortedNames.has(name)) {
+			sortedNames.add(name);
+			sorted.push(name);
+		}
+	}
+	Object.keys(graph).forEach((name) => visit(name, /* @__PURE__ */ new Set()));
+	return sorted;
+}
+/** Sort object keys using a reference order array, sort keys not in reference order in lasts positions */
+function sortObjKeysFromArray(obj, orderedKeys) {
+	const entries = Object.entries(obj);
+	const keyRanks = new Map(orderedKeys.map((key, index) => [key, index]));
+	const orderedEntries = [];
+	const remainingEntries = [];
+	for (const entry of entries) (keyRanks.has(entry[0]) ? orderedEntries : remainingEntries).push(entry);
+	orderedEntries.sort(([a], [b]) => keyRanks.get(a) - keyRanks.get(b));
+	return Object.fromEntries(orderedEntries.concat(remainingEntries));
+}
+//#endregion
+//#region src/generators/core/zod/sortZodSchemasByTopology.ts
+function sortZodSchemasByTopology(resolver, zodSchemas) {
+	return sortObjKeysFromArray(zodSchemas, topologicalSort(resolver.dependencyGraph.deepDependencyGraph).map((ref) => resolver.getZodSchemaNameByRef(ref)));
+}
+//#endregion
+//#region src/generators/core/getDataFromOpenAPIDoc.ts
+function getDataFromOpenAPIDoc(openApiDoc, options, profiler) {
+	const p = profiler ?? new Profiler(false);
+	const resolver = p.runSync("data.resolver.init", () => new SchemaResolver(openApiDoc, options, p));
+	const endpoints = p.runSync("data.endpoints.extract", () => getEndpointsFromOpenAPIDoc(resolver, p));
+	const zodSchemasFromDocSchemas = p.runSync("data.zod.extract", () => getZodSchemasFromOpenAPIDoc(resolver, p));
+	resolver.enableZodSchemaTagCache();
+	let zodSchemas = {
+		...zodSchemasFromDocSchemas.zodSchemas,
+		...resolver.getZodSchemas(),
+		...zodSchemasFromDocSchemas.enumZodSchemas
+	};
+	zodSchemas = p.runSync("data.zod.sortTopology", () => sortZodSchemasByTopology(resolver, zodSchemas));
+	zodSchemas = {
+		...resolver.getExtractedEnumZodSchemas(),
+		...zodSchemas
+	};
+	return {
+		resolver,
+		data: p.runSync("data.splitByTags", () => splitDataByTags({
+			resolver,
+			endpoints,
+			zodSchemas,
+			options
+		}))
+	};
+}
+function splitDataByTags({ resolver, endpoints, zodSchemas, options }) {
+	const data = /* @__PURE__ */ new Map();
+	if (!options.splitByTags) {
+		data.set(options.defaultTag, {
+			endpoints,
+			zodSchemas
+		});
+		return data;
+	}
+	endpoints.forEach((endpoint) => {
+		getTagElement(getEndpointTag(endpoint, options), data).endpoints.push(endpoint);
+	});
+	Object.entries(zodSchemas).forEach(([zodSchemaName, zodSchemaCode]) => {
+		if (options.modelsInModules) {
+			for (const tag of resolver.getTagsByZodSchemaName(zodSchemaName)) getTagElement(tag, data).zodSchemas[zodSchemaName] = zodSchemaCode;
+			return;
+		}
+		const tag = options.modelsInCommon ? options.defaultTag : resolver.getTagByZodSchemaName(zodSchemaName);
+		if (tag) getTagElement(tag, data).zodSchemas[zodSchemaName] = zodSchemaCode;
+	});
+	if (options.modelsInModules) for (const tagData of data.values()) {
+		const pending = Object.keys(tagData.zodSchemas);
+		for (let index = 0; index < pending.length; index++) for (const dependencyName of getZodSchemaRefs(resolver, pending[index])) {
+			if (tagData.zodSchemas[dependencyName] || !zodSchemas[dependencyName]) continue;
+			tagData.zodSchemas[dependencyName] = zodSchemas[dependencyName];
+			pending.push(dependencyName);
+		}
+	}
+	return data;
+}
+function getTagElement(tag, data) {
+	if (!data.has(tag)) data.set(tag, {
+		endpoints: [],
+		zodSchemas: {}
+	});
+	return data.get(tag);
+}
+//#endregion
+export { VALIDATION_ERROR_TYPE_TITLE as i, groupByType as n, getZodSchemaRefs as r, getDataFromOpenAPIDoc as t };