@hey-api/shared 0.2.2 → 0.2.4

package/dist/index.mjs

@@ -1,7 +1,7 @@
 import colors from "ansi-colors";
 import fs from "node:fs";
 import path from "node:path";
-import ts from "typescript";
+import open from "open";
 import { sync } from "cross-spawn";
 import * as semver from "semver";
 import { getResolvedInput, sendRequest } from "@hey-api/json-schema-ref-parser";
@@ -54,12 +54,6 @@ function findTsConfigPath(baseDir, tsConfigPath) {
 	}
 	return null;
 }
-function loadTsConfig(configPath) {
-	if (!configPath) return null;
-	const raw = ts.readConfigFile(configPath, ts.sys.readFile);
-	if (raw.error) throw new Error(`Couldn't read tsconfig from path: ${configPath}`);
-	return ts.parseJsonConfigFileContent(raw.config, ts.sys, path.dirname(configPath));
-}
 
 //#endregion
 //#region src/cli.ts
@@ -91,6 +85,12 @@ const asciiToLines = (ascii, options) => {
 		maxLineLength
 	};
 };
+/**
+* Checks the current environment based on the HEYAPI_CODEGEN_ENV environment variable.
+*/
+function isEnvironment(value) {
+	return process.env.HEYAPI_CODEGEN_ENV === value;
+}
 function printCliIntro(initialDir, showLogo = false) {
 	const packageJson = loadPackageJson(initialDir);
 	if (packageJson) {
@@ -98,15 +98,16 @@ function printCliIntro(initialDir, showLogo = false) {
 			const text = asciiToLines(textAscii, { padding: 1 });
 			for (const line of text.lines) console.log(colors.cyan(line));
 		}
-		console.log(colors.gray(`${packageJson.name} v${packageJson.version}`));
+		const versionString = isEnvironment("development") ? "[DEVELOPMENT]" : `v${packageJson.version}`;
+		console.log(colors.gray(`${packageJson.name} ${versionString}`));
 	}
 	console.log("");
 }
 
 //#endregion
 //#region src/fs.ts
-function ensureDirSync(path$1) {
-	if (!fs.existsSync(path$1)) fs.mkdirSync(path$1, { recursive: true });
+function ensureDirSync(path) {
+	if (!fs.existsSync(path)) fs.mkdirSync(path, { recursive: true });
 }
 
 //#endregion
@@ -200,9 +201,7 @@ async function openGitHubIssueWithCrashReport(error, initialDir) {
 		labels: "bug 🔥",
 		title: "Crash Report"
 	});
-	const url = `${packageJson.bugs.url}new?${search.toString()}`;
-	const open = (await import("open")).default;
-	await open(url);
+	await open(`${packageJson.bugs.url}new?${search.toString()}`);
 }
 function printCrashReport({ error, logPath }) {
 	if (error instanceof ConfigValidationError && error.errors.length) {
@@ -422,7 +421,7 @@ function inputToApiRegistry(input) {
 		return;
 	}
 	if (input.path.startsWith(".")) return;
-	if (input.path.startsWith(heyApiRegistryBaseUrl)) {
+	if (input.path.startsWith("https://get.heyapi.dev")) {
 		input.path = input.path.slice(heyApiRegistryBaseUrl.length + 1);
 		Object.assign(input, inputToHeyApiPath(input));
 		return;
@@ -497,9 +496,9 @@ function compileInputPath(input) {
 	}
 	const [basePath, baseQuery] = input.path.split("?");
 	const queryPath = (baseQuery || "").split("&").map((part) => part.split("="));
-	let path$1 = basePath || "";
-	if (path$1.endsWith("/")) path$1 = path$1.slice(0, path$1.length - 1);
-	const [, pathUrl] = path$1.split("://");
+	let path = basePath || "";
+	if (path.endsWith("/")) path = path.slice(0, path.length - 1);
+	const [, pathUrl] = path.split("://");
 	const [baseUrl, organization, project] = (pathUrl || "").split("/");
 	result.organization = organization || input.organization;
 	result.project = project || input.project;
@@ -622,36 +621,36 @@ const mergeResult = (result, mapped) => {
 	for (const [key, value] of Object.entries(mapped)) if (value !== void 0 && value !== "") result[key] = value;
 	return result;
 };
-const valueToObject = ({ defaultValue, mappers: mappers$1, value }) => {
+const valueToObject = ({ defaultValue, mappers, value }) => {
 	let result = { ...defaultValue };
 	switch (typeof value) {
 		case "boolean":
-			if (mappers$1 && "boolean" in mappers$1) {
-				const mapper = mappers$1.boolean;
+			if (mappers && "boolean" in mappers) {
+				const mapper = mappers.boolean;
 				result = mergeResult(result, mapper(value));
 			}
 			break;
 		case "function":
-			if (mappers$1 && "function" in mappers$1) {
-				const mapper = mappers$1.function;
+			if (mappers && "function" in mappers) {
+				const mapper = mappers.function;
 				result = mergeResult(result, mapper(value));
 			}
 			break;
 		case "number":
-			if (mappers$1 && "number" in mappers$1) {
-				const mapper = mappers$1.number;
+			if (mappers && "number" in mappers) {
+				const mapper = mappers.number;
 				result = mergeResult(result, mapper(value));
 			}
 			break;
 		case "string":
-			if (mappers$1 && "string" in mappers$1) {
-				const mapper = mappers$1.string;
+			if (mappers && "string" in mappers) {
+				const mapper = mappers.string;
 				result = mergeResult(result, mapper(value));
 			}
 			break;
 		case "object":
-			if (isPlainObject(value)) if (mappers$1 && "object" in mappers$1 && typeof mappers$1.object === "function") {
-				const mapper = mappers$1.object;
+			if (isPlainObject(value)) if (mappers && "object" in mappers && typeof mappers.object === "function") {
+				const mapper = mappers.object;
 				result = mergeResult(result, mapper(value, defaultValue));
 			} else result = mergeResult(result, value);
 			break;
@@ -723,50 +722,50 @@ function getParser(userConfig) {
 			}),
 			transforms: valueToObject({
 				defaultValue: { ...defaultValue.transforms },
-				mappers: { object: (fields$1, defaultValue$1) => ({
-					...fields$1,
+				mappers: { object: (fields, defaultValue) => ({
+					...fields,
 					enums: valueToObject({
 						defaultValue: {
-							...defaultValue$1.enums,
-							enabled: fields$1.enums !== void 0 ? Boolean(fields$1.enums) : defaultValue$1.enums.enabled
+							...defaultValue.enums,
+							enabled: fields.enums !== void 0 ? Boolean(fields.enums) : defaultValue.enums.enabled
 						},
 						mappers: {
 							boolean: (enabled) => ({ enabled }),
 							string: (mode) => ({ mode })
 						},
-						value: fields$1.enums
+						value: fields.enums
 					}),
-					propertiesRequiredByDefault: fields$1.propertiesRequiredByDefault !== void 0 ? fields$1.propertiesRequiredByDefault : defaultValue$1.propertiesRequiredByDefault,
+					propertiesRequiredByDefault: fields.propertiesRequiredByDefault !== void 0 ? fields.propertiesRequiredByDefault : defaultValue.propertiesRequiredByDefault,
 					readWrite: valueToObject({
 						defaultValue: {
-							...defaultValue$1.readWrite,
-							enabled: fields$1.readWrite !== void 0 ? Boolean(fields$1.readWrite) : defaultValue$1.readWrite.enabled
+							...defaultValue.readWrite,
+							enabled: fields.readWrite !== void 0 ? Boolean(fields.readWrite) : defaultValue.readWrite.enabled
 						},
 						mappers: {
 							boolean: (enabled) => ({ enabled }),
-							object: (fields$2, defaultValue$2) => ({
-								...fields$2,
+							object: (fields, defaultValue) => ({
+								...fields,
 								requests: valueToObject({
-									defaultValue: { ...defaultValue$2.requests },
+									defaultValue: { ...defaultValue.requests },
 									mappers: {
 										function: (name) => ({ name }),
 										string: (name) => ({ name })
 									},
-									value: fields$2.requests
+									value: fields.requests
 								}),
 								responses: valueToObject({
-									defaultValue: { ...defaultValue$2.responses },
+									defaultValue: { ...defaultValue.responses },
 									mappers: {
 										function: (name) => ({ name }),
 										string: (name) => ({ name })
 									},
-									value: fields$2.responses
+									value: fields.responses
 								})
 							})
 						},
-						value: fields$1.readWrite
+						value: fields.readWrite
 					}),
-					schemaName: fields$1.schemaName !== void 0 ? fields$1.schemaName : defaultValue$1.schemaName
+					schemaName: fields.schemaName !== void 0 ? fields.schemaName : defaultValue.schemaName
 				}) },
 				value: fields.transforms
 			}),
@@ -803,31 +802,31 @@ function dependencyFactory(dependencies) {
 
 //#endregion
 //#region src/debug/graph.ts
-const analyzeStructure = (graph$1) => {
+const analyzeStructure = (graph) => {
 	let maxDepth = 0;
 	let maxChildren = 0;
 	const computeDepth = (pointer, depth) => {
 		maxDepth = Math.max(maxDepth, depth);
-		const children = Array.from(graph$1.nodes.entries()).filter(([, nodeInfo]) => nodeInfo.parentPointer === pointer).map(([childPointer]) => childPointer);
+		const children = Array.from(graph.nodes.entries()).filter(([, nodeInfo]) => nodeInfo.parentPointer === pointer).map(([childPointer]) => childPointer);
 		maxChildren = Math.max(maxChildren, children.length);
 		for (const childPointer of children) computeDepth(childPointer, depth + 1);
 	};
-	const totalNodes = graph$1.nodes.size;
-	if (graph$1.nodes.has("#")) computeDepth("#", 1);
+	const totalNodes = graph.nodes.size;
+	if (graph.nodes.has("#")) computeDepth("#", 1);
 	return {
 		maxChildren,
 		maxDepth,
 		totalNodes
 	};
 };
-const exportForVisualization = (graph$1) => {
+const exportForVisualization = (graph) => {
 	const childrenMap = /* @__PURE__ */ new Map();
-	for (const [pointer, nodeInfo] of graph$1.nodes) {
+	for (const [pointer, nodeInfo] of graph.nodes) {
 		if (!nodeInfo.parentPointer) continue;
 		if (!childrenMap.has(nodeInfo.parentPointer)) childrenMap.set(nodeInfo.parentPointer, []);
 		childrenMap.get(nodeInfo.parentPointer).push(pointer);
 	}
-	return Array.from(graph$1.nodes.keys()).map((pointer) => ({
+	return Array.from(graph.nodes.keys()).map((pointer) => ({
 		children: childrenMap.get(pointer)?.length ?? 0,
 		childrenPointers: childrenMap.get(pointer) || [],
 		pointer
@@ -994,7 +993,7 @@ const hasOperationDataRequired = (operation) => {
 	if (operation.body?.required) return true;
 	return false;
 };
-const createOperationKey = ({ method, path: path$1 }) => `${method.toUpperCase()} ${path$1}`;
+const createOperationKey = ({ method, path }) => `${method.toUpperCase()} ${path}`;
 const operationPagination = ({ context, operation }) => {
 	const body = operation.body;
 	if (!body || !body.pagination) return parameterWithPagination({
@@ -1110,7 +1109,7 @@ const uppercaseRegExp = /[\p{Lu}]/u;
 const lowercaseRegExp = /[\p{Ll}]/u;
 const identifierRegExp = /([\p{Alpha}\p{N}_]|$)/u;
 const separatorsRegExp = /[_.$+:\- `\\[\](){}\\/]+/;
-const leadingSeparatorsRegExp = /* @__PURE__ */ new RegExp(`^${separatorsRegExp.source}`);
+const leadingSeparatorsRegExp = new RegExp(`^${separatorsRegExp.source}`);
 const separatorsAndIdentifierRegExp = new RegExp(`${separatorsRegExp.source}${identifierRegExp.source}`, "gu");
 const numbersAndIdentifierRegExp = new RegExp(`\\d+${identifierRegExp.source}`, "gu");
 const preserveCase = (value, casing) => {
@@ -1258,24 +1257,24 @@ const sanitizeNamespaceIdentifier = (name) => name.replace(/^[^\p{ID_Start}]+/u,
 *
 * @deprecated
 */
-function operationToId({ context, count = 1, id, method, path: path$1, state }) {
+function operationToId({ context, count = 1, id, method, path, state }) {
 	let result;
 	const { output } = context.config;
 	const targetCase = (output !== void 0 && typeof output === "object" && "case" in output ? output.case : void 0) ?? "camelCase";
 	if (id && (!context.config.plugins["@hey-api/sdk"] || context.config.plugins["@hey-api/sdk"].config.operations && typeof context.config.plugins["@hey-api/sdk"].config.operations !== "function" && typeof context.config.plugins["@hey-api/sdk"].config.operations === "object" && context.config.plugins["@hey-api/sdk"].config.operations.nesting === "operationId")) result = toCase(sanitizeNamespaceIdentifier(id), targetCase);
-	else result = toCase(`${method}-${path$1.replace(/{(.*?)}/g, "by-$1").replace(/[/:+]/g, "-")}`, targetCase);
+	else result = toCase(`${method}-${path.replace(/{(.*?)}/g, "by-$1").replace(/[/:+]/g, "-")}`, targetCase);
 	if (count > 1) result = `${result}${count}`;
 	if (state.ids.has(result)) return operationToId({
 		context,
 		count: count + 1,
 		id,
 		method,
-		path: path$1,
+		path,
 		state
 	});
 	state.ids.set(result, createOperationKey({
 		method,
-		path: path$1
+		path
 	}));
 	return result;
 }
@@ -1284,7 +1283,7 @@ function operationToId({ context, count = 1, id, method, path: path$1, state })
 //#region src/debug/ir.ts
 const indent = (level) => "  ".repeat(level);
 const log = (message, level) => console.log(`${indent(level ?? 0)}${message}`);
-const print = (ir$1, options = {}) => {
+const print = (ir, options = {}) => {
 	const { depth = 2, section = "all", verbosity = "summary" } = options;
 	const printObject = (obj, level, kind = "generic") => {
 		if (verbosity === "summary" && obj && typeof obj === "object") if (kind === "responses") {
@@ -1309,25 +1308,25 @@ const print = (ir$1, options = {}) => {
 			if (operation.responses) printObject(operation.responses, base + 1, "responses");
 		}
 	};
-	const sections = section === "all" ? Object.keys(ir$1) : [section];
-	for (const section$1 of sections) switch (section$1) {
+	const sections = section === "all" ? Object.keys(ir) : [section];
+	for (const section of sections) switch (section) {
 		case "components":
-			if (ir$1.components?.schemas) {
-				log(`Components: ${Object.keys(ir$1.components.schemas).length} schemas`);
-				for (const [, schema] of Object.entries(ir$1.components.schemas)) printObject(schema, 1, "schema");
+			if (ir.components?.schemas) {
+				log(`Components: ${Object.keys(ir.components.schemas).length} schemas`);
+				for (const [, schema] of Object.entries(ir.components.schemas)) printObject(schema, 1, "schema");
 			}
 			break;
 		case "paths": {
-			const paths = ir$1.paths || {};
+			const paths = ir.paths || {};
 			log(`paths (${Object.keys(paths).length} items):`);
-			for (const [path$1, item] of Object.entries(paths)) printPathItem(path$1, item);
+			for (const [path, item] of Object.entries(paths)) printPathItem(path, item);
 			break;
 		}
 		case "servers": break;
 		case "webhooks": {
-			const webhooks = ir$1.webhooks || {};
+			const webhooks = ir.webhooks || {};
 			log(`webhooks (${Object.keys(webhooks).length} items):`);
-			for (const [path$1, item] of Object.entries(webhooks)) printPathItem(path$1, item);
+			for (const [path, item] of Object.entries(webhooks)) printPathItem(path, item);
 			break;
 		}
 	}
@@ -1533,8 +1532,8 @@ var MinHeap = class {
 * is not required and the caller only wants nodes in the order they were
 * added to the graph.
 */
-const walkDeclarations = (graph$1, callback, options) => {
-	const pointers = Array.from(graph$1.nodes.keys());
+const walkDeclarations = (graph, callback, options) => {
+	const pointers = Array.from(graph.nodes.keys());
 	if (options?.preferGroups && options.preferGroups.length > 0) {
 		const emitted = /* @__PURE__ */ new Set();
 		if (options.matchPointerToGroup) for (const kind of options.preferGroups) for (const pointer of pointers) {
@@ -1542,16 +1541,16 @@ const walkDeclarations = (graph$1, callback, options) => {
 			if (!result.matched) continue;
 			if (result.kind === kind) {
 				emitted.add(pointer);
-				callback(pointer, graph$1.nodes.get(pointer));
+				callback(pointer, graph.nodes.get(pointer));
 			}
 		}
 		for (const pointer of pointers) {
 			if (emitted.has(pointer)) continue;
-			callback(pointer, graph$1.nodes.get(pointer));
+			callback(pointer, graph.nodes.get(pointer));
 		}
 		return;
 	}
-	for (const pointer of pointers) callback(pointer, graph$1.nodes.get(pointer));
+	for (const pointer of pointers) callback(pointer, graph.nodes.get(pointer));
 };
 /**
 * Walks the nodes of the graph in topological order (dependencies before dependents).
@@ -1561,8 +1560,8 @@ const walkDeclarations = (graph$1, callback, options) => {
 * @param graph - The dependency graph
 * @param callback - Function to call for each node pointer
 */
-const walkTopological = (graph$1, callback, options) => {
-	const pointers = Array.from(graph$1.nodes.keys());
+const walkTopological = (graph, callback, options) => {
+	const pointers = Array.from(graph.nodes.keys());
 	const baseIndex = /* @__PURE__ */ new Map();
 	pointers.forEach((pointer, index) => baseIndex.set(pointer, index));
 	const declIndex = /* @__PURE__ */ new Map();
@@ -1572,11 +1571,11 @@ const walkTopological = (graph$1, callback, options) => {
 	}
 	const depsOf = /* @__PURE__ */ new Map();
 	for (const pointer of pointers) {
-		const raw = graph$1.subtreeDependencies?.get(pointer) ?? /* @__PURE__ */ new Set();
+		const raw = graph.subtreeDependencies?.get(pointer) ?? /* @__PURE__ */ new Set();
 		const filtered = /* @__PURE__ */ new Set();
 		for (const rawPointer of raw) {
 			if (rawPointer === pointer) continue;
-			if (graph$1.nodes.has(rawPointer)) filtered.add(rawPointer);
+			if (graph.nodes.has(rawPointer)) filtered.add(rawPointer);
 		}
 		depsOf.set(pointer, filtered);
 	}
@@ -1643,11 +1642,11 @@ const walkTopological = (graph$1, callback, options) => {
 			return false;
 		})()) finalOrder = proposed;
 	}
-	for (const pointer of finalOrder) callback(pointer, graph$1.nodes.get(pointer));
+	for (const pointer of finalOrder) callback(pointer, graph.nodes.get(pointer));
 };
-const walk = (graph$1, callback, options) => {
-	if (options?.order === "topological") return walkTopological(graph$1, callback, options);
-	return walkDeclarations(graph$1, callback, options);
+const walk = (graph, callback, options) => {
+	if (options?.order === "topological") return walkTopological(graph, callback, options);
+	return walkDeclarations(graph, callback, options);
 };
 
 //#endregion
@@ -1681,9 +1680,9 @@ const matchIrPointerToGroup = (pointer, kind) => {
 		matched: true
 	} : { matched: false };
 	for (const key of Object.keys(patterns)) {
-		const kind$1 = key;
-		if (patterns[kind$1].test(pointer)) return {
-			kind: kind$1,
+		const kind = key;
+		if (patterns[kind].test(pointer)) return {
+			kind,
 			matched: true
 		};
 	}
@@ -1721,8 +1720,8 @@ const jsonPointerTilde = /~0/g;
 * Returns the reusable component name from `$ref`.
 */
 function refToName($ref) {
-	const path$1 = jsonPointerToPath($ref);
-	const name = path$1[path$1.length - 1];
+	const path = jsonPointerToPath($ref);
+	const name = path[path.length - 1];
 	return decodeURI(name);
 }
 /**
@@ -1782,8 +1781,8 @@ function normalizeJsonPointer(pointer) {
 * @param path
 * @returns
 */
-function pathToJsonPointer(path$1) {
-	const segments = path$1.map(encodeJsonPointerSegment).join("/");
+function pathToJsonPointer(path) {
+	const segments = path.map(encodeJsonPointerSegment).join("/");
 	return "#" + (segments ? `/${segments}` : "");
 }
 /**
@@ -1800,15 +1799,15 @@ function pathToJsonPointer(path$1) {
 * @returns true if the ref points to a top-level component, false otherwise
 */
 function isTopLevelComponent(refOrPath) {
-	const path$1 = refOrPath instanceof Array ? refOrPath : jsonPointerToPath(refOrPath);
-	if (path$1[0] === "components") return path$1.length === 3;
-	if (path$1[0] === "definitions") return path$1.length === 2;
+	const path = refOrPath instanceof Array ? refOrPath : jsonPointerToPath(refOrPath);
+	if (path[0] === "components") return path.length === 3;
+	if (path[0] === "definitions") return path.length === 2;
 	return false;
 }
 function resolveRef({ $ref, spec }) {
-	const path$1 = jsonPointerToPath(decodeURI($ref));
+	const path = jsonPointerToPath(decodeURI($ref));
 	let current = spec;
-	for (const part of path$1) {
+	for (const part of path) {
 		const segment = part;
 		if (current[segment] === void 0) throw new Error(`Reference not found: ${$ref}`);
 		current = current[segment];
@@ -1822,6 +1821,7 @@ const defaultGetFilePath = (symbol) => {
 	if (!symbol.meta?.pluginName || typeof symbol.meta.pluginName !== "string") return;
 	if (symbol.meta.pluginName.startsWith("@hey-api/client-")) return "client";
 	if (symbol.meta.pluginName === "@hey-api/typescript") return "types";
+	if (symbol.meta.pluginName === "@hey-api/python-sdk") return "sdk";
 	if (symbol.meta.pluginName.startsWith("@hey-api/")) return symbol.meta.pluginName.split("/")[1];
 	return symbol.meta.pluginName;
 };
@@ -2027,7 +2027,7 @@ var PluginInstance = class {
 		return this.gen.symbols.reference(meta);
 	}
 	/**
-	* @deprecated use `plugin.symbol()` instead
+	* Alias for `symbol()` method with single argument.
 	*/
 	registerSymbol(symbol) {
 		return this.symbol(symbol.name, symbol);
@@ -2264,10 +2264,10 @@ var IntentContext = class {
 	constructor(spec) {
 		this.spec = spec;
 	}
-	getOperation(path$1, method) {
+	getOperation(path, method) {
 		const paths = this.spec.paths;
 		if (!paths) return;
-		return paths[path$1]?.[method];
+		return paths[path]?.[method];
 	}
 	setExample(operation, example) {
 		const source = this.getOperation(operation.path, operation.method);
@@ -2290,11 +2290,11 @@ function createSchemaProcessor() {
 				tags: contextTags
 			};
 		},
-		hasEmitted(path$1) {
-			return emitted.has(pathToJsonPointer(path$1));
+		hasEmitted(path) {
+			return emitted.has(pathToJsonPointer(path));
 		},
-		markEmitted(path$1) {
-			const pointer = pathToJsonPointer(path$1);
+		markEmitted(path) {
+			const pointer = pathToJsonPointer(path);
 			if (emitted.has(pointer)) return false;
 			emitted.add(pointer);
 			return true;
@@ -2325,21 +2325,21 @@ function createSchemaProcessor() {
 * - Path tracking for child schemas
 */
 function createSchemaWalker(visitor) {
-	const walk$1 = (schema, ctx) => {
+	const walk = (schema, ctx) => {
 		if (visitor.intercept) {
-			const intercepted = visitor.intercept(schema, ctx, walk$1);
+			const intercepted = visitor.intercept(schema, ctx, walk);
 			if (intercepted !== void 0) return intercepted;
 		}
 		if (schema.$ref) return visitor.reference(schema.$ref, schema, ctx);
 		if (schema.type) {
-			let result = visitTyped(schema, ctx, visitor, walk$1);
+			let result = visitTyped(schema, ctx, visitor, walk);
 			if (visitor.postProcess) result = visitor.postProcess(result, schema, ctx);
 			return result;
 		}
 		if (schema.items) {
 			const deduplicated = deduplicateSchema({ schema });
-			if (!deduplicated.items) return walk$1(deduplicated, ctx);
-			const itemResults = deduplicated.items.map((item, index) => walk$1(item, {
+			if (!deduplicated.items) return walk(deduplicated, ctx);
+			const itemResults = deduplicated.items.map((item, index) => walk(item, {
 				...ctx,
 				path: ref([
 					...fromRef(ctx.path),
@@ -2351,23 +2351,23 @@ function createSchemaWalker(visitor) {
 		}
 		return visitor.unknown({ type: "unknown" }, ctx);
 	};
-	return walk$1;
+	return walk;
 }
 /**
 * Dispatch to the appropriate visitor method based on schema type.
 */
-function visitTyped(schema, ctx, visitor, walk$1) {
+function visitTyped(schema, ctx, visitor, walk) {
 	switch (schema.type) {
-		case "array": return visitor.array(schema, ctx, walk$1);
+		case "array": return visitor.array(schema, ctx, walk);
 		case "boolean": return visitor.boolean(schema, ctx);
-		case "enum": return visitor.enum(schema, ctx, walk$1);
+		case "enum": return visitor.enum(schema, ctx, walk);
 		case "integer": return visitor.integer(schema, ctx);
 		case "never": return visitor.never(schema, ctx);
 		case "null": return visitor.null(schema, ctx);
 		case "number": return visitor.number(schema, ctx);
-		case "object": return visitor.object(schema, ctx, walk$1);
+		case "object": return visitor.object(schema, ctx, walk);
 		case "string": return visitor.string(schema, ctx);
-		case "tuple": return visitor.tuple(schema, ctx, walk$1);
+		case "tuple": return visitor.tuple(schema, ctx, walk);
 		case "undefined": return visitor.undefined(schema, ctx);
 		case "unknown": return visitor.unknown(schema, ctx);
 		case "void": return visitor.void(schema, ctx);
@@ -2386,7 +2386,7 @@ function childContext(ctx, ...segments) {
 //#endregion
 //#region src/openApi/shared/utils/filter.ts
 const namespaceNeedle = "/";
-const addNamespace = (namespace$2, value = "") => `${namespace$2}${namespaceNeedle}${value}`;
+const addNamespace = (namespace, value = "") => `${namespace}${namespaceNeedle}${value}`;
 const removeNamespace = (key) => {
 	const index = key.indexOf(namespaceNeedle);
 	return {
@@ -2421,13 +2421,13 @@ const createFiltersSetAndRegExps = (type, filters) => {
 };
 const collectFiltersSetFromRegExpsOpenApiV2 = ({ excludeOperations, excludeSchemas, includeOperations, includeSchemas, spec }) => {
 	if ((excludeOperations.regexps.length || includeOperations.regexps.length) && spec.paths) for (const entry of Object.entries(spec.paths)) {
-		const path$1 = entry[0];
+		const path = entry[0];
 		const pathItem = entry[1];
 		for (const method of httpMethods) {
 			if (!pathItem[method]) continue;
 			const key = createOperationKey({
 				method,
-				path: path$1
+				path
 			});
 			if (excludeOperations.regexps.some((regexp) => regexp.test(key))) excludeOperations.set.add(addNamespace("operation", key));
 			if (includeOperations.regexps.some((regexp) => regexp.test(key))) includeOperations.set.add(addNamespace("operation", key));
@@ -2442,13 +2442,13 @@ const collectFiltersSetFromRegExpsOpenApiV2 = ({ excludeOperations, excludeSchem
 };
 const collectFiltersSetFromRegExpsOpenApiV3 = ({ excludeOperations, excludeParameters, excludeRequestBodies, excludeResponses, excludeSchemas, includeOperations, includeParameters, includeRequestBodies, includeResponses, includeSchemas, spec }) => {
 	if ((excludeOperations.regexps.length || includeOperations.regexps.length) && spec.paths) for (const entry of Object.entries(spec.paths)) {
-		const path$1 = entry[0];
+		const path = entry[0];
 		const pathItem = entry[1];
 		for (const method of httpMethods) {
 			if (!pathItem[method]) continue;
 			const key = createOperationKey({
 				method,
-				path: path$1
+				path
 			});
 			if (excludeOperations.regexps.some((regexp) => regexp.test(key))) excludeOperations.set.add(addNamespace("operation", key));
 			if (includeOperations.regexps.some((regexp) => regexp.test(key))) includeOperations.set.add(addNamespace("operation", key));
@@ -2560,8 +2560,8 @@ const collectOperations = ({ filters, parameters, requestBodies, resourceMetadat
 		if (filters.tags.exclude.size && node.tags.size && [...filters.tags.exclude].some((tag) => node.tags.has(tag))) continue;
 		if (filters.tags.include.size && !new Set([...filters.tags.include].filter((tag) => node.tags.has(tag))).size) continue;
 		if ([...node.dependencies].some((dependency) => {
-			const { namespace: namespace$2 } = removeNamespace(dependency);
-			switch (namespace$2) {
+			const { namespace } = removeNamespace(dependency);
+			switch (namespace) {
 				case "body": return !requestBodies.has(dependency);
 				case "parameter": return !parameters.has(dependency);
 				case "response": return !responses.has(dependency);
@@ -2588,8 +2588,8 @@ const collectParameters = ({ filters, resourceMetadata, schemas }) => {
 		finalSet.add(key);
 		if (!node.dependencies.size) continue;
 		for (const dependency of node.dependencies) {
-			const { namespace: namespace$2 } = removeNamespace(dependency);
-			switch (namespace$2) {
+			const { namespace } = removeNamespace(dependency);
+			switch (namespace) {
 				case "body":
 					if (filters.requestBodies.exclude.has(dependency)) finalSet.delete(key);
 					else if (!finalSet.has(dependency)) stack.push(dependency);
@@ -2618,8 +2618,8 @@ const collectRequestBodies = ({ filters, resourceMetadata, schemas }) => {
 		finalSet.add(key);
 		if (!node.dependencies.size) continue;
 		for (const dependency of node.dependencies) {
-			const { namespace: namespace$2 } = removeNamespace(dependency);
-			switch (namespace$2) {
+			const { namespace } = removeNamespace(dependency);
+			switch (namespace) {
 				case "body":
 					if (filters.requestBodies.exclude.has(dependency)) finalSet.delete(key);
 					else if (!finalSet.has(dependency)) stack.push(dependency);
@@ -2648,8 +2648,8 @@ const collectResponses = ({ filters, resourceMetadata, schemas }) => {
 		finalSet.add(key);
 		if (!node.dependencies.size) continue;
 		for (const dependency of node.dependencies) {
-			const { namespace: namespace$2 } = removeNamespace(dependency);
-			switch (namespace$2) {
+			const { namespace } = removeNamespace(dependency);
+			switch (namespace) {
 				case "body":
 					if (filters.requestBodies.exclude.has(dependency)) finalSet.delete(key);
 					else if (!finalSet.has(dependency)) stack.push(dependency);
@@ -2678,8 +2678,8 @@ const collectSchemas = ({ filters, resourceMetadata }) => {
 		finalSet.add(key);
 		if (!node.dependencies.size) continue;
 		for (const dependency of node.dependencies) {
-			const { namespace: namespace$2 } = removeNamespace(dependency);
-			switch (namespace$2) {
+			const { namespace } = removeNamespace(dependency);
+			switch (namespace) {
 				case "schema":
 					if (!finalSet.has(dependency) && !filters.schemas.exclude.has(dependency)) stack.push(dependency);
 					break;
@@ -2757,13 +2757,13 @@ const collectOperationDependencies = ({ operations, resourceMetadata }) => {
 		const key = stack.pop();
 		if (finalSet.has(key)) continue;
 		finalSet.add(key);
-		const { namespace: namespace$2 } = removeNamespace(key);
+		const { namespace } = removeNamespace(key);
 		let dependencies;
-		if (namespace$2 === "body") dependencies = resourceMetadata.requestBodies.get(key)?.dependencies;
-		else if (namespace$2 === "operation") dependencies = resourceMetadata.operations.get(key)?.dependencies;
-		else if (namespace$2 === "parameter") dependencies = resourceMetadata.parameters.get(key)?.dependencies;
-		else if (namespace$2 === "response") dependencies = resourceMetadata.responses.get(key)?.dependencies;
-		else if (namespace$2 === "schema") dependencies = resourceMetadata.schemas.get(key)?.dependencies;
+		if (namespace === "body") dependencies = resourceMetadata.requestBodies.get(key)?.dependencies;
+		else if (namespace === "operation") dependencies = resourceMetadata.operations.get(key)?.dependencies;
+		else if (namespace === "parameter") dependencies = resourceMetadata.parameters.get(key)?.dependencies;
+		else if (namespace === "response") dependencies = resourceMetadata.responses.get(key)?.dependencies;
+		else if (namespace === "schema") dependencies = resourceMetadata.schemas.get(key)?.dependencies;
 		if (!dependencies?.size) continue;
 		for (const dependency of dependencies) if (!finalSet.has(dependency)) stack.push(dependency);
 	}
@@ -2847,7 +2847,7 @@ const createFilteredDependencies = ({ filters, logger, resourceMetadata }) => {
 * Builds a resource metadata map from a Graph, matching the old Graph interface
 * for compatibility with filtering code.
 */
-const buildResourceMetadata = (graph$1, logger) => {
+const buildResourceMetadata = (graph, logger) => {
 	const eventBuildResourceMetadata = logger.timeEvent("build-resource-metadata");
 	const resourceMetadata = {
 		operations: /* @__PURE__ */ new Map(),
@@ -2858,43 +2858,43 @@ const buildResourceMetadata = (graph$1, logger) => {
 	};
 	const getDependencies = (pointer) => {
 		const dependencies = /* @__PURE__ */ new Set();
-		const nodeDependencies = graph$1.transitiveDependencies.get(pointer);
+		const nodeDependencies = graph.transitiveDependencies.get(pointer);
 		if (nodeDependencies?.size) for (const dependency of nodeDependencies) {
-			const path$1 = jsonPointerToPath(dependency);
-			const type = path$1[path$1.length - 2];
-			const name = path$1[path$1.length - 1];
+			const path = jsonPointerToPath(dependency);
+			const type = path[path.length - 2];
+			const name = path[path.length - 1];
 			if (type && name) {
-				const namespace$2 = stringToNamespace(type);
-				if (namespace$2 === "unknown") console.warn(`unsupported type: ${type}`);
-				dependencies.add(addNamespace(namespace$2, name));
+				const namespace = stringToNamespace(type);
+				if (namespace === "unknown") console.warn(`unsupported type: ${type}`);
+				dependencies.add(addNamespace(namespace, name));
 			}
 		}
 		return dependencies;
 	};
-	for (const [pointer, nodeInfo] of graph$1.nodes) {
-		const path$1 = jsonPointerToPath(pointer);
-		if (path$1[0] === "components") {
-			if (path$1.length === 3) {
-				if (path$1[1] === "schemas") {
-					const name = path$1[path$1.length - 1];
+	for (const [pointer, nodeInfo] of graph.nodes) {
+		const path = jsonPointerToPath(pointer);
+		if (path[0] === "components") {
+			if (path.length === 3) {
+				if (path[1] === "schemas") {
+					const name = path[path.length - 1];
 					resourceMetadata.schemas.set(addNamespace("schema", name), {
 						dependencies: getDependencies(pointer),
 						deprecated: nodeInfo.deprecated ?? false
 					});
-				} else if (path$1[1] === "parameters") {
-					const name = path$1[path$1.length - 1];
+				} else if (path[1] === "parameters") {
+					const name = path[path.length - 1];
 					resourceMetadata.parameters.set(addNamespace("parameter", name), {
 						dependencies: getDependencies(pointer),
 						deprecated: nodeInfo.deprecated ?? false
 					});
-				} else if (path$1[1] === "requestBodies") {
-					const name = path$1[path$1.length - 1];
+				} else if (path[1] === "requestBodies") {
+					const name = path[path.length - 1];
 					resourceMetadata.requestBodies.set(addNamespace("body", name), {
 						dependencies: getDependencies(pointer),
 						deprecated: nodeInfo.deprecated ?? false
 					});
-				} else if (path$1[1] === "responses") {
-					const name = path$1[path$1.length - 1];
+				} else if (path[1] === "responses") {
+					const name = path[path.length - 1];
 					resourceMetadata.responses.set(addNamespace("response", name), {
 						dependencies: getDependencies(pointer),
 						deprecated: nodeInfo.deprecated ?? false
@@ -2903,12 +2903,12 @@ const buildResourceMetadata = (graph$1, logger) => {
 			}
 			continue;
 		}
-		if (path$1[0] === "paths") {
-			if (path$1.length === 3 && httpMethods.includes(path$1[2])) {
-				const method = path$1[path$1.length - 1];
+		if (path[0] === "paths") {
+			if (path.length === 3 && httpMethods.includes(path[2])) {
+				const method = path[path.length - 1];
 				const operationKey = createOperationKey({
 					method,
-					path: path$1.slice(1, -1).join("/")
+					path: path.slice(1, -1).join("/")
 				});
 				resourceMetadata.operations.set(addNamespace("operation", operationKey), {
 					dependencies: getDependencies(pointer),
@@ -2918,9 +2918,9 @@ const buildResourceMetadata = (graph$1, logger) => {
 			}
 			continue;
 		}
-		if (path$1[0] === "definitions") {
-			if (path$1.length === 2) {
-				const name = path$1[path$1.length - 1];
+		if (path[0] === "definitions") {
+			if (path.length === 2) {
+				const name = path[path.length - 1];
 				resourceMetadata.schemas.set(addNamespace("schema", name), {
 					dependencies: getDependencies(pointer),
 					deprecated: nodeInfo.deprecated ?? false
@@ -2989,7 +2989,7 @@ const getUniqueComponentName = ({ base, components, extraComponents }) => {
 	}
 	return name;
 };
-const isPathRootSchema = (path$1) => path$1.length === 3 && path$1[0] === "components" && path$1[1] === "schemas" || path$1.length === 2 && path$1[0] === "definitions";
+const isPathRootSchema = (path) => path.length === 3 && path[0] === "components" && path[1] === "schemas" || path.length === 2 && path[0] === "definitions";
 const specToSchemasPointerNamespace = (spec) => {
 	if (spec && typeof spec === "object") {
 		if ("swagger" in spec) return "#/definitions/";
@@ -3026,21 +3026,21 @@ const getEnumSignature = (schema) => {
 * @param path - The path to the current node
 * @param visitor - Function to call for each visited node
 */
-const walkSchemas$1 = ({ key, node, parent, path: path$1, visitor }) => {
+const walkSchemas$1 = ({ key, node, parent, path, visitor }) => {
 	if (!node || typeof node !== "object" || node instanceof Array) return;
 	const value = node;
 	if ("type" in value || "enum" in value || childSchemaRelationships.some(([keyword]) => keyword in value)) visitor({
 		key,
 		node,
 		parent,
-		path: path$1
+		path
 	});
 	for (const [k, v] of Object.entries(value)) if (typeof v === "object" && v !== null) if (v instanceof Array) v.forEach((item, index) => walkSchemas$1({
 		key: index,
 		node: item,
 		parent: v,
 		path: [
-			...path$1,
+			...path,
 			k,
 			index
 		],
@@ -3050,7 +3050,7 @@ const walkSchemas$1 = ({ key, node, parent, path: path$1, visitor }) => {
 		key: k,
 		node: v,
 		parent: node,
-		path: [...path$1, k],
+		path: [...path, k],
 		visitor
 	});
 };
@@ -3075,8 +3075,8 @@ const inlineMode = ({ spec }) => {
 	};
 	replaceEnumRefs(spec);
 	for (const pointer of Object.keys(rootEnums)) {
-		const path$1 = jsonPointerToPath(pointer);
-		const name = path$1[path$1.length - 1];
+		const path = jsonPointerToPath(pointer);
+		const name = path[path.length - 1];
 		if (name) delete schemasObj[name];
 	}
 };
@@ -3174,21 +3174,21 @@ const enumsTransform = ({ config, spec }) => {
 * @param path - The path to the current node
 * @param visitor - Function to call for each visited node
 */
-const walkSchemas = ({ key, node, parent, path: path$1, visitor }) => {
+const walkSchemas = ({ key, node, parent, path, visitor }) => {
 	if (!node || typeof node !== "object" || node instanceof Array) return;
 	const value = node;
 	if ("type" in value || childSchemaRelationships.some(([keyword]) => keyword in value)) visitor({
 		key,
 		node,
 		parent,
-		path: path$1
+		path
 	});
 	for (const [k, v] of Object.entries(value)) if (typeof v === "object" && v !== null) if (v instanceof Array) v.forEach((item, index) => walkSchemas({
 		key: index,
 		node: item,
 		parent: v,
 		path: [
-			...path$1,
+			...path,
 			k,
 			index
 		],
@@ -3198,7 +3198,7 @@ const walkSchemas = ({ key, node, parent, path: path$1, visitor }) => {
 		key: k,
 		node: v,
 		parent: node,
-		path: [...path$1, k],
+		path: [...path, k],
 		visitor
 	});
 };
@@ -3249,7 +3249,6 @@ const deepEqual = (a, b) => {
 	for (const key of keysA) if (!deepEqual(objA[key], objB[key])) return false;
 	return true;
 };
-var deepEqual_default = deepEqual;
 
 //#endregion
 //#region src/openApi/shared/utils/graph.ts
@@ -3271,7 +3270,7 @@ const annotateChildScopes = (nodes) => {
 /**
 * Recursively collects all $ref dependencies in the subtree rooted at `pointer`.
 */
-const collectPointerDependencies = ({ cache, graph: graph$1, pointer, visited }) => {
+const collectPointerDependencies = ({ cache, graph, pointer, visited }) => {
 	const cached = cache.transitiveDependencies.get(pointer);
 	if (cached) return {
 		subtreeDependencies: cache.subtreeDependencies.get(pointer),
@@ -3282,19 +3281,19 @@ const collectPointerDependencies = ({ cache, graph: graph$1, pointer, visited })
 		transitiveDependencies: /* @__PURE__ */ new Set()
 	};
 	visited.add(pointer);
-	if (!graph$1.nodes.get(pointer)) return {
+	if (!graph.nodes.get(pointer)) return {
 		subtreeDependencies: /* @__PURE__ */ new Set(),
 		transitiveDependencies: /* @__PURE__ */ new Set()
 	};
 	const transitiveDependencies = /* @__PURE__ */ new Set();
 	const subtreeDependencies = /* @__PURE__ */ new Set();
-	const nodeDependencies = graph$1.nodeDependencies.get(pointer);
+	const nodeDependencies = graph.nodeDependencies.get(pointer);
 	if (nodeDependencies) for (const depPointer of nodeDependencies) {
 		transitiveDependencies.add(depPointer);
 		subtreeDependencies.add(depPointer);
 		const depResult = collectPointerDependencies({
 			cache,
-			graph: graph$1,
+			graph,
 			pointer: depPointer,
 			visited
 		});
@@ -3309,7 +3308,7 @@ const collectPointerDependencies = ({ cache, graph: graph$1, pointer, visited })
 		if (!childResult.subtreeDependencies || !childResult.transitiveDependencies) {
 			childResult = collectPointerDependencies({
 				cache,
-				graph: graph$1,
+				graph,
 				pointer: childPointer,
 				visited
 			});
@@ -3338,8 +3337,8 @@ const collectPointerDependencies = ({ cache, graph: graph$1, pointer, visited })
 *
 * @param graph - The Graph structure containing nodes, dependencies, and reverseNodeDependencies.
 */
-const propagateScopes = (graph$1) => {
-	const worklist = new Set(Array.from(graph$1.nodes.entries()).filter(([, nodeInfo]) => nodeInfo.scopes && nodeInfo.scopes.size > 0).map(([pointer]) => pointer));
+const propagateScopes = (graph) => {
+	const worklist = new Set(Array.from(graph.nodes.entries()).filter(([, nodeInfo]) => nodeInfo.scopes && nodeInfo.scopes.size > 0).map(([pointer]) => pointer));
 	/**
 	* Notifies all dependents of a node that its scopes may have changed.
 	* Dependents include:
@@ -3353,7 +3352,7 @@ const propagateScopes = (graph$1) => {
 	*/
 	const notifyAllDependents = (pointer, nodeInfo, childPointer) => {
 		if (nodeInfo.parentPointer) worklist.add(nodeInfo.parentPointer);
-		const reverseNodeDependencies = graph$1.reverseNodeDependencies.get(pointer);
+		const reverseNodeDependencies = graph.reverseNodeDependencies.get(pointer);
 		if (reverseNodeDependencies) for (const dependentPointer of reverseNodeDependencies) worklist.add(dependentPointer);
 		if (childPointer) {
 			const combinatorChildMatch = childPointer.match(/(.*)\/(allOf|anyOf|oneOf)\/\d+$/);
@@ -3373,14 +3372,14 @@ const propagateScopes = (graph$1) => {
 	*/
 	const propagateChildScopes = (pointer, nodeInfo, childPointer) => {
 		if (!nodeInfo?.scopes) return;
-		const childInfo = graph$1.nodes.get(childPointer);
+		const childInfo = graph.nodes.get(childPointer);
 		if (!childInfo?.scopes) return;
 		if (propagateScopesToNode(childInfo, nodeInfo)) notifyAllDependents(pointer, nodeInfo, childPointer);
 	};
 	while (worklist.size > 0) {
 		const pointer = worklist.values().next().value;
 		worklist.delete(pointer);
-		const nodeInfo = graph$1.nodes.get(pointer);
+		const nodeInfo = graph.nodes.get(pointer);
 		if (!nodeInfo) continue;
 		if (!nodeInfo.scopes) nodeInfo.scopes = /* @__PURE__ */ new Set();
 		const node = nodeInfo.node;
@@ -3395,15 +3394,15 @@ const propagateScopes = (graph$1) => {
 				else if (typeof value === "object" && value !== null) propagateChildScopes(pointer, nodeInfo, `${pointer}/${keyword}`);
 			}
 		}
-		const nodeDependencies = graph$1.nodeDependencies.get(pointer);
+		const nodeDependencies = graph.nodeDependencies.get(pointer);
 		if (nodeDependencies) for (const depPointer of nodeDependencies) {
-			const depNode = graph$1.nodes.get(depPointer);
+			const depNode = graph.nodes.get(depPointer);
 			if (depNode?.scopes) {
 				if (propagateScopesToNode(depNode, nodeInfo)) notifyAllDependents(pointer, nodeInfo);
 			}
 		}
 		if (nodeInfo.parentPointer) {
-			const parentInfo = graph$1.nodes.get(nodeInfo.parentPointer);
+			const parentInfo = graph.nodes.get(nodeInfo.parentPointer);
 			if (parentInfo) {
 				if (propagateScopesToNode(nodeInfo, parentInfo)) notifyAllDependents(nodeInfo.parentPointer, parentInfo);
 			}
@@ -3466,48 +3465,48 @@ const seedLocalScopes = (nodes) => {
 */
 function buildGraph(root, logger) {
 	const eventBuildGraph = logger.timeEvent("build-graph");
-	const graph$1 = {
+	const graph = {
 		nodeDependencies: /* @__PURE__ */ new Map(),
 		nodes: /* @__PURE__ */ new Map(),
 		reverseNodeDependencies: /* @__PURE__ */ new Map(),
 		subtreeDependencies: /* @__PURE__ */ new Map(),
 		transitiveDependencies: /* @__PURE__ */ new Map()
 	};
-	const walk$1 = ({ key, node, parentPointer, path: path$1 }) => {
+	const walk = ({ key, node, parentPointer, path }) => {
 		if (typeof node !== "object" || node === null) return;
-		const pointer = pathToJsonPointer(path$1);
+		const pointer = pathToJsonPointer(path);
 		let deprecated;
 		let tags;
 		if (typeof node === "object" && node !== null) {
 			if ("deprecated" in node && typeof node.deprecated === "boolean") deprecated = Boolean(node.deprecated);
 			if ("$ref" in node && typeof node.$ref === "string") {
 				const refPointer = normalizeJsonPointer(node.$ref);
-				if (!graph$1.nodeDependencies.has(pointer)) graph$1.nodeDependencies.set(pointer, /* @__PURE__ */ new Set());
-				graph$1.nodeDependencies.get(pointer).add(refPointer);
+				if (!graph.nodeDependencies.has(pointer)) graph.nodeDependencies.set(pointer, /* @__PURE__ */ new Set());
+				graph.nodeDependencies.get(pointer).add(refPointer);
 			}
 			if ("tags" in node && node.tags instanceof Array) tags = new Set(node.tags.filter((tag) => typeof tag === "string"));
 		}
-		graph$1.nodes.set(pointer, {
+		graph.nodes.set(pointer, {
 			deprecated,
 			key,
 			node,
 			parentPointer,
 			tags
 		});
-		if (node instanceof Array) node.forEach((item, index) => walk$1({
+		if (node instanceof Array) node.forEach((item, index) => walk({
 			key: index,
 			node: item,
 			parentPointer: pointer,
-			path: [...path$1, index]
+			path: [...path, index]
 		}));
-		else for (const [childKey, value] of Object.entries(node)) walk$1({
+		else for (const [childKey, value] of Object.entries(node)) walk({
 			key: childKey,
 			node: value,
 			parentPointer: pointer,
-			path: [...path$1, childKey]
+			path: [...path, childKey]
 		});
 	};
-	walk$1({
+	walk({
 		key: null,
 		node: root,
 		parentPointer: null,
@@ -3518,31 +3517,31 @@ function buildGraph(root, logger) {
 		subtreeDependencies: /* @__PURE__ */ new Map(),
 		transitiveDependencies: /* @__PURE__ */ new Map()
 	};
-	for (const [pointer, nodeInfo] of graph$1.nodes) {
+	for (const [pointer, nodeInfo] of graph.nodes) {
 		const parent = nodeInfo.parentPointer;
 		if (!parent) continue;
 		if (!cache.parentToChildren.has(parent)) cache.parentToChildren.set(parent, []);
 		cache.parentToChildren.get(parent).push(pointer);
 	}
-	for (const [pointerFrom, pointers] of graph$1.nodeDependencies) for (const pointerTo of pointers) {
-		if (!graph$1.reverseNodeDependencies.has(pointerTo)) graph$1.reverseNodeDependencies.set(pointerTo, /* @__PURE__ */ new Set());
-		graph$1.reverseNodeDependencies.get(pointerTo).add(pointerFrom);
+	for (const [pointerFrom, pointers] of graph.nodeDependencies) for (const pointerTo of pointers) {
+		if (!graph.reverseNodeDependencies.has(pointerTo)) graph.reverseNodeDependencies.set(pointerTo, /* @__PURE__ */ new Set());
+		graph.reverseNodeDependencies.get(pointerTo).add(pointerFrom);
 	}
-	seedLocalScopes(graph$1.nodes);
-	propagateScopes(graph$1);
-	annotateChildScopes(graph$1.nodes);
-	for (const pointer of graph$1.nodes.keys()) {
+	seedLocalScopes(graph.nodes);
+	propagateScopes(graph);
+	annotateChildScopes(graph.nodes);
+	for (const pointer of graph.nodes.keys()) {
 		const result = collectPointerDependencies({
 			cache,
-			graph: graph$1,
+			graph,
 			pointer,
 			visited: /* @__PURE__ */ new Set()
 		});
-		graph$1.transitiveDependencies.set(pointer, result.transitiveDependencies);
-		graph$1.subtreeDependencies.set(pointer, result.subtreeDependencies);
+		graph.transitiveDependencies.set(pointer, result.transitiveDependencies);
+		graph.subtreeDependencies.set(pointer, result.subtreeDependencies);
 	}
 	eventBuildGraph.timeEnd();
-	return { graph: graph$1 };
+	return { graph };
 }
 
 //#endregion
@@ -3559,16 +3558,16 @@ const schemaKeys = new Set([
 	"schema",
 	"unevaluatedProperties"
 ]);
-const getComponentContext = (path$1) => {
-	if (path$1.length === 3 && path$1[0] === "components") {
-		const type = path$1[1];
+const getComponentContext = (path) => {
+	if (path.length === 3 && path[0] === "components") {
+		const type = path[1];
 		if (type === "parameters") return "write";
 		if (type === "requestBodies") return "write";
 		if (type === "responses") return "read";
 		if (type === "headers") return "read";
 	}
-	if (path$1.length === 2) {
-		const type = path$1[0];
+	if (path.length === 2) {
+		const type = path[0];
 		if (type === "parameters") return "write";
 		if (type === "responses") return "read";
 	}
@@ -3613,10 +3612,10 @@ const insertSplitSchemasIntoSpec = ({ logger, spec, split }) => {
 * @param scope - The scope to exclude ('readOnly' or 'writeOnly')
 * @returns boolean - Whether the schema should be removed from its parent
 */
-const pruneSchemaByScope = (graph$1, schema, scope) => {
+const pruneSchemaByScope = (graph, schema, scope) => {
 	if (schema && typeof schema === "object") {
 		if ("$ref" in schema && typeof schema.$ref === "string") {
-			const nodeInfo = graph$1.nodes.get(schema.$ref);
+			const nodeInfo = graph.nodes.get(schema.$ref);
 			if (nodeInfo?.scopes) {
 				if (scope === "writeOnly" && nodeInfo.scopes.size === 1 && nodeInfo.scopes.has("write") || scope === "readOnly" && nodeInfo.scopes.size === 1 && nodeInfo.scopes.has("read")) {
 					delete schema["$ref"];
@@ -3631,7 +3630,7 @@ const pruneSchemaByScope = (graph$1, schema, scope) => {
 				for (let index = value.length - 1; index >= 0; index--) {
 					const item = value[index];
 					if (item && typeof item === "object" && item[scope] === true) value.splice(index, 1);
-					else if (pruneSchemaByScope(graph$1, item, scope)) value.splice(index, 1);
+					else if (pruneSchemaByScope(graph, item, scope)) value.splice(index, 1);
 				}
 				if (!value.length) delete schema[keyword];
 			} else if (type === "objectMap" && typeof value === "object" && value !== null && !(value instanceof Array)) {
@@ -3642,7 +3641,7 @@ const pruneSchemaByScope = (graph$1, schema, scope) => {
 					if (prop && typeof prop === "object" && prop[scope] === true) {
 						delete objMap[key];
 						if (keyword === "properties") removedProperties.add(key);
-					} else if (pruneSchemaByScope(graph$1, prop, scope)) {
+					} else if (pruneSchemaByScope(graph, prop, scope)) {
 						delete objMap[key];
 						if (keyword === "properties") removedProperties.add(key);
 					}
@@ -3655,18 +3654,18 @@ const pruneSchemaByScope = (graph$1, schema, scope) => {
 				if (!Object.keys(objMap).length) delete schema[keyword];
 			} else if (type === "single" && typeof value === "object" && value !== null) {
 				if (value[scope] === true) delete schema[keyword];
-				else if (pruneSchemaByScope(graph$1, value, scope)) delete schema[keyword];
+				else if (pruneSchemaByScope(graph, value, scope)) delete schema[keyword];
 			} else if (type === "singleOrArray") {
 				if (value instanceof Array) {
 					for (let index = value.length - 1; index >= 0; index--) {
 						const item = value[index];
 						if (item && typeof item === "object" && item[scope] === true) value.splice(index, 1);
-						else if (pruneSchemaByScope(graph$1, item, scope)) value.splice(index, 1);
+						else if (pruneSchemaByScope(graph, item, scope)) value.splice(index, 1);
 					}
 					if (!value.length) delete schema[keyword];
 				} else if (typeof value === "object" && value !== null) {
 					if (value[scope] === true) delete schema[keyword];
-					else if (pruneSchemaByScope(graph$1, value, scope)) delete schema[keyword];
+					else if (pruneSchemaByScope(graph, value, scope)) delete schema[keyword];
 				}
 			}
 		}
@@ -3686,8 +3685,8 @@ const removeOriginalSplitSchemas = ({ logger, originalSchemas, spec, split }) =>
 	const event = logger.timeEvent("remove-original-split-schemas");
 	const schemasObj = getSchemasObject(spec);
 	for (const originalPointer of Object.keys(split.mapping)) {
-		const path$1 = jsonPointerToPath(originalPointer);
-		const name = path$1[path$1.length - 1];
+		const path = jsonPointerToPath(originalPointer);
+		const name = path[path.length - 1];
 		if (typeof name === "string" && schemasObj && Object.prototype.hasOwnProperty.call(schemasObj, name) && schemasObj[name] === originalSchemas[originalPointer]) delete schemasObj[name];
 	}
 	event.timeEnd();
@@ -3787,7 +3786,7 @@ function splitDiscriminatorSchemas({ config, existingNames, schemasPointerNamesp
 * @param spec - The OpenAPI spec object
 * @returns SplitSchemas - The split schemas and pointer mappings
 */
-const splitSchemas = ({ config, graph: graph$1, logger, spec }) => {
+const splitSchemas = ({ config, graph, logger, spec }) => {
 	const event = logger.timeEvent("split-schemas");
 	const existingNames = /* @__PURE__ */ new Set();
 	const split = {
@@ -3805,20 +3804,20 @@ const splitSchemas = ({ config, graph: graph$1, logger, spec }) => {
 	*/
 	const pointerToSchema = (pointer) => {
 		if (pointer.startsWith(schemasPointerNamespace)) {
-			const path$1 = jsonPointerToPath(pointer);
-			if (path$1.length === schemasNamespaceSegments) return path$1[schemasNamespaceSegments - 1] || "";
+			const path = jsonPointerToPath(pointer);
+			if (path.length === schemasNamespaceSegments) return path[schemasNamespaceSegments - 1] || "";
 		}
 		return "";
 	};
-	for (const pointer of graph$1.nodes.keys()) {
+	for (const pointer of graph.nodes.keys()) {
 		const name = pointerToSchema(pointer);
 		if (name) existingNames.add(name);
 	}
-	for (const [pointer, nodeInfo] of graph$1.nodes) {
+	for (const [pointer, nodeInfo] of graph.nodes) {
 		const name = pointerToSchema(pointer);
 		if (!name || !(nodeInfo.scopes?.has("read") || nodeInfo.scopes?.has("write")) || !nodeInfo.scopes?.has("normal")) continue;
 		const readSchema = deepClone(nodeInfo.node);
-		pruneSchemaByScope(graph$1, readSchema, "writeOnly");
+		pruneSchemaByScope(graph, readSchema, "writeOnly");
 		const readBase = applyNaming(name, config.responses);
 		const readName = readBase === name ? readBase : getUniqueComponentName({
 			base: readBase,
@@ -3828,12 +3827,12 @@ const splitSchemas = ({ config, graph: graph$1, logger, spec }) => {
 		split.schemas[readName] = readSchema;
 		const readPointer = `${schemasPointerNamespace}${readName}`;
 		const writeSchema = deepClone(nodeInfo.node);
-		pruneSchemaByScope(graph$1, writeSchema, "readOnly");
-		const transitiveDeps = graph$1.transitiveDependencies.get(pointer) || /* @__PURE__ */ new Set();
+		pruneSchemaByScope(graph, writeSchema, "readOnly");
+		const transitiveDeps = graph.transitiveDependencies.get(pointer) || /* @__PURE__ */ new Set();
 		if (!Array.from(transitiveDeps).some((depPointer) => {
-			const depNodeInfo = graph$1.nodes.get(depPointer);
+			const depNodeInfo = graph.nodes.get(depPointer);
 			return depNodeInfo?.scopes?.has("normal") && (depNodeInfo.scopes.has("read") || depNodeInfo.scopes.has("write"));
-		}) && deepEqual_default(readSchema, writeSchema) && deepEqual_default(readSchema, nodeInfo.node)) continue;
+		}) && deepEqual(readSchema, writeSchema) && deepEqual(readSchema, nodeInfo.node)) continue;
 		const writeBase = applyNaming(name, config.requests);
 		const writeName = writeBase === name && writeBase !== readName ? writeBase : getUniqueComponentName({
 			base: writeBase,
@@ -3869,20 +3868,20 @@ const splitSchemas = ({ config, graph: graph$1, logger, spec }) => {
 const updateRefsInSpec = ({ logger, spec, split }) => {
 	const event = logger.timeEvent("update-refs-in-spec");
 	const schemasPointerNamespace = specToSchemasPointerNamespace(spec);
-	const walk$1 = ({ context, currentPointer, inSchema, node, path: path$1, visited = /* @__PURE__ */ new Set() }) => {
-		if (node instanceof Array) node.forEach((item, index) => walk$1({
+	const walk = ({ context, currentPointer, inSchema, node, path, visited = /* @__PURE__ */ new Set() }) => {
+		if (node instanceof Array) node.forEach((item, index) => walk({
 			context,
 			currentPointer,
 			inSchema,
 			node: item,
-			path: [...path$1, index],
+			path: [...path, index],
 			visited
 		}));
 		else if (node && typeof node === "object") {
 			let nextPointer = currentPointer;
 			let nextContext = context;
-			if (isPathRootSchema(path$1)) {
-				nextPointer = `${schemasPointerNamespace}${path$1[path$1.length - 1]}`;
+			if (isPathRootSchema(path)) {
+				nextPointer = `${schemasPointerNamespace}${path[path.length - 1]}`;
 				const originalPointer = split.reverseMapping[nextPointer];
 				if (originalPointer) {
 					const mapping = split.mapping[originalPointer];
@@ -3890,16 +3889,16 @@ const updateRefsInSpec = ({ logger, spec, split }) => {
 					else if (mapping?.write === nextPointer) nextContext = "write";
 				}
 			}
-			const compContext = getComponentContext(path$1);
+			const compContext = getComponentContext(path);
 			if (compContext !== void 0) {
 				for (const key in node) {
 					if (!Object.prototype.hasOwnProperty.call(node, key)) continue;
-					walk$1({
+					walk({
 						context: compContext,
 						currentPointer: nextPointer,
 						inSchema: false,
 						node: node[key],
-						path: [...path$1, key],
+						path: [...path, key],
 						visited
 					});
 				}
@@ -3910,49 +3909,49 @@ const updateRefsInSpec = ({ logger, spec, split }) => {
 				const value = node[key];
 				if (!inSchema) {
 					if (key === "requestBody") {
-						walk$1({
+						walk({
 							context: "write",
 							currentPointer: nextPointer,
 							inSchema: false,
 							node: value,
-							path: [...path$1, key],
+							path: [...path, key],
 							visited
 						});
 						continue;
 					}
 					if (key === "responses") {
-						walk$1({
+						walk({
 							context: "read",
 							currentPointer: nextPointer,
 							inSchema: false,
 							node: value,
-							path: [...path$1, key],
+							path: [...path, key],
 							visited
 						});
 						continue;
 					}
 					if (key === "parameters" && Array.isArray(value)) {
 						value.forEach((param, index) => {
-							if (param && typeof param === "object" && "schema" in param) walk$1({
+							if (param && typeof param === "object" && "schema" in param) walk({
 								context: "write",
 								currentPointer: nextPointer,
 								inSchema: true,
 								node: param.schema,
 								path: [
-									...path$1,
+									...path,
 									key,
 									index,
 									"schema"
 								],
 								visited
 							});
-							if (param && typeof param === "object" && "content" in param) walk$1({
+							if (param && typeof param === "object" && "content" in param) walk({
 								context: "write",
 								currentPointer: nextPointer,
 								inSchema: false,
 								node: param.content,
 								path: [
-									...path$1,
+									...path,
 									key,
 									index,
 									"content"
@@ -3965,13 +3964,13 @@ const updateRefsInSpec = ({ logger, spec, split }) => {
 					if (key === "headers" && typeof value === "object" && value !== null) {
 						for (const headerKey in value) {
 							if (!Object.prototype.hasOwnProperty.call(value, headerKey)) continue;
-							walk$1({
+							walk({
 								context: "read",
 								currentPointer: nextPointer,
 								inSchema: false,
 								node: value[headerKey],
 								path: [
-									...path$1,
+									...path,
 									key,
 									headerKey
 								],
@@ -3981,12 +3980,12 @@ const updateRefsInSpec = ({ logger, spec, split }) => {
 						continue;
 					}
 				}
-				if (schemaKeys.has(key)) walk$1({
+				if (schemaKeys.has(key)) walk({
 					context: nextContext,
 					currentPointer: nextPointer,
 					inSchema: true,
 					node: value,
-					path: [...path$1, key],
+					path: [...path, key],
 					visited
 				});
 				else if (key === "$ref" && typeof value === "string") {
@@ -4008,26 +4007,26 @@ const updateRefsInSpec = ({ logger, spec, split }) => {
 						}
 						value.mapping = updatedMapping;
 					}
-					walk$1({
+					walk({
 						context: nextContext,
 						currentPointer: nextPointer,
 						inSchema,
 						node: value,
-						path: [...path$1, key],
+						path: [...path, key],
 						visited
 					});
-				} else walk$1({
+				} else walk({
 					context: nextContext,
 					currentPointer: nextPointer,
 					inSchema,
 					node: value,
-					path: [...path$1, key],
+					path: [...path, key],
 					visited
 				});
 			}
 		}
 	};
-	walk$1({
+	walk({
 		context: null,
 		currentPointer: null,
 		inSchema: false,
@@ -4048,11 +4047,11 @@ const updateRefsInSpec = ({ logger, spec, split }) => {
 * @param spec - The OpenAPI spec object
 */
 const readWriteTransform = ({ config, logger, spec }) => {
-	const { graph: graph$1 } = buildGraph(spec, logger);
+	const { graph } = buildGraph(spec, logger);
 	const originalSchemas = captureOriginalSchemas(spec, logger);
 	const split = splitSchemas({
 		config,
-		graph: graph$1,
+		graph,
 		logger,
 		spec
 	});
@@ -4170,7 +4169,7 @@ const mergeParametersObjects = ({ source, target }) => {
 //#endregion
 //#region src/openApi/shared/utils/validator.ts
 const isSimpleKey = (key) => /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key);
-const formatPath = (path$1) => path$1.map((segment, i) => {
+const formatPath = (path) => path.map((segment, i) => {
 	if (typeof segment === "number") return `[${segment}]`;
 	if (i === 0) return segment;
 	return isSimpleKey(segment) ? `.${segment}` : `['${segment.replace(/"/g, "\\'")}']`;
@@ -4213,17 +4212,17 @@ const filterSpec$2 = ({ logger, operations, preserveOrder, schemas, spec }) => {
 		spec.definitions = filtered;
 	}
 	if (spec.paths) for (const entry of Object.entries(spec.paths)) {
-		const path$1 = entry[0];
+		const path = entry[0];
 		const pathItem = entry[1];
 		for (const method of httpMethods) {
 			if (!pathItem[method]) continue;
 			const key = addNamespace("operation", createOperationKey({
 				method,
-				path: path$1
+				path
 			}));
 			if (!operations.has(key)) delete pathItem[method];
 		}
-		if (!Object.keys(pathItem).length) delete spec.paths[path$1];
+		if (!Object.keys(pathItem).length) delete spec.paths[path];
 	}
 	eventFilterSpec.timeEnd();
 };
@@ -4479,20 +4478,20 @@ const parseAllOf$2 = ({ context, schema, state }) => {
 		else irCompositionSchema.required = schema.required;
 		schemaItems.push(irCompositionSchema);
 		if (compositionSchema.$ref) {
-			const ref$1 = context.resolveRef(compositionSchema.$ref);
-			if (ref$1.discriminator && state.$ref) {
+			const ref = context.resolveRef(compositionSchema.$ref);
+			if (ref.discriminator && state.$ref) {
 				const valueSchemas = discriminatorValues(state.$ref).map((value) => ({
 					const: value,
 					type: "string"
 				}));
 				const irDiscriminatorSchema = {
-					properties: { [ref$1.discriminator]: valueSchemas.length > 1 ? {
+					properties: { [ref.discriminator]: valueSchemas.length > 1 ? {
 						items: valueSchemas,
 						logicalOperator: "or"
 					} : valueSchemas[0] },
 					type: "object"
 				};
-				if (ref$1.required?.includes(ref$1.discriminator)) irDiscriminatorSchema.required = [ref$1.discriminator];
+				if (ref.required?.includes(ref.discriminator)) irDiscriminatorSchema.required = [ref.discriminator];
 				schemaItems.push(irDiscriminatorSchema);
 			}
 		}
@@ -4585,13 +4584,13 @@ const parseRef$2 = ({ context, schema, state }) => {
 			const refSchema = context.resolveRef(schema.$ref);
 			const originalRef = state.$ref;
 			state.$ref = schema.$ref;
-			const irSchema$1 = schemaToIrSchema$2({
+			const irSchema = schemaToIrSchema$2({
 				context,
 				schema: refSchema,
 				state
 			});
 			state.$ref = originalRef;
-			return irSchema$1;
+			return irSchema;
 		}
 	}
 	irSchema.$ref = decodeURI(schema.$ref);
@@ -4758,19 +4757,19 @@ const isPaginationType$2 = (schemaType) => schemaType === "boolean" || schemaTyp
 const paginationField$2 = ({ context, name, schema }) => {
 	if (getPaginationKeywordsRegExp(context.config.parser.pagination).test(name)) return true;
 	if ("$ref" in schema) {
-		const ref$1 = context.resolveRef(schema.$ref ?? "");
-		if ("in" in ref$1 && ref$1.in) return paginationField$2({
+		const ref = context.resolveRef(schema.$ref ?? "");
+		if ("in" in ref && ref.in) return paginationField$2({
 			context,
 			name,
-			schema: "schema" in ref$1 ? ref$1.schema : {
-				...ref$1,
+			schema: "schema" in ref ? ref.schema : {
+				...ref,
 				in: void 0
 			}
 		});
 		return paginationField$2({
 			context,
 			name,
-			schema: ref$1
+			schema: ref
 		});
 	}
 	if ("in" in schema) {
@@ -4784,10 +4783,10 @@ const paginationField$2 = ({ context, name, schema }) => {
 			}
 		});
 	}
-	for (const name$1 in schema.properties) if (getPaginationKeywordsRegExp(context.config.parser.pagination).test(name$1)) {
-		const property = schema.properties[name$1];
+	for (const name in schema.properties) if (getPaginationKeywordsRegExp(context.config.parser.pagination).test(name)) {
+		const property = schema.properties[name];
 		if (typeof property !== "boolean" && !("$ref" in property)) {
-			if (isPaginationType$2(getSchemaType$1({ schema: property }))) return name$1;
+			if (isPaginationType$2(getSchemaType$1({ schema: property }))) return name;
 		}
 	}
 	for (const allOf of schema.allOf ?? []) {
@@ -4809,17 +4808,17 @@ const parseOperationJsDoc$2 = ({ irOperation, operation }) => {
 	if (operation.summary) irOperation.summary = operation.summary;
 	if (operation.tags?.length) irOperation.tags = operation.tags;
 };
-const initIrOperation$2 = ({ context, method, operation, path: path$1, state }) => {
+const initIrOperation$2 = ({ context, method, operation, path, state }) => {
 	const irOperation = {
 		id: operationToId({
 			context,
 			id: operation.operationId,
 			method,
-			path: path$1,
+			path,
 			state
 		}),
 		method,
-		path: path$1
+		path
 	};
 	if (operation.operationId) irOperation.operationId = operation.operationId;
 	parseOperationJsDoc$2({
@@ -4832,12 +4831,12 @@ const initIrOperation$2 = ({ context, method, operation, path: path$1, state })
 	});
 	return irOperation;
 };
-const operationToIrOperation$2 = ({ context, method, operation, path: path$1, securitySchemesMap, state }) => {
+const operationToIrOperation$2 = ({ context, method, operation, path, securitySchemesMap, state }) => {
 	const irOperation = initIrOperation$2({
 		context,
 		method,
 		operation,
-		path: path$1,
+		path,
 		state
 	});
 	if (operation.parameters) irOperation.parameters = operation.parameters;
@@ -4868,7 +4867,7 @@ const operationToIrOperation$2 = ({ context, method, operation, path: path$1, se
 			mimeTypes,
 			response: { schema }
 		});
-		const content = contents.find((content$1) => content$1.type === "json") || contents[0];
+		const content = contents.find((content) => content.type === "json") || contents[0];
 		if (content) {
 			const pagination = paginationField$2({
 				context,
@@ -4924,7 +4923,7 @@ const operationToIrOperation$2 = ({ context, method, operation, path: path$1, se
 			mimeTypes: operation.produces ? operation.produces : ["application/json"],
 			response: responseObject
 		});
-		const content = contents.find((content$1) => content$1.type === "json") || contents[0];
+		const content = contents.find((content) => content.type === "json") || contents[0];
 		if (content) irOperation.responses[name] = {
 			mediaType: content.mediaType,
 			schema: schemaToIrSchema$2({
@@ -4994,14 +4993,14 @@ const operationToIrOperation$2 = ({ context, method, operation, path: path$1, se
 	}
 	return irOperation;
 };
-const parsePathOperation$2 = ({ context, method, operation, path: path$1, securitySchemesMap, state }) => {
+const parsePathOperation$2 = ({ context, method, operation, path, securitySchemesMap, state }) => {
 	if (!context.ir.paths) context.ir.paths = {};
-	if (!context.ir.paths[path$1]) context.ir.paths[path$1] = {};
-	context.ir.paths[path$1][method] = operationToIrOperation$2({
+	if (!context.ir.paths[path]) context.ir.paths[path] = {};
+	context.ir.paths[path][method] = operationToIrOperation$2({
 		context,
 		method,
 		operation,
-		path: path$1,
+		path,
 		securitySchemesMap,
 		state
 	});
@@ -5015,10 +5014,6 @@ const parsePathOperation$2 = ({ context, method, operation, path: path$1, securi
 const defaultExplode$2 = (collectionFormat) => {
 	switch (collectionFormat) {
 		case "multi": return true;
-		case "csv":
-		case "pipes":
-		case "ssv":
-		case "tsv":
 		default: return false;
 	}
 };
@@ -5029,7 +5024,6 @@ const defaultStyle$2 = (_in) => {
 	switch (_in) {
 		case "header":
 		case "path": return "simple";
-		case "query":
 		default: return "form";
 	}
 };
@@ -5114,12 +5108,12 @@ function parseUrl(value) {
 	if (!match) return errorResponse;
 	const host = match[5] || "";
 	if (host === "." || host === "..") return errorResponse;
-	const path$1 = match[8] || "";
+	const path = match[8] || "";
 	const protocol = match[2] || "";
 	if (protocol.length === 1) return errorResponse;
 	return {
 		host,
-		path: path$1 === "/" ? "" : path$1,
+		path: path === "/" ? "" : path,
 		port: match[7] || "",
 		protocol
 	};
@@ -5130,7 +5124,7 @@ function parseUrl(value) {
 const parseServers$2 = ({ context }) => {
 	let schemes = context.spec.schemes ?? [];
 	let host = context.spec.host ?? "";
-	const path$1 = context.spec.basePath ?? "";
+	const path = context.spec.basePath ?? "";
 	for (const input of context.config.input) if (typeof input.path === "string") {
 		const url = parseUrl(input.path);
 		if (!schemes.length) {
@@ -5139,7 +5133,7 @@ const parseServers$2 = ({ context }) => {
 		if (!host) host = `${url.host}${url.port ? `:${url.port}` : ""}`;
 	}
 	if (!schemes.length) schemes = [""];
-	const servers = schemes.map((scheme) => `${scheme ? `${scheme}://` : ""}${host}${path$1}`).filter(Boolean);
+	const servers = schemes.map((scheme) => `${scheme ? `${scheme}://` : ""}${host}${path}`).filter(Boolean);
 	if (servers.length) context.ir.servers = servers.map((url) => ({ url }));
 };
 
@@ -5150,7 +5144,7 @@ const validateOpenApiSpec$2 = (spec, logger) => {
 	const issues = [];
 	const operationIds = /* @__PURE__ */ new Map();
 	if (spec.paths) for (const entry of Object.entries(spec.paths)) {
-		const path$1 = entry[0];
+		const path = entry[0];
 		const pathItem = entry[1];
 		for (const method of httpMethods) {
 			if (method === "trace") continue;
@@ -5158,7 +5152,7 @@ const validateOpenApiSpec$2 = (spec, logger) => {
 			if (!operation) continue;
 			const operationKey = createOperationKey({
 				method,
-				path: path$1
+				path
 			});
 			if (operation.operationId) if (!operationIds.has(operation.operationId)) operationIds.set(operation.operationId, operationKey);
 			else issues.push({
@@ -5170,7 +5164,7 @@ const validateOpenApiSpec$2 = (spec, logger) => {
 				message: "Duplicate `operationId` found. Each `operationId` must be unique.",
 				path: [
 					"paths",
-					path$1,
+					path,
 					method,
 					"operationId"
 				],
@@ -5194,8 +5188,8 @@ const parseV2_0_X = (context) => {
 	});
 	if (hasFilters(context.config.parser.filters)) {
 		const filters = createFilters(context.config.parser.filters, context.spec, context.logger);
-		const { graph: graph$1 } = buildGraph(context.spec, context.logger);
-		const { resourceMetadata } = buildResourceMetadata(graph$1, context.logger);
+		const { graph } = buildGraph(context.spec, context.logger);
+		const { resourceMetadata } = buildResourceMetadata(graph, context.logger);
 		filterSpec$2({
 			...createFilteredDependencies({
 				filters,
@@ -5224,9 +5218,9 @@ const parseV2_0_X = (context) => {
 		});
 	}
 	parseServers$2({ context });
-	for (const path$1 in context.spec.paths) {
-		if (path$1.startsWith("x-")) continue;
-		const pathItem = context.spec.paths[path$1];
+	for (const path in context.spec.paths) {
+		if (path.startsWith("x-")) continue;
+		const pathItem = context.spec.paths[path];
 		const finalPathItem = pathItem.$ref ? {
 			...context.resolveRef(pathItem.$ref),
 			...pathItem
@@ -5247,7 +5241,7 @@ const parseV2_0_X = (context) => {
 					parameters: finalPathItem.parameters
 				})
 			},
-			path: path$1,
+			path,
 			securitySchemesMap,
 			state
 		};
@@ -5441,17 +5435,17 @@ const filterSpec$1 = ({ logger, operations, parameters, preserveOrder, requestBo
 		}
 	}
 	if (spec.paths) for (const entry of Object.entries(spec.paths)) {
-		const path$1 = entry[0];
+		const path = entry[0];
 		const pathItem = entry[1];
 		for (const method of httpMethods) {
 			if (!pathItem[method]) continue;
 			const key = addNamespace("operation", createOperationKey({
 				method,
-				path: path$1
+				path
 			}));
 			if (!operations.has(key)) delete pathItem[method];
 		}
-		if (!Object.keys(pathItem).length) delete spec.paths[path$1];
+		if (!Object.keys(pathItem).length) delete spec.paths[path];
 	}
 	eventFilterSpec.timeEnd();
 };
@@ -5665,11 +5659,11 @@ const parseAllOf$1 = ({ context, schema, state }) => {
 		else irCompositionSchema.required = schema.required;
 		schemaItems.push(irCompositionSchema);
 		if ("$ref" in compositionSchema) {
-			const ref$1 = context.resolveRef(compositionSchema.$ref);
+			const ref = context.resolveRef(compositionSchema.$ref);
 			if (state.$ref) {
 				const discriminators = findDiscriminatorsInSchema$1({
 					context,
-					schema: ref$1
+					schema: ref
 				});
 				for (const { discriminator, oneOf } of discriminators) {
 					const values = discriminatorValues(state.$ref, discriminator.mapping, oneOf ? () => oneOf.some((o) => "$ref" in o && o.$ref === state.$ref) : void 0);
@@ -5678,7 +5672,7 @@ const parseAllOf$1 = ({ context, schema, state }) => {
 					const existingIndex = discriminatorsToAdd.findIndex((d) => d.discriminator.propertyName === discriminator.propertyName);
 					if (existingIndex !== -1) if (isExplicitMapping && !discriminatorsToAdd[existingIndex].isExplicitMapping) discriminatorsToAdd.splice(existingIndex, 1);
 					else continue;
-					const isRequired = discriminators.some((d) => d.discriminator.propertyName === discriminator.propertyName && (ref$1.required?.includes(d.discriminator.propertyName) || ref$1.allOf && ref$1.allOf.some((item) => {
+					const isRequired = discriminators.some((d) => d.discriminator.propertyName === discriminator.propertyName && (ref.required?.includes(d.discriminator.propertyName) || ref.allOf && ref.allOf.some((item) => {
 						return ("$ref" in item ? context.resolveRef(item.$ref) : item).required?.includes(d.discriminator.propertyName);
 					})));
 					discriminatorsToAdd.push({
@@ -5942,13 +5936,13 @@ const parseRef$1 = ({ context, schema, state }) => {
 			const refSchema = context.resolveRef(schema.$ref);
 			const originalRef = state.$ref;
 			state.$ref = schema.$ref;
-			const irSchema$1 = schemaToIrSchema$1({
+			const irSchema = schemaToIrSchema$1({
 				context,
 				schema: refSchema,
 				state
 			});
 			state.$ref = originalRef;
-			return irSchema$1;
+			return irSchema;
 		}
 	}
 	const irSchema = {};
@@ -6125,13 +6119,13 @@ const isPaginationType$1 = (schemaType) => schemaType === "boolean" || schemaTyp
 const paginationField$1 = ({ context, name, schema }) => {
 	if (getPaginationKeywordsRegExp(context.config.parser.pagination).test(name)) return true;
 	if ("$ref" in schema) {
-		const ref$1 = context.resolveRef(schema.$ref);
-		if ("content" in ref$1 || "in" in ref$1) {
+		const ref = context.resolveRef(schema.$ref);
+		if ("content" in ref || "in" in ref) {
 			let refSchema;
-			if ("in" in ref$1) refSchema = ref$1.schema;
+			if ("in" in ref) refSchema = ref.schema;
 			if (!refSchema) {
-				const contents = mediaTypeObjects$1({ content: ref$1.content });
-				const content = contents.find((content$1) => content$1.type === "json") || contents[0];
+				const contents = mediaTypeObjects$1({ content: ref.content });
+				const content = contents.find((content) => content.type === "json") || contents[0];
 				if (content?.schema) refSchema = content.schema;
 			}
 			if (!refSchema) return false;
@@ -6144,13 +6138,13 @@ const paginationField$1 = ({ context, name, schema }) => {
 		return paginationField$1({
 			context,
 			name,
-			schema: ref$1
+			schema: ref
 		});
 	}
-	for (const name$1 in schema.properties) if (getPaginationKeywordsRegExp(context.config.parser.pagination).test(name$1)) {
-		const property = schema.properties[name$1];
+	for (const name in schema.properties) if (getPaginationKeywordsRegExp(context.config.parser.pagination).test(name)) {
+		const property = schema.properties[name];
 		if (typeof property !== "boolean" && !("$ref" in property)) {
-			if (isPaginationType$1(getSchemaType({ schema: property }))) return name$1;
+			if (isPaginationType$1(getSchemaType({ schema: property }))) return name;
 		}
 	}
 	for (const allOf of schema.allOf ?? []) {
@@ -6172,17 +6166,17 @@ const parseOperationJsDoc$1 = ({ irOperation, operation }) => {
 	if (operation.summary) irOperation.summary = operation.summary;
 	if (operation.tags?.length) irOperation.tags = operation.tags;
 };
-const initIrOperation$1 = ({ context, method, operation, path: path$1, state }) => {
+const initIrOperation$1 = ({ context, method, operation, path, state }) => {
 	const irOperation = {
 		id: operationToId({
 			context,
 			id: operation.operationId,
 			method,
-			path: path$1,
+			path,
 			state
 		}),
 		method,
-		path: path$1
+		path
 	};
 	if (operation.operationId) irOperation.operationId = operation.operationId;
 	parseOperationJsDoc$1({
@@ -6195,19 +6189,19 @@ const initIrOperation$1 = ({ context, method, operation, path: path$1, state })
 	});
 	return irOperation;
 };
-const operationToIrOperation$1 = ({ context, method, operation, path: path$1, securitySchemesMap, state }) => {
+const operationToIrOperation$1 = ({ context, method, operation, path, securitySchemesMap, state }) => {
 	const irOperation = initIrOperation$1({
 		context,
 		method,
 		operation,
-		path: path$1,
+		path,
 		state
 	});
 	if (operation.parameters) irOperation.parameters = operation.parameters;
 	if (operation.requestBody) {
 		const requestBody = "$ref" in operation.requestBody ? context.resolveRef(operation.requestBody.$ref) : operation.requestBody;
 		const contents = mediaTypeObjects$1({ content: requestBody.content });
-		const content = contents.find((content$1) => content$1.type === "json") || contents[0];
+		const content = contents.find((content) => content.type === "json") || contents[0];
 		if (content) {
 			const pagination = paginationField$1({
 				context,
@@ -6248,7 +6242,7 @@ const operationToIrOperation$1 = ({ context, method, operation, path: path$1, se
 		const response = operation.responses[name];
 		const responseObject = "$ref" in response ? context.resolveRef(response.$ref) : response;
 		const contents = mediaTypeObjects$1({ content: responseObject.content });
-		const content = contents.find((content$1) => content$1.type === "json") || contents[0];
+		const content = contents.find((content) => content.type === "json") || contents[0];
 		if (content) irOperation.responses[name] = {
 			mediaType: content.mediaType,
 			schema: schemaToIrSchema$1({
@@ -6276,15 +6270,15 @@ const operationToIrOperation$1 = ({ context, method, operation, path: path$1, se
 	}
 	return irOperation;
 };
-const parsePathOperation$1 = ({ context, method, operation, path: path$1, securitySchemesMap, state }) => {
+const parsePathOperation$1 = ({ context, method, operation, path, securitySchemesMap, state }) => {
 	if (!context.ir.paths) context.ir.paths = {};
-	if (!context.ir.paths[path$1]) context.ir.paths[path$1] = {};
+	if (!context.ir.paths[path]) context.ir.paths[path] = {};
 	if (operation.servers) context.ir.servers = [...context.ir.servers ?? [], ...operation.servers];
-	context.ir.paths[path$1][method] = operationToIrOperation$1({
+	context.ir.paths[path][method] = operationToIrOperation$1({
 		context,
 		method,
 		operation,
-		path: path$1,
+		path,
 		securitySchemesMap,
 		state
 	});
@@ -6340,7 +6334,7 @@ const parameterToIrParameter$1 = ({ $ref, context, parameter }) => {
 	let schema = parameter.schema;
 	if (!schema) {
 		const contents = mediaTypeObjects$1({ content: parameter.content });
-		const content = contents.find((content$1) => content$1.type === "json") || contents[0];
+		const content = contents.find((content) => content.type === "json") || contents[0];
 		if (content) schema = content.schema;
 	}
 	const finalSchema = schema && "$ref" in schema ? {
@@ -6398,7 +6392,7 @@ const parseParameter$1 = ({ $ref, context, parameter }) => {
 //#region src/openApi/3.0.x/parser/requestBody.ts
 const requestBodyToIrRequestBody$1 = ({ $ref, context, requestBody }) => {
 	const contents = mediaTypeObjects$1({ content: requestBody.content });
-	const content = contents.find((content$1) => content$1.type === "json") || contents[0];
+	const content = contents.find((content) => content.type === "json") || contents[0];
 	const schema = content ? content.schema : void 0;
 	const irRequestBody = { schema: schemaToIrSchema$1({
 		context,
@@ -6446,14 +6440,14 @@ const validateOpenApiSpec$1 = (spec, logger) => {
 	const issues = [];
 	const operationIds = /* @__PURE__ */ new Map();
 	if (spec.paths) for (const entry of Object.entries(spec.paths)) {
-		const path$1 = entry[0];
+		const path = entry[0];
 		const pathItem = entry[1];
 		for (const method of httpMethods) {
 			const operation = pathItem[method];
 			if (!operation) continue;
 			const operationKey = createOperationKey({
 				method,
-				path: path$1
+				path
 			});
 			if (operation.operationId) if (!operationIds.has(operation.operationId)) operationIds.set(operation.operationId, operationKey);
 			else issues.push({
@@ -6465,7 +6459,7 @@ const validateOpenApiSpec$1 = (spec, logger) => {
 				message: "Duplicate `operationId` found. Each `operationId` must be unique.",
 				path: [
 					"paths",
-					path$1,
+					path,
 					method,
 					"operationId"
 				],
@@ -6517,8 +6511,8 @@ const parseV3_0_X = (context) => {
 	});
 	if (hasFilters(context.config.parser.filters)) {
 		const filters = createFilters(context.config.parser.filters, context.spec, context.logger);
-		const { graph: graph$1 } = buildGraph(context.spec, context.logger);
-		const { resourceMetadata } = buildResourceMetadata(graph$1, context.logger);
+		const { graph } = buildGraph(context.spec, context.logger);
+		const { resourceMetadata } = buildResourceMetadata(graph, context.logger);
 		filterSpec$1({
 			...createFilteredDependencies({
 				filters,
@@ -6568,9 +6562,9 @@ const parseV3_0_X = (context) => {
 		}
 	}
 	parseServers$1({ context });
-	for (const path$1 in context.spec.paths) {
-		if (path$1.startsWith("x-")) continue;
-		const pathItem = context.spec.paths[path$1];
+	for (const path in context.spec.paths) {
+		if (path.startsWith("x-")) continue;
+		const pathItem = context.spec.paths[path];
 		const finalPathItem = pathItem.$ref ? {
 			...context.resolveRef(pathItem.$ref),
 			...pathItem
@@ -6587,7 +6581,7 @@ const parseV3_0_X = (context) => {
 				servers: finalPathItem.servers,
 				summary: finalPathItem.summary
 			},
-			path: path$1,
+			path,
 			securitySchemesMap,
 			state
 		};
@@ -6768,17 +6762,17 @@ const filterSpec = ({ logger, operations, parameters, preserveOrder, requestBodi
 		}
 	}
 	if (spec.paths) for (const entry of Object.entries(spec.paths)) {
-		const path$1 = entry[0];
+		const path = entry[0];
 		const pathItem = entry[1];
 		for (const method of httpMethods) {
 			if (!pathItem[method]) continue;
 			const key = addNamespace("operation", createOperationKey({
 				method,
-				path: path$1
+				path
 			}));
 			if (!operations.has(key)) delete pathItem[method];
 		}
-		if (!Object.keys(pathItem).length) delete spec.paths[path$1];
+		if (!Object.keys(pathItem).length) delete spec.paths[path];
 	}
 	eventFilterSpec.timeEnd();
 };
@@ -7042,11 +7036,11 @@ const parseAllOf = ({ context, schema, state }) => {
 		else irCompositionSchema.required = schema.required;
 		schemaItems.push(irCompositionSchema);
 		if (compositionSchema.$ref) {
-			const ref$1 = context.resolveRef(compositionSchema.$ref);
+			const ref = context.resolveRef(compositionSchema.$ref);
 			if (state.$ref) {
 				const discriminators = findDiscriminatorsInSchema({
 					context,
-					schema: ref$1
+					schema: ref
 				});
 				for (const { discriminator, oneOf } of discriminators) {
 					const values = discriminatorValues(state.$ref, discriminator.mapping, oneOf ? () => oneOf.some((o) => "$ref" in o && o.$ref === state.$ref) : void 0);
@@ -7055,7 +7049,7 @@ const parseAllOf = ({ context, schema, state }) => {
 					const existingIndex = discriminatorsToAdd.findIndex((d) => d.discriminator.propertyName === discriminator.propertyName);
 					if (existingIndex !== -1) if (isExplicitMapping && !discriminatorsToAdd[existingIndex].isExplicitMapping) discriminatorsToAdd.splice(existingIndex, 1);
 					else continue;
-					const isRequired = discriminators.some((d) => d.discriminator.propertyName === discriminator.propertyName && (ref$1.required?.includes(d.discriminator.propertyName) || ref$1.allOf && ref$1.allOf.some((item) => {
+					const isRequired = discriminators.some((d) => d.discriminator.propertyName === discriminator.propertyName && (ref.required?.includes(d.discriminator.propertyName) || ref.allOf && ref.allOf.some((item) => {
 						return (item.$ref ? context.resolveRef(item.$ref) : item).required?.includes(d.discriminator.propertyName);
 					})));
 					discriminatorsToAdd.push({
@@ -7324,13 +7318,13 @@ const parseRef = ({ context, schema, state }) => {
 			const refSchema = context.resolveRef(schema.$ref);
 			const originalRef = state.$ref;
 			state.$ref = schema.$ref;
-			const irSchema$1 = schemaToIrSchema({
+			const irSchema = schemaToIrSchema({
 				context,
 				schema: refSchema,
 				state
 			});
 			state.$ref = originalRef;
-			return irSchema$1;
+			return irSchema;
 		}
 	}
 	let irSchema = initIrSchema({ schema });
@@ -7540,13 +7534,13 @@ const isPaginationType = (schemaTypes) => schemaTypes.includes("boolean") || sch
 const paginationField = ({ context, name, schema }) => {
 	if (getPaginationKeywordsRegExp(context.config.parser.pagination).test(name)) return true;
 	if (schema.$ref) {
-		const ref$1 = context.resolveRef(schema.$ref);
-		if ("content" in ref$1 || "in" in ref$1) {
+		const ref = context.resolveRef(schema.$ref);
+		if ("content" in ref || "in" in ref) {
 			let refSchema;
-			if ("in" in ref$1) refSchema = ref$1.schema;
+			if ("in" in ref) refSchema = ref.schema;
 			if (!refSchema) {
-				const contents = mediaTypeObjects({ content: ref$1.content });
-				const content = contents.find((content$1) => content$1.type === "json") || contents[0];
+				const contents = mediaTypeObjects({ content: ref.content });
+				const content = contents.find((content) => content.type === "json") || contents[0];
 				if (content?.schema) refSchema = content.schema;
 			}
 			if (!refSchema) return false;
@@ -7559,20 +7553,20 @@ const paginationField = ({ context, name, schema }) => {
 		return paginationField({
 			context,
 			name,
-			schema: ref$1
+			schema: ref
 		});
 	}
-	for (const name$1 in schema.properties) if (getPaginationKeywordsRegExp(context.config.parser.pagination).test(name$1)) {
-		const property = schema.properties[name$1];
+	for (const name in schema.properties) if (getPaginationKeywordsRegExp(context.config.parser.pagination).test(name)) {
+		const property = schema.properties[name];
 		if (typeof property !== "boolean") {
 			const schemaTypes = getSchemaTypes({ schema: property });
 			if (!schemaTypes.length) {
-				const nonNullCompositionSchemas = (property.anyOf ?? property.oneOf ?? []).filter((schema$1) => schema$1.type !== "null");
+				const nonNullCompositionSchemas = (property.anyOf ?? property.oneOf ?? []).filter((schema) => schema.type !== "null");
 				if (nonNullCompositionSchemas.length === 1) {
-					if (isPaginationType(getSchemaTypes({ schema: nonNullCompositionSchemas[0] }))) return name$1;
+					if (isPaginationType(getSchemaTypes({ schema: nonNullCompositionSchemas[0] }))) return name;
 				}
 			}
-			if (isPaginationType(schemaTypes)) return name$1;
+			if (isPaginationType(schemaTypes)) return name;
 		}
 	}
 	for (const allOf of schema.allOf ?? []) {
@@ -7594,17 +7588,17 @@ const parseOperationJsDoc = ({ irOperation, operation }) => {
 	if (operation.summary) irOperation.summary = operation.summary;
 	if (operation.tags?.length) irOperation.tags = operation.tags;
 };
-const initIrOperation = ({ context, method, operation, path: path$1, state }) => {
+const initIrOperation = ({ context, method, operation, path, state }) => {
 	const irOperation = {
 		id: operationToId({
 			context,
 			id: operation.operationId,
 			method,
-			path: path$1,
+			path,
 			state
 		}),
 		method,
-		path: path$1
+		path
 	};
 	if (operation.operationId) irOperation.operationId = operation.operationId;
 	parseOperationJsDoc({
@@ -7617,19 +7611,19 @@ const initIrOperation = ({ context, method, operation, path: path$1, state }) =>
 	});
 	return irOperation;
 };
-const operationToIrOperation = ({ context, method, operation, path: path$1, securitySchemesMap, state }) => {
+const operationToIrOperation = ({ context, method, operation, path, securitySchemesMap, state }) => {
 	const irOperation = initIrOperation({
 		context,
 		method,
 		operation,
-		path: path$1,
+		path,
 		state
 	});
 	if (operation.parameters) irOperation.parameters = operation.parameters;
 	if (operation.requestBody) {
 		const requestBody = "$ref" in operation.requestBody ? context.resolveRef(operation.requestBody.$ref) : operation.requestBody;
 		const contents = mediaTypeObjects({ content: requestBody.content });
-		const content = contents.find((content$1) => content$1.type === "json") || contents[0];
+		const content = contents.find((content) => content.type === "json") || contents[0];
 		if (content) {
 			const pagination = paginationField({
 				context,
@@ -7661,7 +7655,7 @@ const operationToIrOperation = ({ context, method, operation, path: path$1, secu
 		const response = operation.responses[name];
 		const responseObject = "$ref" in response ? context.resolveRef(response.$ref) : response;
 		const contents = mediaTypeObjects({ content: responseObject.content });
-		const content = contents.find((content$1) => content$1.type === "json") || contents[0];
+		const content = contents.find((content) => content.type === "json") || contents[0];
 		if (content) irOperation.responses[name] = {
 			mediaType: content.mediaType,
 			schema: schemaToIrSchema({
@@ -7689,27 +7683,27 @@ const operationToIrOperation = ({ context, method, operation, path: path$1, secu
 	}
 	return irOperation;
 };
-const parseOperationObject = ({ context, method, operation, path: path$1, securitySchemesMap, state }) => {
+const parseOperationObject = ({ context, method, operation, path, securitySchemesMap, state }) => {
 	if (operation.servers) context.ir.servers = [...context.ir.servers ?? [], ...operation.servers];
 	return { parsed: operationToIrOperation({
 		context,
 		method,
 		operation,
-		path: path$1,
+		path,
 		securitySchemesMap,
 		state
 	}) };
 };
-const parsePathOperation = ({ context, method, path: path$1, ...options }) => {
+const parsePathOperation = ({ context, method, path, ...options }) => {
 	if (!context.ir.paths) context.ir.paths = {};
-	if (!context.ir.paths[path$1]) context.ir.paths[path$1] = {};
+	if (!context.ir.paths[path]) context.ir.paths[path] = {};
 	const { parsed } = parseOperationObject({
 		context,
 		method,
-		path: path$1,
+		path,
 		...options
 	});
-	context.ir.paths[path$1][method] = parsed;
+	context.ir.paths[path][method] = parsed;
 };
 const parseWebhookOperation = ({ context, key, method, ...options }) => {
 	if (!context.ir.webhooks) context.ir.webhooks = {};
@@ -7773,7 +7767,7 @@ const parameterToIrParameter = ({ $ref, context, parameter }) => {
 	let schema = parameter.schema;
 	if (!schema) {
 		const contents = mediaTypeObjects({ content: parameter.content });
-		const content = contents.find((content$1) => content$1.type === "json") || contents[0];
+		const content = contents.find((content) => content.type === "json") || contents[0];
 		if (content) schema = content.schema;
 	}
 	const finalSchema = {
@@ -7827,7 +7821,7 @@ const parseParameter = ({ $ref, context, parameter }) => {
 //#region src/openApi/3.1.x/parser/requestBody.ts
 const requestBodyToIrRequestBody = ({ $ref, context, requestBody }) => {
 	const contents = mediaTypeObjects({ content: requestBody.content });
-	const content = contents.find((content$1) => content$1.type === "json") || contents[0];
+	const content = contents.find((content) => content.type === "json") || contents[0];
 	const schema = content ? content.schema : void 0;
 	const irRequestBody = { schema: schemaToIrSchema({
 		context,
@@ -7875,14 +7869,14 @@ const validateOpenApiSpec = (spec, logger) => {
 	const issues = [];
 	const operationIds = /* @__PURE__ */ new Map();
 	if (spec.paths) for (const entry of Object.entries(spec.paths)) {
-		const path$1 = entry[0];
+		const path = entry[0];
 		const pathItem = entry[1];
 		for (const method of httpMethods) {
 			const operation = pathItem[method];
 			if (!operation) continue;
 			const operationKey = createOperationKey({
 				method,
-				path: path$1
+				path
 			});
 			if (operation.operationId) if (!operationIds.has(operation.operationId)) operationIds.set(operation.operationId, operationKey);
 			else issues.push({
@@ -7894,7 +7888,7 @@ const validateOpenApiSpec = (spec, logger) => {
 				message: "Duplicate `operationId` found. Each `operationId` must be unique.",
 				path: [
 					"paths",
-					path$1,
+					path,
 					method,
 					"operationId"
 				],
@@ -8095,8 +8089,8 @@ const parseV3_1_X = (context) => {
 	});
 	if (hasFilters(context.config.parser.filters)) {
 		const filters = createFilters(context.config.parser.filters, context.spec, context.logger);
-		const { graph: graph$1 } = buildGraph(context.spec, context.logger);
-		const { resourceMetadata } = buildResourceMetadata(graph$1, context.logger);
+		const { graph } = buildGraph(context.spec, context.logger);
+		const { resourceMetadata } = buildResourceMetadata(graph, context.logger);
 		filterSpec({
 			...createFilteredDependencies({
 				filters,
@@ -8146,9 +8140,9 @@ const parseV3_1_X = (context) => {
 		}
 	}
 	parseServers({ context });
-	for (const path$1 in context.spec.paths) {
-		if (path$1.startsWith("x-")) continue;
-		const pathItem = context.spec.paths[path$1];
+	for (const path in context.spec.paths) {
+		if (path.startsWith("x-")) continue;
+		const pathItem = context.spec.paths[path];
 		const finalPathItem = pathItem.$ref ? {
 			...context.resolveRef(pathItem.$ref),
 			...pathItem
@@ -8165,7 +8159,7 @@ const parseV3_1_X = (context) => {
 				servers: finalPathItem.servers,
 				summary: finalPathItem.summary
 			},
-			path: path$1,
+			path,
 			securitySchemesMap,
 			state
 		};
@@ -8388,7 +8382,7 @@ async function patchOpenApiSpec({ patchOptions, spec: _spec }) {
 			const patchFn = patchOptions.schemas[key];
 			await patchFn(schema);
 		}
-		if (patchOptions.operations && spec.paths) if (typeof patchOptions.operations === "function") for (const [path$1, pathItem] of Object.entries(spec.paths)) {
+		if (patchOptions.operations && spec.paths) if (typeof patchOptions.operations === "function") for (const [path, pathItem] of Object.entries(spec.paths)) {
 			if (!pathItem || typeof pathItem !== "object") continue;
 			for (const method of [
 				"get",
@@ -8402,13 +8396,13 @@ async function patchOpenApiSpec({ patchOptions, spec: _spec }) {
 			]) {
 				const operation = pathItem[method];
 				if (!operation || typeof operation !== "object") continue;
-				await patchOptions.operations(method, path$1, operation);
+				await patchOptions.operations(method, path, operation);
 			}
 		}
 		else for (const key in patchOptions.operations) {
-			const [method, path$1] = key.split(" ");
-			if (!method || !path$1) continue;
-			const pathItem = spec.paths[path$1];
+			const [method, path] = key.split(" ");
+			if (!method || !path) continue;
+			const pathItem = spec.paths[path];
 			if (!pathItem) continue;
 			const operation = pathItem[method.toLocaleLowerCase()] || pathItem[method.toLocaleUpperCase()];
 			if (!operation || typeof operation !== "object") continue;
@@ -8447,7 +8441,7 @@ async function patchOpenApiSpec({ patchOptions, spec: _spec }) {
 			patchFn(schema);
 		}
 	}
-	if (patchOptions.operations && spec.paths) if (typeof patchOptions.operations === "function") for (const [path$1, pathItem] of Object.entries(spec.paths)) {
+	if (patchOptions.operations && spec.paths) if (typeof patchOptions.operations === "function") for (const [path, pathItem] of Object.entries(spec.paths)) {
 		if (!pathItem || typeof pathItem !== "object") continue;
 		for (const method of [
 			"get",
@@ -8461,13 +8455,13 @@ async function patchOpenApiSpec({ patchOptions, spec: _spec }) {
 		]) {
 			const operation = pathItem[method];
 			if (!operation || typeof operation !== "object") continue;
-			await patchOptions.operations(method, path$1, operation);
+			await patchOptions.operations(method, path, operation);
 		}
 	}
 	else for (const key in patchOptions.operations) {
-		const [method, path$1] = key.split(" ");
-		if (!method || !path$1) continue;
-		const pathItem = spec.paths[path$1];
+		const [method, path] = key.split(" ");
+		if (!method || !path) continue;
+		const pathItem = spec.paths[path];
 		if (!pathItem) continue;
 		const operation = pathItem[method.toLocaleLowerCase()] || pathItem[method.toLocaleUpperCase()];
 		if (!operation || typeof operation !== "object") continue;
@@ -8494,6 +8488,33 @@ const mappers = {
 	string: (name) => ({ name })
 };
 
+//#endregion
+//#region src/plugins/symbol.ts
+/**
+* Helper function to build the input for symbol registration, applying naming hooks if provided.
+*/
+function buildSymbolIn({ plugin, ...ctx }) {
+	const hooks = [plugin.config["~hooks"]?.symbols?.getName, plugin.context.config.parser.hooks.symbols?.getName];
+	for (const hook of hooks) {
+		if (!hook) continue;
+		const result = hook(ctx);
+		if (typeof result === "function") {
+			const name = result(ctx);
+			if (name) return {
+				meta: ctx.meta,
+				name
+			};
+		} else if (typeof result === "string") return {
+			meta: ctx.meta,
+			name: ctx.naming ? applyNaming(result, ctx.naming) : result
+		};
+	}
+	return {
+		meta: ctx.meta,
+		name: ctx.naming ? applyNaming(ctx.name, ctx.naming) : ctx.name
+	};
+}
+
 //#endregion
 //#region src/utils/escape.ts
 function escapeComment(value) {
@@ -8517,9 +8538,14 @@ const utils = {
 /**
 * Converts an {@link OutputHeader} value to a string prefix for file content.
 */
-function outputHeaderToPrefix(header, project) {
-	let lines = typeof header === "function" ? header({ project }) : header;
-	if (lines === null || lines === void 0) return "";
+function outputHeaderToPrefix(ctx) {
+	const { defaultValue, header, project } = ctx;
+	let lines = typeof header === "function" ? header({
+		defaultValue,
+		project
+	}) : header;
+	if (lines === void 0) lines = defaultValue;
+	if (lines === null) return "";
 	lines = typeof lines === "string" ? lines.split(/\r?\n/) : lines.flatMap((line) => line.split(/\r?\n/));
 	const content = lines.join("\n");
 	return content ? `${content}\n\n` : "";
@@ -8593,35 +8619,35 @@ function sanitizeSegment(segment) {
 *   paths//event/get/properties/query, { anchor: 'event.subscribe' }
 *                                               → 'event.subscribe-Query'
 */
-function pathToName(path$1, options) {
+function pathToName(path, options) {
 	const names = [];
 	let index = 0;
-	const rootContext = ROOT_CONTEXT[path$1[0]];
+	const rootContext = ROOT_CONTEXT[path[0]];
 	if (rootContext) {
 		index = rootContext.skip;
 		if (options?.anchor) {
 			names.push(options.anchor);
 			index += rootContext.names;
-		} else for (let n = 0; n < rootContext.names && index < path$1.length; n++) {
-			names.push(sanitizeSegment(path$1[index]));
+		} else for (let n = 0; n < rootContext.names && index < path.length; n++) {
+			names.push(sanitizeSegment(path[index]));
 			index++;
 		}
 	} else if (options?.anchor) {
 		names.push(options.anchor);
 		index++;
-	} else if (index < path$1.length) {
-		names.push(sanitizeSegment(path$1[index]));
+	} else if (index < path.length) {
+		names.push(sanitizeSegment(path[index]));
 		index++;
 	}
-	while (index < path$1.length) {
-		const segment = String(path$1[index]);
+	while (index < path.length) {
+		const segment = String(path[index]);
 		const role = STRUCTURAL_ROLE[segment];
 		if (role === "name") {
 			index++;
-			if (index < path$1.length) names.push(sanitizeSegment(path$1[index]));
+			if (index < path.length) names.push(sanitizeSegment(path[index]));
 		} else if (role === "index") {
 			index++;
-			if (index < path$1.length && typeof path$1[index] === "number") index++;
+			if (index < path.length && typeof path[index] === "number") index++;
 			continue;
 		} else if (STRUCTURAL_SUFFIX[segment]) names.push(STRUCTURAL_SUFFIX[segment]);
 		index++;
@@ -8630,5 +8656,5 @@ function pathToName(path$1, options) {
 }
 
 //#endregion
-export { ConfigError, ConfigValidationError, Context, HeyApiError, IntentContext, JobError, MinHeap, OperationPath, OperationStrategy, PluginInstance, addItemsToSchema, applyNaming, buildGraph, checkNodeVersion, childContext, compileInputPath, createOperationKey, createSchemaProcessor, createSchemaWalker, debugTools, deduplicateSchema, defaultPaginationKeywords, definePluginConfig, dependencyFactory, encodeJsonPointerSegment, ensureDirSync, escapeComment, findPackageJson, findTsConfigPath, getInput, getLogs, getParser, getSpec, hasOperationDataRequired, hasParameterGroupObjectRequired, hasParametersObjectRequired, heyApiRegistryBaseUrl, inputToApiRegistry, isTopLevelComponent, jsonPointerToPath, loadPackageJson, loadTsConfig, logCrashReport, logInputPaths, mappers, normalizeJsonPointer, openGitHubIssueWithCrashReport, operationPagination, operationResponsesMap, outputHeaderToPrefix, parameterWithPagination, parseOpenApiSpec, parseUrl, parseV2_0_X, parseV3_0_X, parseV3_1_X, patchOpenApiSpec, pathToJsonPointer, pathToName, postprocessOutput, printCliIntro, printCrashReport, refToName, resolveNaming, resolveRef, resolveSource, satisfies, shouldReportCrash, statusCodeToGroup, toCase, utils, valueToObject };
+export { ConfigError, ConfigValidationError, Context, HeyApiError, IntentContext, JobError, MinHeap, OperationPath, OperationStrategy, PluginInstance, addItemsToSchema, applyNaming, buildGraph, buildSymbolIn, checkNodeVersion, childContext, compileInputPath, createOperationKey, createSchemaProcessor, createSchemaWalker, debugTools, deduplicateSchema, defaultPaginationKeywords, definePluginConfig, dependencyFactory, encodeJsonPointerSegment, ensureDirSync, escapeComment, findPackageJson, findTsConfigPath, getInput, getLogs, getParser, getSpec, hasOperationDataRequired, hasParameterGroupObjectRequired, hasParametersObjectRequired, heyApiRegistryBaseUrl, inputToApiRegistry, isEnvironment, isTopLevelComponent, jsonPointerToPath, loadPackageJson, logCrashReport, logInputPaths, mappers, normalizeJsonPointer, openGitHubIssueWithCrashReport, operationPagination, operationResponsesMap, outputHeaderToPrefix, parameterWithPagination, parseOpenApiSpec, parseUrl, parseV2_0_X, parseV3_0_X, parseV3_1_X, patchOpenApiSpec, pathToJsonPointer, pathToName, postprocessOutput, printCliIntro, printCrashReport, refToName, resolveNaming, resolveRef, resolveSource, satisfies, shouldReportCrash, statusCodeToGroup, toCase, utils, valueToObject };
 //# sourceMappingURL=index.mjs.map