@povio/openapi-codegen-cli 3.2.0-rc.9 → 3.3.0-rc.2

package/dist/getDataFromOpenAPIDoc-D8w0QElH.mjs

@@ -1,2011 +0,0 @@
-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 "./native-bindings-BTQGSGhU.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 ? `get ${wrapWithQuotesIfNeeded(prop)}() { return ${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) 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) {
-	return `${ENUM_SCHEMA}([${schema.enum?.map((value) => value === null ? "null" : `"${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 };