orval 8.21.0 → 8.22.0

package/dist/{config-DGhExJ4J.mjs → config-CotJKggp.mjs}

@@ -4,7 +4,9 @@ import { DefaultTag, FormDataArrayHandling, GetterPropType, NamingConvention, Ou
 import { bundle } from "@scalar/json-magic/bundle";
 import { fetchUrls, parseJson, parseYaml, readFiles } from "@scalar/json-magic/bundle/plugins/node";
 import { upgrade, validate } from "@scalar/openapi-parser";
+import fs, { access, readFile } from "node:fs/promises";
 import { isNullish as isNullish$1, pick, unique } from "remeda";
+import jsYaml from "js-yaml";
 import * as mock from "@orval/mock";
 import { dedupeStrictMockTypeDeclarations, generateFakerForSchemas, generateMockImports, getDefaultMockOptionsForType } from "@orval/mock";
 import angular from "@orval/angular";
@@ -17,19 +19,17 @@ import query from "@orval/query";
 import solidStart from "@orval/solid-start";
 import swr from "@orval/swr";
 import zod, { assertZodTarget, dereference, generateFormDataZodSchema, generateZodValidationSchemaDefinition, getZodImportSource, getZodTypeName, parseZodValidationSchemaDefinition, resolveIsZodV4 } from "@orval/zod";
-import { ExecaError, execa } from "execa";
-import fs from "fs-extra";
-import fs$1, { access } from "node:fs/promises";
+import fs$1, { existsSync } from "node:fs";
 import { styleText } from "node:util";
-import { parseArgsStringToArgv } from "string-argv";
-import fs$2, { existsSync } from "node:fs";
 import { findUp, findUpMultiple } from "find-up";
-import yaml from "js-yaml";
+import fs$2 from "fs-extra";
 import { parseTsconfig } from "get-tsconfig";
+import { ExecaError, execa } from "execa";
+import { parseArgsStringToArgv } from "string-argv";
 import { createJiti } from "jiti";
 //#region package.json
 var name = "orval";
-var version = "8.21.0";
+var version = "8.22.0";
 var description = "A swagger client generator for typescript";
 //#endregion
 //#region src/client.ts
@@ -348,594 +348,246 @@ function getApiSchemas({ input, output, target, workspace, spec }) {
 	];
 }
 //#endregion
-//#region src/import-specs.ts
-async function resolveSpec(input, { parserOptions, transformer, workspace, unsafeDisableValidation = false }) {
-	const dereferencedData = await bundleAndDereferenceExternalRefs(input, parserOptions);
-	let transformedData = dereferencedData;
-	if (transformer) {
-		const applied = await applyInputTransformer(dereferencedData, transformer, workspace);
-		transformedData = hasExternalRef(applied) ? await bundleAndDereferenceExternalRefs(applied, parserOptions, isString(input) ? input : void 0) : applied;
+//#region src/utils/package-json.ts
+const loadPackageJson = async (packageJson, workspace = process.cwd()) => {
+	if (!packageJson) {
+		const pkgPath = await findUp(["package.json"], { cwd: workspace });
+		if (pkgPath) {
+			const pkg = await dynamicImport(pkgPath, workspace);
+			if (isPackageJson(pkg)) return resolveAndAttachVersions(await maybeReplaceCatalog(pkg, workspace), workspace, pkgPath);
+			else throw new Error("Invalid package.json file");
+		}
+		return;
 	}
-	if (unsafeDisableValidation) logWarning("🚨 OpenAPI spec validation is disabled.\n  Code generation with invalid specs is not guaranteed to work and may break in minor updates.\n  Bug reports with validation disabled will not be accepted.");
-	else {
-		validateComponentKeys(transformedData);
-		const { valid, errors } = await validate(transformedData);
-		if (!valid) throw new Error(`OpenAPI spec validation failed:\n${JSON.stringify(errors, void 0, 2)}`);
+	const normalizedPath = normalizePath(packageJson, workspace);
+	if (fs$2.existsSync(normalizedPath)) {
+		const pkg = await dynamicImport(normalizedPath);
+		if (isPackageJson(pkg)) return resolveAndAttachVersions(await maybeReplaceCatalog(pkg, workspace), workspace, normalizedPath);
+		else throw new Error(`Invalid package.json file: ${normalizedPath}`);
 	}
-	const { specification } = upgrade(transformedData);
-	return specification;
-}
-async function applyInputTransformer(data, transformer, workspace) {
-	const transformerFn = await dynamicImport(transformer, workspace);
-	const result = await transformerFn(data);
-	if (!isObject(result)) {
-		const source = isString(transformer) ? transformer : transformerFn.name || "<inline function>";
-		throw new Error(`input.override.transformer must return an OpenAPI document object; got ${result === void 0 ? "undefined" : typeof result} from ${source}. Ensure your transformer returns the (possibly modified) spec.`);
+};
+const isPackageJson = (obj) => isObject(obj);
+const resolvedCache = /* @__PURE__ */ new Map();
+const resolveAndAttachVersions = (pkg, workspace, cacheKey) => {
+	const cached = resolvedCache.get(cacheKey);
+	if (cached) {
+		pkg.resolvedVersions = cached;
+		return pkg;
 	}
-	return result;
-}
+	const resolved = resolveInstalledVersions(pkg, workspace);
+	if (Object.keys(resolved).length > 0) {
+		pkg.resolvedVersions = resolved;
+		resolvedCache.set(cacheKey, resolved);
+		for (const [name, version] of Object.entries(resolved)) logVerbose(styleText("dim", `Detected ${styleText("white", name)} v${styleText("white", version)}`));
+	}
+	return pkg;
+};
+const hasCatalogReferences = (pkg) => {
+	return [
+		...Object.entries(pkg.dependencies ?? {}),
+		...Object.entries(pkg.devDependencies ?? {}),
+		...Object.entries(pkg.peerDependencies ?? {})
+	].some(([, value]) => isString(value) && value.startsWith("catalog:"));
+};
+const loadPnpmWorkspaceCatalog = async (workspace) => {
+	const filePath = await findUp("pnpm-workspace.yaml", { cwd: workspace });
+	if (!filePath) return void 0;
+	try {
+		const file = await fs$2.readFile(filePath, "utf8");
+		const data = jsYaml.load(file);
+		if (!data?.catalog && !data?.catalogs) return void 0;
+		return {
+			catalog: data.catalog,
+			catalogs: data.catalogs
+		};
+	} catch {
+		return;
+	}
+};
+const loadPackageJsonCatalog = async (workspace) => {
+	const filePaths = await findUpMultiple("package.json", { cwd: workspace });
+	for (const filePath of filePaths) try {
+		const pkg = await fs$2.readJson(filePath);
+		if (pkg.catalog || pkg.catalogs) return {
+			catalog: pkg.catalog,
+			catalogs: pkg.catalogs
+		};
+	} catch {}
+};
+const loadYarnrcCatalog = async (workspace) => {
+	const filePath = await findUp(".yarnrc.yml", { cwd: workspace });
+	if (!filePath) return void 0;
+	try {
+		const file = await fs$2.readFile(filePath, "utf8");
+		const data = jsYaml.load(file);
+		if (!data?.catalog && !data?.catalogs) return void 0;
+		return {
+			catalog: data.catalog,
+			catalogs: data.catalogs
+		};
+	} catch {
+		return;
+	}
+};
+const maybeReplaceCatalog = async (pkg, workspace) => {
+	if (!hasCatalogReferences(pkg)) return pkg;
+	const catalogData = await loadPnpmWorkspaceCatalog(workspace) ?? await loadPackageJsonCatalog(workspace) ?? await loadYarnrcCatalog(workspace);
+	if (!catalogData) {
+		logWarning("⚠️  package.json contains catalog: references, but no catalog source was found (checked: pnpm-workspace.yaml, package.json, .yarnrc.yml).");
+		return pkg;
+	}
+	performSubstitution(pkg.dependencies, catalogData);
+	performSubstitution(pkg.devDependencies, catalogData);
+	performSubstitution(pkg.peerDependencies, catalogData);
+	return pkg;
+};
+const performSubstitution = (dependencies, catalogData) => {
+	if (!dependencies) return;
+	for (const [packageName, version] of Object.entries(dependencies)) if (version === "catalog:" || version === "catalog:default") {
+		if (!catalogData.catalog) {
+			logWarning(`⚠️  catalog: substitution for the package '${packageName}' failed as there is no default catalog.`);
+			continue;
+		}
+		const sub = catalogData.catalog[packageName];
+		if (!sub) {
+			logWarning(`⚠️  catalog: substitution for the package '${packageName}' failed as there is no matching package in the default catalog.`);
+			continue;
+		}
+		dependencies[packageName] = sub;
+	} else if (version.startsWith("catalog:")) {
+		const catalogName = version.slice(8);
+		const catalog = catalogData.catalogs?.[catalogName];
+		if (!catalog) {
+			logWarning(`⚠️  '${version}' substitution for the package '${packageName}' failed as there is no matching catalog named '${catalogName}'. (available named catalogs are: ${Object.keys(catalogData.catalogs ?? {}).join(", ")})`);
+			continue;
+		}
+		const sub = catalog[packageName];
+		if (!sub) {
+			logWarning(`⚠️  '${version}' substitution for the package '${packageName}' failed as there is no package in the catalog named '${catalogName}'. (packages in the catalog are: ${Object.keys(catalog).join(", ")})`);
+			continue;
+		}
+		dependencies[packageName] = sub;
+	}
+};
+//#endregion
+//#region src/utils/tsconfig.ts
+const convertTarget = (config) => {
+	if (!config.compilerOptions?.target) return {
+		baseUrl: config.compilerOptions?.baseUrl,
+		...config
+	};
+	const lowercaseTarget = config.compilerOptions.target.toLowerCase();
+	return {
+		baseUrl: config.compilerOptions.baseUrl,
+		...config,
+		compilerOptions: {
+			...config.compilerOptions,
+			target: lowercaseTarget
+		}
+	};
+};
+const loadTsconfig = async (tsconfig, workspace = process.cwd()) => {
+	if (isNullish(tsconfig)) {
+		const configPath = await findUp(["tsconfig.json", "jsconfig.json"], { cwd: workspace });
+		if (configPath) return convertTarget(parseTsconfig(configPath));
+		return;
+	}
+	if (isString(tsconfig)) {
+		const normalizedPath = normalizePath(tsconfig, workspace);
+		if (fs$2.existsSync(normalizedPath)) return convertTarget(parseTsconfig(normalizedPath));
+		return;
+	}
+	if (isObject(tsconfig)) return tsconfig;
+};
+//#endregion
+//#region src/utils/options.ts
+const INPUT_TARGET_FETCH_TIMEOUT_MS = 1e4;
 /**
-* Bundle external references into the document and then resolve the `x-ext`
-* entries that `@scalar/json-magic` produces. Shared by the initial pass and
-* the post-transformer pass (#3327); `origin` lets the second pass resolve refs
-* relative to the original spec file when the input is an in-memory object.
+* Type helper to make it easier to use orval.config.ts
+* accepts a direct {@link ConfigExternal} object.
 */
-async function bundleAndDereferenceExternalRefs(input, parserOptions, origin) {
-	return dereferenceExternalRef(await bundle(input, {
-		plugins: [
-			readFiles(),
-			fetchUrls({ headers: parserOptions?.headers }),
-			parseJson(),
-			parseYaml()
-		],
-		treeShake: false,
-		...origin ? { origin } : {}
-	}));
+function defineConfig(options) {
+	return options;
 }
 /**
-* Report whether any `$ref` in the document points to an external document.
-* Per the JSON Reference rules a ref is external when it does not start with
-* `#` (an in-document pointer). Used to decide whether a transformer introduced
-* new external refs that need a second bundle pass (#3327) — when it did not,
-* the already-bundled spec is returned untouched.
+* Type helper to make it easier to write input transformers.
+* accepts a direct {@link InputTransformerFn} function.
 */
-function hasExternalRef(obj) {
-	if (Array.isArray(obj)) return obj.some((item) => hasExternalRef(item));
-	if (isObject(obj)) {
-		if ("$ref" in obj && isString(obj.$ref) && !obj.$ref.startsWith("#")) return true;
-		return Object.values(obj).some((value) => hasExternalRef(value));
-	}
-	return false;
+function defineTransformer(transformer) {
+	return transformer;
 }
-async function importSpecs(workspace, options, projectName) {
-	const { input, output } = options;
-	return importOpenApi({
-		spec: await resolveSpec(input.target, {
-			parserOptions: input.parserOptions,
-			transformer: input.override.transformer,
-			workspace,
-			unsafeDisableValidation: input.unsafeDisableValidation
-		}),
-		input,
-		output,
-		target: isString(input.target) ? input.target : workspace,
-		workspace,
-		projectName
-	});
+function createFormData(workspace, formData) {
+	const defaultArrayHandling = FormDataArrayHandling.SERIALIZE;
+	if (formData === void 0) return {
+		disabled: false,
+		arrayHandling: defaultArrayHandling
+	};
+	if (isBoolean(formData)) return {
+		disabled: !formData,
+		arrayHandling: defaultArrayHandling
+	};
+	if (isString(formData)) return {
+		disabled: false,
+		mutator: normalizeMutator(workspace, formData),
+		arrayHandling: defaultArrayHandling
+	};
+	if ("mutator" in formData || "arrayHandling" in formData) return {
+		disabled: false,
+		mutator: normalizeMutator(workspace, formData.mutator),
+		arrayHandling: formData.arrayHandling ?? defaultArrayHandling
+	};
+	return {
+		disabled: false,
+		mutator: normalizeMutator(workspace, formData),
+		arrayHandling: defaultArrayHandling
+	};
+}
+function normalizeSchemasOption(schemas, workspace) {
+	if (!schemas) return;
+	if (isString(schemas)) return normalizePath(schemas, workspace);
+	validatePackageSpecifier(schemas.importPath, "schemas.importPath");
+	return {
+		path: normalizePath(schemas.path, workspace),
+		type: schemas.type ?? "typescript",
+		importPath: schemas.importPath,
+		splitByTags: schemas.splitByTags ?? false
+	};
 }
-const COMPONENT_KEY_PATTERN = /^[a-zA-Z0-9.\-_]+$/;
-const COMPONENT_SECTIONS = [
-	"schemas",
-	"responses",
-	"parameters",
-	"examples",
-	"requestBodies",
-	"headers",
-	"securitySchemes",
-	"links",
-	"callbacks",
-	"pathItems"
-];
 /**
-* Validate that all component keys conform to the OAS regex: ^[a-zA-Z0-9.\-_]+$
-* @see https://spec.openapis.org/oas/v3.0.3.html#fixed-fields-5
-* @see https://spec.openapis.org/oas/v3.1.0#fixed-fields-5
-*/
-function validateComponentKeys(data) {
-	const components = data.components;
-	if (!isObject(components)) return;
-	const invalidKeys = [];
-	for (const section of COMPONENT_SECTIONS) {
-		const sectionObj = components[section];
-		if (!isObject(sectionObj)) continue;
-		for (const key of Object.keys(sectionObj)) if (!COMPONENT_KEY_PATTERN.test(key)) invalidKeys.push(`components.${section}.${key}`);
-	}
-	if (invalidKeys.length > 0) throw new Error(`Invalid component key${invalidKeys.length > 1 ? "s" : ""} found. OpenAPI component keys must match the pattern ${COMPONENT_KEY_PATTERN} (non-ASCII characters are not allowed per the spec).\n  See: https://spec.openapis.org/oas/v3.0.3.html#components-object\n  Invalid keys:\n` + invalidKeys.map((k) => `    - ${k}`).join("\n"));
-}
-/**
-* The plugins from `@scalar/json-magic` does not dereference $ref.
-* Instead it fetches them and puts them under x-ext, and changes the $ref to point to #x-ext/<name>.
-* This function:
-* 1. Merges external schemas into main spec's components.schemas (with collision handling)
-* 2. Replaces x-ext refs with standard component refs or inlined content
-*/
-function dereferenceExternalRef(data) {
-	const extensions = data["x-ext"] ?? {};
-	const schemaNameMappings = mergeExternalSchemas(data, extensions);
-	const result = {};
-	for (const [key, value] of Object.entries(data)) if (key !== "x-ext") result[key] = replaceXExtRefs(value, extensions, schemaNameMappings);
-	return result;
-}
-/**
-* Merge external document schemas into main spec's components.schemas
-* Returns mapping of original schema names to final names (with suffixes for collisions)
-*/
-function mergeExternalSchemas(data, extensions) {
-	const schemaNameMappings = {};
-	if (Object.keys(extensions).length === 0) return schemaNameMappings;
-	data.components ??= {};
-	const mainComponents = data.components;
-	mainComponents.schemas ??= {};
-	const mainSchemas = mainComponents.schemas;
-	for (const [extKey, extDoc] of Object.entries(extensions)) {
-		schemaNameMappings[extKey] = {};
-		if (isObject(extDoc) && "components" in extDoc) {
-			const extComponents = extDoc.components;
-			if (isObject(extComponents) && "schemas" in extComponents) {
-				const extSchemas = extComponents.schemas;
-				for (const [schemaName, schema] of Object.entries(extSchemas)) {
-					const existingSchema = mainSchemas[schemaName];
-					const isXExtRef = isObject(existingSchema) && "$ref" in existingSchema && isString(existingSchema.$ref) && existingSchema.$ref.startsWith("#/x-ext/");
-					let finalSchemaName = schemaName;
-					if (schemaName in mainSchemas && !isXExtRef) {
-						finalSchemaName = `${schemaName}_${extKey.replaceAll(/[^a-zA-Z0-9]/g, "_")}`;
-						schemaNameMappings[extKey][schemaName] = finalSchemaName;
-					} else schemaNameMappings[extKey][schemaName] = schemaName;
-					mainSchemas[finalSchemaName] = scrubUnwantedKeys(schema);
-				}
-			}
-		}
-	}
-	for (const [extKey, mapping] of Object.entries(schemaNameMappings)) for (const [, finalName] of Object.entries(mapping)) {
-		const schema = mainSchemas[finalName];
-		if (schema) mainSchemas[finalName] = updateInternalRefs(schema, extKey, schemaNameMappings);
-	}
-	return schemaNameMappings;
-}
-/**
-* Remove unwanted keys like $schema and $id from objects
-*/
-function scrubUnwantedKeys(obj) {
-	const UNWANTED_KEYS = new Set(["$schema", "$id"]);
-	if (obj === null || obj === void 0) return obj;
-	if (Array.isArray(obj)) return obj.map((x) => scrubUnwantedKeys(x));
-	if (isObject(obj)) {
-		const rec = obj;
-		const out = {};
-		for (const [k, v] of Object.entries(rec)) {
-			if (UNWANTED_KEYS.has(k)) continue;
-			out[k] = scrubUnwantedKeys(v);
-		}
-		return out;
-	}
-	return obj;
-}
-/**
-* Update internal refs within an external schema to use suffixed names
-*/
-function updateInternalRefs(obj, extKey, schemaNameMappings) {
-	if (obj === null || obj === void 0) return obj;
-	if (Array.isArray(obj)) return obj.map((element) => updateInternalRefs(element, extKey, schemaNameMappings));
-	if (isObject(obj)) {
-		const record = obj;
-		if ("$ref" in record && isString(record.$ref)) {
-			const refValue = record.$ref;
-			if (refValue.startsWith("#/components/schemas/")) {
-				const schemaName = refValue.replace("#/components/schemas/", "");
-				const mappedName = schemaNameMappings[extKey][schemaName];
-				if (mappedName) return { $ref: `#/components/schemas/${mappedName}` };
-			}
-		}
-		const result = {};
-		for (const [key, value] of Object.entries(record)) result[key] = updateInternalRefs(value, extKey, schemaNameMappings);
-		return result;
-	}
-	return obj;
-}
-/**
-* Decode a single JSON Pointer reference token taken from an x-ext `$ref`.
-*
-* The token carries two layers of encoding: it sits in a URI fragment, so it
-* may be percent-encoded (e.g. `%7B` for `{` in templated paths), and it is a
-* JSON Pointer token, so `~1`/`~0` stand for `/`/`~` (RFC 6901). Percent-
-* encoding is the outer layer and is removed first; a malformed sequence is
-* left as-is rather than throwing. Without this, tokens such as `~1pets`
-* never match the real `/pets` key and the external `$ref` fails to resolve.
-*/
-function decodeRefToken(token) {
-	let decoded = token;
-	try {
-		decoded = decodeURIComponent(token);
-	} catch {}
-	return decoded.replaceAll("~1", "/").replaceAll("~0", "~");
-}
-/**
-* Replace x-ext refs with standard component refs, or inline the content.
-* `inliningRefs` tracks the inline chain to break cycles in recursive
-* external schemas that aren't under `components.schemas` (#1642).
-*/
-function replaceXExtRefs(obj, extensions, schemaNameMappings, inliningRefs = /* @__PURE__ */ new Set()) {
-	if (isNullish$1(obj)) return obj;
-	if (Array.isArray(obj)) return obj.map((element) => replaceXExtRefs(element, extensions, schemaNameMappings, inliningRefs));
-	if (isObject(obj)) {
-		const record = obj;
-		if ("$ref" in record && isString(record.$ref)) {
-			const refValue = record.$ref;
-			if (refValue.startsWith("#/x-ext/")) {
-				const parts = refValue.replace("#/x-ext/", "").split("/");
-				const extKey = parts.shift();
-				if (extKey) {
-					if (parts.length >= 3 && parts[0] === "components" && parts[1] === "schemas") {
-						const schemaName = parts.slice(2).join("/");
-						return { $ref: `#/components/schemas/${schemaNameMappings[extKey][schemaName] || schemaName}` };
-					}
-					if (inliningRefs.has(refValue)) {
-						logWarning(`Detected a circular external $ref while inlining "${refValue}". Replacing with an empty schema to avoid infinite recursion. Move the schema under "components.schemas" in its source file or pre-bundle the spec to keep the recursion intact.`);
-						return {};
-					}
-					let refObj = extensions[extKey];
-					for (const rawPart of parts) {
-						const p = decodeRefToken(rawPart);
-						if (refObj && (isObject(refObj) || Array.isArray(refObj)) && p in refObj) refObj = refObj[p];
-						else {
-							refObj = void 0;
-							break;
-						}
-					}
-					if (refObj) {
-						const cleaned = scrubUnwantedKeys(refObj);
-						const nextInlining = new Set(inliningRefs);
-						nextInlining.add(refValue);
-						return replaceXExtRefs(cleaned, extensions, schemaNameMappings, nextInlining);
-					}
-				}
-			}
-		}
-		const result = {};
-		for (const [key, value] of Object.entries(record)) result[key] = replaceXExtRefs(value, extensions, schemaNameMappings, inliningRefs);
-		return result;
-	}
-	return obj;
-}
-//#endregion
-//#region src/formatters/prettier.ts
-/**
-* Format files with prettier.
-* Tries the programmatic API first (project dependency),
-* then falls back to the globally installed CLI.
+* Validates that a config value is a valid package specifier (bare specifier
+* or sub-path import like `@acme/models` / `@acme/models/fakers`). Rejects
+* empty, whitespace-only, relative (`./`, `../`), and absolute paths with a
+* clear, actionable error message. No-op when the value is `undefined`.
 */
-async function formatWithPrettier(paths, projectTitle) {
-	const prettier = await tryImportPrettier();
-	if (prettier) {
-		const filePaths = [...new Set(await collectFilePaths(paths))];
-		if (filePaths.length === 0) return;
-		const config = await prettier.resolveConfig(filePaths[0]) ?? {};
-		await Promise.all(filePaths.map(async (filePath) => {
-			try {
-				const content = await fs$1.readFile(filePath, "utf8");
-				const formatted = await prettier.format(content, {
-					...config,
-					filepath: filePath
-				});
-				await fs$1.writeFile(filePath, formatted);
-			} catch (error) {
-				if (isMissingFileError(error)) return;
-				if (error instanceof Error) if (error.name === "UndefinedParserError") {} else logWarning(`⚠️  ${projectTitle ? `${projectTitle} - ` : ""}Failed to format file ${filePath}: ${error.toString()}`);
-				else logWarning(`⚠️  ${projectTitle ? `${projectTitle} - ` : ""}Failed to format file ${filePath}: unknown error`);
-			}
-		}));
-		return;
-	}
-	try {
-		await execa("prettier", ["--write", ...paths]);
-	} catch {
-		logWarning(`⚠️  ${projectTitle ? `${projectTitle} - ` : ""}prettier not found. Install it as a project dependency or globally.`);
-	}
+function validatePackageSpecifier(value, fieldName) {
+	if (value === void 0) return;
+	if (!value) throw new Error(`\`${fieldName}\` must be a non-empty package specifier (e.g. '@acme/models'). Received an empty string.`);
+	if (value.trim() === "") throw new Error(`\`${fieldName}\` must be a non-empty package specifier (e.g. '@acme/models'). Received a whitespace-only string.`);
+	if (value.trim() !== value) throw new Error(`\`${fieldName}\` must be a non-empty package specifier (e.g. '@acme/models'). Received a value with leading or trailing whitespace: "${value}"`);
+	if (value.startsWith(".")) throw new Error(`\`${fieldName}\` must be a package specifier (e.g. '@acme/models'), not a relative path. Received: "${value}"`);
+	if (path.isAbsolute(value) || /^[A-Za-z]:[\\/]/.test(value) || value.startsWith("\\\\")) throw new Error(`\`${fieldName}\` must be a package specifier (e.g. '@acme/models'), not an absolute path. Received: "${value}"`);
 }
-function isMissingFileError(error) {
-	return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+function looksLikePackageSpecifier(value) {
+	return !!value && value.trim() === value && !value.startsWith(".") && !path.isAbsolute(value) && !/^[A-Za-z]:[\\/]/.test(value) && !value.startsWith("\\\\");
 }
-/**
-* Try to import prettier from the project's dependencies.
-* Returns undefined if prettier is not installed.
-*/
-async function tryImportPrettier() {
+function resolvePackageSpecifier(workspace, value) {
 	try {
-		return await import("prettier");
+		return createRequire(path.join(workspace, "package.json")).resolve(value);
 	} catch {
 		return;
 	}
 }
-/**
-* Recursively collect absolute file paths from a mix of files and directories.
-*/
-async function collectFilePaths(paths) {
-	const results = [];
-	for (const p of paths) {
-		const absolute = path.resolve(p);
-		try {
-			const stat = await fs$1.stat(absolute);
-			if (stat.isFile()) results.push(absolute);
-			else if (stat.isDirectory()) {
-				const subFiles = await collectFilePaths((await fs$1.readdir(absolute)).map((entry) => path.join(absolute, entry)));
-				results.push(...subFiles);
-			}
-		} catch {}
-	}
-	return results;
-}
-//#endregion
-//#region src/utils/execute-hook.ts
-const executeHook = async (name, commands = [], args = []) => {
-	log(styleText("white", `Running ${name} hook...`));
-	for (const command of commands) try {
-		if (isString(command)) await executeCommand(command, args);
-		else if (isFunction(command)) await command(args);
-		else if (isObject(command)) await executeObjectCommand(command, args);
-	} catch (error) {
-		logError(error, `Failed to run ${name} hook`);
-	}
-};
-async function executeCommand(command, args) {
-	const [cmd, ..._args] = [...parseArgsStringToArgv(command), ...args];
-	await execa(cmd, _args);
-}
-async function executeObjectCommand(command, args) {
-	if (command.injectGeneratedDirsAndFiles === false) args = [];
-	if (isString(command.command)) await executeCommand(command.command, args);
-	else if (isFunction(command.command)) await command.command();
-}
-//#endregion
-//#region src/utils/package-json.ts
-const loadPackageJson = async (packageJson, workspace = process.cwd()) => {
-	if (!packageJson) {
-		const pkgPath = await findUp(["package.json"], { cwd: workspace });
-		if (pkgPath) {
-			const pkg = await dynamicImport(pkgPath, workspace);
-			if (isPackageJson(pkg)) return resolveAndAttachVersions(await maybeReplaceCatalog(pkg, workspace), workspace, pkgPath);
-			else throw new Error("Invalid package.json file");
-		}
-		return;
-	}
-	const normalizedPath = normalizePath(packageJson, workspace);
-	if (fs.existsSync(normalizedPath)) {
-		const pkg = await dynamicImport(normalizedPath);
-		if (isPackageJson(pkg)) return resolveAndAttachVersions(await maybeReplaceCatalog(pkg, workspace), workspace, normalizedPath);
-		else throw new Error(`Invalid package.json file: ${normalizedPath}`);
-	}
-};
-const isPackageJson = (obj) => isObject(obj);
-const resolvedCache = /* @__PURE__ */ new Map();
-const resolveAndAttachVersions = (pkg, workspace, cacheKey) => {
-	const cached = resolvedCache.get(cacheKey);
-	if (cached) {
-		pkg.resolvedVersions = cached;
-		return pkg;
-	}
-	const resolved = resolveInstalledVersions(pkg, workspace);
-	if (Object.keys(resolved).length > 0) {
-		pkg.resolvedVersions = resolved;
-		resolvedCache.set(cacheKey, resolved);
-		for (const [name, version] of Object.entries(resolved)) logVerbose(styleText("dim", `Detected ${styleText("white", name)} v${styleText("white", version)}`));
-	}
-	return pkg;
-};
-const hasCatalogReferences = (pkg) => {
-	return [
-		...Object.entries(pkg.dependencies ?? {}),
-		...Object.entries(pkg.devDependencies ?? {}),
-		...Object.entries(pkg.peerDependencies ?? {})
-	].some(([, value]) => isString(value) && value.startsWith("catalog:"));
-};
-const loadPnpmWorkspaceCatalog = async (workspace) => {
-	const filePath = await findUp("pnpm-workspace.yaml", { cwd: workspace });
-	if (!filePath) return void 0;
-	try {
-		const file = await fs.readFile(filePath, "utf8");
-		const data = yaml.load(file);
-		if (!data?.catalog && !data?.catalogs) return void 0;
-		return {
-			catalog: data.catalog,
-			catalogs: data.catalogs
-		};
-	} catch {
-		return;
-	}
-};
-const loadPackageJsonCatalog = async (workspace) => {
-	const filePaths = await findUpMultiple("package.json", { cwd: workspace });
-	for (const filePath of filePaths) try {
-		const pkg = await fs.readJson(filePath);
-		if (pkg.catalog || pkg.catalogs) return {
-			catalog: pkg.catalog,
-			catalogs: pkg.catalogs
-		};
-	} catch {}
-};
-const loadYarnrcCatalog = async (workspace) => {
-	const filePath = await findUp(".yarnrc.yml", { cwd: workspace });
-	if (!filePath) return void 0;
-	try {
-		const file = await fs.readFile(filePath, "utf8");
-		const data = yaml.load(file);
-		if (!data?.catalog && !data?.catalogs) return void 0;
-		return {
-			catalog: data.catalog,
-			catalogs: data.catalogs
-		};
-	} catch {
-		return;
-	}
-};
-const maybeReplaceCatalog = async (pkg, workspace) => {
-	if (!hasCatalogReferences(pkg)) return pkg;
-	const catalogData = await loadPnpmWorkspaceCatalog(workspace) ?? await loadPackageJsonCatalog(workspace) ?? await loadYarnrcCatalog(workspace);
-	if (!catalogData) {
-		logWarning("⚠️  package.json contains catalog: references, but no catalog source was found (checked: pnpm-workspace.yaml, package.json, .yarnrc.yml).");
-		return pkg;
-	}
-	performSubstitution(pkg.dependencies, catalogData);
-	performSubstitution(pkg.devDependencies, catalogData);
-	performSubstitution(pkg.peerDependencies, catalogData);
-	return pkg;
-};
-const performSubstitution = (dependencies, catalogData) => {
-	if (!dependencies) return;
-	for (const [packageName, version] of Object.entries(dependencies)) if (version === "catalog:" || version === "catalog:default") {
-		if (!catalogData.catalog) {
-			logWarning(`⚠️  catalog: substitution for the package '${packageName}' failed as there is no default catalog.`);
-			continue;
-		}
-		const sub = catalogData.catalog[packageName];
-		if (!sub) {
-			logWarning(`⚠️  catalog: substitution for the package '${packageName}' failed as there is no matching package in the default catalog.`);
-			continue;
-		}
-		dependencies[packageName] = sub;
-	} else if (version.startsWith("catalog:")) {
-		const catalogName = version.slice(8);
-		const catalog = catalogData.catalogs?.[catalogName];
-		if (!catalog) {
-			logWarning(`⚠️  '${version}' substitution for the package '${packageName}' failed as there is no matching catalog named '${catalogName}'. (available named catalogs are: ${Object.keys(catalogData.catalogs ?? {}).join(", ")})`);
-			continue;
-		}
-		const sub = catalog[packageName];
-		if (!sub) {
-			logWarning(`⚠️  '${version}' substitution for the package '${packageName}' failed as there is no package in the catalog named '${catalogName}'. (packages in the catalog are: ${Object.keys(catalog).join(", ")})`);
-			continue;
-		}
-		dependencies[packageName] = sub;
-	}
-};
-//#endregion
-//#region src/utils/tsconfig.ts
-const convertTarget = (config) => {
-	if (!config.compilerOptions?.target) return {
-		baseUrl: config.compilerOptions?.baseUrl,
-		...config
-	};
-	const lowercaseTarget = config.compilerOptions.target.toLowerCase();
-	return {
-		baseUrl: config.compilerOptions.baseUrl,
-		...config,
-		compilerOptions: {
-			...config.compilerOptions,
-			target: lowercaseTarget
-		}
-	};
-};
-const loadTsconfig = async (tsconfig, workspace = process.cwd()) => {
-	if (isNullish(tsconfig)) {
-		const configPath = await findUp(["tsconfig.json", "jsconfig.json"], { cwd: workspace });
-		if (configPath) return convertTarget(parseTsconfig(configPath));
-		return;
-	}
-	if (isString(tsconfig)) {
-		const normalizedPath = normalizePath(tsconfig, workspace);
-		if (fs.existsSync(normalizedPath)) return convertTarget(parseTsconfig(normalizedPath));
-		return;
-	}
-	if (isObject(tsconfig)) return tsconfig;
-};
-//#endregion
-//#region src/utils/options.ts
-const INPUT_TARGET_FETCH_TIMEOUT_MS = 1e4;
-/**
-* Type helper to make it easier to use orval.config.ts
-* accepts a direct {@link ConfigExternal} object.
-*/
-function defineConfig(options) {
-	return options;
-}
-/**
-* Type helper to make it easier to write input transformers.
-* accepts a direct {@link InputTransformerFn} function.
-*/
-function defineTransformer(transformer) {
-	return transformer;
-}
-function createFormData(workspace, formData) {
-	const defaultArrayHandling = FormDataArrayHandling.SERIALIZE;
-	if (formData === void 0) return {
-		disabled: false,
-		arrayHandling: defaultArrayHandling
-	};
-	if (isBoolean(formData)) return {
-		disabled: !formData,
-		arrayHandling: defaultArrayHandling
-	};
-	if (isString(formData)) return {
-		disabled: false,
-		mutator: normalizeMutator(workspace, formData),
-		arrayHandling: defaultArrayHandling
-	};
-	if ("mutator" in formData || "arrayHandling" in formData) return {
-		disabled: false,
-		mutator: normalizeMutator(workspace, formData.mutator),
-		arrayHandling: formData.arrayHandling ?? defaultArrayHandling
-	};
-	return {
-		disabled: false,
-		mutator: normalizeMutator(workspace, formData),
-		arrayHandling: defaultArrayHandling
-	};
-}
-function normalizeSchemasOption(schemas, workspace) {
-	if (!schemas) return;
-	if (isString(schemas)) return normalizePath(schemas, workspace);
-	validatePackageSpecifier(schemas.importPath, "schemas.importPath");
-	return {
-		path: normalizePath(schemas.path, workspace),
-		type: schemas.type ?? "typescript",
-		importPath: schemas.importPath,
-		splitByTags: schemas.splitByTags ?? false
-	};
-}
-/**
-* Validates that a config value is a valid package specifier (bare specifier
-* or sub-path import like `@acme/models` / `@acme/models/fakers`). Rejects
-* empty, whitespace-only, relative (`./`, `../`), and absolute paths with a
-* clear, actionable error message. No-op when the value is `undefined`.
-*/
-function validatePackageSpecifier(value, fieldName) {
-	if (value === void 0) return;
-	if (!value) throw new Error(`\`${fieldName}\` must be a non-empty package specifier (e.g. '@acme/models'). Received an empty string.`);
-	if (value.trim() === "") throw new Error(`\`${fieldName}\` must be a non-empty package specifier (e.g. '@acme/models'). Received a whitespace-only string.`);
-	if (value.trim() !== value) throw new Error(`\`${fieldName}\` must be a non-empty package specifier (e.g. '@acme/models'). Received a value with leading or trailing whitespace: "${value}"`);
-	if (value.startsWith(".")) throw new Error(`\`${fieldName}\` must be a package specifier (e.g. '@acme/models'), not a relative path. Received: "${value}"`);
-	if (path.isAbsolute(value) || /^[A-Za-z]:[\\/]/.test(value) || value.startsWith("\\\\")) throw new Error(`\`${fieldName}\` must be a package specifier (e.g. '@acme/models'), not an absolute path. Received: "${value}"`);
-}
-function looksLikePackageSpecifier(value) {
-	return !!value && value.trim() === value && !value.startsWith(".") && !path.isAbsolute(value) && !/^[A-Za-z]:[\\/]/.test(value) && !value.startsWith("\\\\");
-}
-function resolvePackageSpecifier(workspace, value) {
-	try {
-		return createRequire(path.join(workspace, "package.json")).resolve(value);
-	} catch {
-		return;
-	}
-}
-function isPackageSpecifierCandidate(workspace, value) {
-	if (!looksLikePackageSpecifier(value)) return false;
-	if (existsSync(path.resolve(workspace, value))) return false;
-	if (value.startsWith("@")) return true;
-	const [packageName] = value.split("/");
-	if (!value.includes("/")) return true;
-	for (let dir = workspace;;) {
-		if (existsSync(path.join(dir, "node_modules", packageName))) return true;
-		const parent = path.dirname(dir);
-		if (parent === dir) return false;
-		dir = parent;
+function isPackageSpecifierCandidate(workspace, value) {
+	if (!looksLikePackageSpecifier(value)) return false;
+	if (existsSync(path.resolve(workspace, value))) return false;
+	if (value.startsWith("@")) return true;
+	const [packageName] = value.split("/");
+	if (!value.includes("/")) return true;
+	for (let dir = workspace;;) {
+		if (existsSync(path.join(dir, "node_modules", packageName))) return true;
+		const parent = path.dirname(dir);
+		if (parent === dir) return false;
+		dir = parent;
 	}
 }
 function normalizeEffectOptions(effect) {
@@ -1222,215 +874,678 @@ async function resolveFirstValidTarget(targets, workspace, parserOptions) {
 					method: "HEAD",
 					headers
 				});
-				if (headResponse.ok) return target;
-				if (headResponse.status === 405 || headResponse.status === 501) {
-					if ((await fetchWithTimeout(target, {
-						method: "GET",
-						headers
-					})).ok) return target;
-				}
-			} catch {
-				continue;
+				if (headResponse.ok) return target;
+				if (headResponse.status === 405 || headResponse.status === 501) {
+					if ((await fetchWithTimeout(target, {
+						method: "GET",
+						headers
+					})).ok) return target;
+				}
+			} catch {
+				continue;
+			}
+			continue;
+		}
+		const resolvedTarget = normalizePath(target, workspace);
+		try {
+			await access(resolvedTarget);
+			return resolvedTarget;
+		} catch {
+			continue;
+		}
+	}
+	throw new Error(styleText("red", `None of the input targets could be resolved:\n${targets.map((target) => `  - ${target}`).join("\n")}`));
+}
+function getHeadersForUrl(url, headersConfig) {
+	if (!headersConfig) return {};
+	const { hostname } = new URL(url);
+	const matchedHeaders = {};
+	for (const headerEntry of headersConfig) if (headerEntry.domains.some((domain) => hostname === domain || hostname.endsWith(`.${domain}`))) Object.assign(matchedHeaders, headerEntry.headers);
+	return matchedHeaders;
+}
+async function fetchWithTimeout(target, init) {
+	const controller = new AbortController();
+	const timeoutId = setTimeout(() => {
+		controller.abort();
+	}, INPUT_TARGET_FETCH_TIMEOUT_MS);
+	try {
+		return await fetch(target, {
+			...init,
+			signal: controller.signal
+		});
+	} finally {
+		clearTimeout(timeoutId);
+	}
+}
+function normalizePathOrUrl(path, workspace) {
+	if (isString(path) && !isUrl(path)) return normalizePath(path, workspace);
+	return path;
+}
+function normalizePath(path$1, workspace) {
+	if (!isString(path$1)) return path$1;
+	return path.resolve(workspace, path$1);
+}
+function normalizeOperationsAndTags(operationsOrTags, workspace, global, source) {
+	const unsupportedZodKeys = [
+		"version",
+		"variant",
+		"dateTimeOptions",
+		"timeOptions",
+		"generateEachHttpStatus",
+		"generateReusableSchemas",
+		"generateMeta",
+		"generateDiscriminatedUnion"
+	];
+	return Object.fromEntries(Object.entries(operationsOrTags).map(([key, { transformer, mutator, formData, formUrlEncoded, paramsSerializer, paramsFilter, query, angular, zod, effect, ...rest }]) => {
+		const unsupportedOperationZodKeys = zod && unsupportedZodKeys.filter((unsupportedKey) => zod[unsupportedKey] !== void 0);
+		if (unsupportedOperationZodKeys && unsupportedOperationZodKeys.length) logWarning(`⚠️  override.${source}.${key}.zod only supports strict, generate, coerce, preprocess, params, and useBrandedTypes. Ignoring unsupported ${unsupportedOperationZodKeys.length === 1 ? "field" : "fields"}: ${unsupportedOperationZodKeys.map((unsupportedKey) => `zod.${unsupportedKey}`).join(", ")}.`);
+		const hasSupportedOperationZodConfig = !!zod && (zod.strict !== void 0 || zod.generate !== void 0 || zod.coerce !== void 0 || zod.preprocess !== void 0 || zod.params !== void 0 || zod.useBrandedTypes !== void 0);
+		return [key, {
+			...rest,
+			...angular ? { angular: {
+				provideIn: angular.provideIn ?? "root",
+				client: angular.retrievalClient ?? angular.client ?? "httpClient",
+				runtimeValidation: angular.runtimeValidation ?? false,
+				queryObjectSerialization: angular.queryObjectSerialization ?? "spec",
+				...angular.httpResource ? { httpResource: angular.httpResource } : {}
+			} } : {},
+			...query ? { query: normalizeQueryOptions(query, workspace, global.query) } : {},
+			...hasSupportedOperationZodConfig && zod ? { zod: {
+				strict: {
+					param: zod.strict?.param ?? false,
+					query: zod.strict?.query ?? false,
+					header: zod.strict?.header ?? false,
+					body: zod.strict?.body ?? false,
+					response: zod.strict?.response ?? false
+				},
+				generate: {
+					param: zod.generate?.param ?? true,
+					query: zod.generate?.query ?? true,
+					header: zod.generate?.header ?? true,
+					body: zod.generate?.body ?? true,
+					response: zod.generate?.response ?? true
+				},
+				coerce: {
+					param: zod.coerce?.param ?? false,
+					query: zod.coerce?.query ?? false,
+					header: zod.coerce?.header ?? false,
+					body: zod.coerce?.body ?? false,
+					response: zod.coerce?.response ?? false
+				},
+				preprocess: {
+					...zod.preprocess?.param ? { param: normalizeMutator(workspace, zod.preprocess.param) } : {},
+					...zod.preprocess?.query ? { query: normalizeMutator(workspace, zod.preprocess.query) } : {},
+					...zod.preprocess?.header ? { header: normalizeMutator(workspace, zod.preprocess.header) } : {},
+					...zod.preprocess?.body ? { body: normalizeMutator(workspace, zod.preprocess.body) } : {},
+					...zod.preprocess?.response ? { response: normalizeMutator(workspace, zod.preprocess.response) } : {}
+				},
+				...zod.params ? { params: normalizeMutator(workspace, zod.params) } : {},
+				useBrandedTypes: zod.useBrandedTypes ?? false
+			} } : {},
+			...effect ? { effect: normalizeEffectOptions(effect) } : {},
+			...transformer ? { transformer: normalizePath(transformer, workspace) } : {},
+			...mutator ? { mutator: normalizeMutator(workspace, mutator) } : {},
+			...formData === void 0 ? {} : { formData: createFormData(workspace, formData) },
+			...formUrlEncoded ? { formUrlEncoded: isBoolean(formUrlEncoded) ? formUrlEncoded : normalizeMutator(workspace, formUrlEncoded) } : {},
+			...paramsSerializer ? { paramsSerializer: normalizeMutator(workspace, paramsSerializer) } : {},
+			...paramsFilter ? { paramsFilter: normalizeMutator(workspace, paramsFilter) } : {}
+		}];
+	}));
+}
+function normalizeOutputMode(mode) {
+	if (!mode) return OutputMode.SINGLE;
+	if (!Object.values(OutputMode).includes(mode)) {
+		logWarning(`⚠️  Unknown provided mode => ${mode}`);
+		return OutputMode.SINGLE;
+	}
+	return mode;
+}
+function normalizeHooks(hooks) {
+	const keys = Object.keys(hooks);
+	const result = {};
+	for (const key of keys) if (isString(hooks[key])) result[key] = [hooks[key]];
+	else if (Array.isArray(hooks[key])) result[key] = hooks[key];
+	else if (isFunction(hooks[key])) result[key] = [hooks[key]];
+	else if (isObject(hooks[key])) result[key] = [hooks[key]];
+	return result;
+}
+function normalizeHonoOptions(hono = {}, workspace) {
+	return {
+		...hono.handlers ? { handlers: path.resolve(workspace, hono.handlers) } : {},
+		handlerGenerationStrategy: hono.handlerGenerationStrategy ?? "smart",
+		compositeRoute: hono.compositeRoute ? path.resolve(workspace, hono.compositeRoute) : "",
+		validator: hono.validator ?? true,
+		validatorOutputPath: hono.validatorOutputPath ? path.resolve(workspace, hono.validatorOutputPath) : ""
+	};
+}
+function normalizeMcpServerOptions(server, workspace) {
+	return {
+		path: path.resolve(workspace, server.path),
+		name: server.name,
+		default: server.default ?? !server.name
+	};
+}
+function normalizeMcpOptions(mcp = {}, workspace) {
+	return mcp.server ? { server: normalizeMcpServerOptions(mcp.server, workspace) } : {};
+}
+function normalizeJSDocOptions(jsdoc = {}) {
+	return { ...jsdoc };
+}
+function normalizeQueryOptions(queryOptions = {}, outputWorkspace, globalOptions = {}) {
+	if (queryOptions.options) logWarning("⚠️  Using query options is deprecated and will be removed in a future major release. Please use queryOptions or mutationOptions instead.");
+	return {
+		...isNullish(queryOptions.usePrefetch) ? {} : { usePrefetch: queryOptions.usePrefetch },
+		...isNullish(queryOptions.useInvalidate) ? {} : { useInvalidate: queryOptions.useInvalidate },
+		...isNullish(queryOptions.useSetQueryData) ? {} : { useSetQueryData: queryOptions.useSetQueryData },
+		...isNullish(queryOptions.useGetQueryData) ? {} : { useGetQueryData: queryOptions.useGetQueryData },
+		...isNullish(queryOptions.useQuery) ? {} : { useQuery: queryOptions.useQuery },
+		...isNullish(queryOptions.useSuspenseQuery) ? {} : { useSuspenseQuery: queryOptions.useSuspenseQuery },
+		...isNullish(queryOptions.useMutation) ? {} : { useMutation: queryOptions.useMutation },
+		...isNullish(queryOptions.useInfinite) ? {} : { useInfinite: queryOptions.useInfinite },
+		...isNullish(queryOptions.useSuspenseInfiniteQuery) ? {} : { useSuspenseInfiniteQuery: queryOptions.useSuspenseInfiniteQuery },
+		...queryOptions.useInfiniteQueryParam ? { useInfiniteQueryParam: queryOptions.useInfiniteQueryParam } : {},
+		...queryOptions.options ? { options: queryOptions.options } : {},
+		...globalOptions.queryKey ? { queryKey: globalOptions.queryKey } : {},
+		...queryOptions.queryKey ? { queryKey: normalizeMutator(outputWorkspace, queryOptions.queryKey) } : {},
+		...globalOptions.queryOptions ? { queryOptions: globalOptions.queryOptions } : {},
+		...queryOptions.queryOptions ? { queryOptions: normalizeMutator(outputWorkspace, queryOptions.queryOptions) } : {},
+		...globalOptions.mutationOptions ? { mutationOptions: globalOptions.mutationOptions } : {},
+		...queryOptions.mutationOptions ? { mutationOptions: normalizeMutator(outputWorkspace, queryOptions.mutationOptions) } : {},
+		...isNullish(globalOptions.shouldExportQueryKey) ? {} : { shouldExportQueryKey: globalOptions.shouldExportQueryKey },
+		...isNullish(queryOptions.shouldExportQueryKey) ? {} : { shouldExportQueryKey: queryOptions.shouldExportQueryKey },
+		...isNullish(globalOptions.shouldFilterQueryKey) ? {} : { shouldFilterQueryKey: globalOptions.shouldFilterQueryKey },
+		...isNullish(queryOptions.shouldFilterQueryKey) ? {} : { shouldFilterQueryKey: queryOptions.shouldFilterQueryKey },
+		...isNullish(globalOptions.queryKeyFilter) ? {} : { queryKeyFilter: globalOptions.queryKeyFilter },
+		...isNullish(queryOptions.queryKeyFilter) ? {} : { queryKeyFilter: queryOptions.queryKeyFilter },
+		...isNullish(globalOptions.shouldExportHttpClient) ? {} : { shouldExportHttpClient: globalOptions.shouldExportHttpClient },
+		...isNullish(queryOptions.shouldExportHttpClient) ? {} : { shouldExportHttpClient: queryOptions.shouldExportHttpClient },
+		...isNullish(globalOptions.shouldExportMutatorHooks) ? {} : { shouldExportMutatorHooks: globalOptions.shouldExportMutatorHooks },
+		...isNullish(queryOptions.shouldExportMutatorHooks) ? {} : { shouldExportMutatorHooks: queryOptions.shouldExportMutatorHooks },
+		...isNullish(globalOptions.shouldSplitQueryKey) ? {} : { shouldSplitQueryKey: globalOptions.shouldSplitQueryKey },
+		...isNullish(queryOptions.shouldSplitQueryKey) ? {} : { shouldSplitQueryKey: queryOptions.shouldSplitQueryKey },
+		...isNullish(globalOptions.signal) ? {} : { signal: globalOptions.signal },
+		...isNullish(globalOptions.useOperationIdAsQueryKey) ? {} : { useOperationIdAsQueryKey: globalOptions.useOperationIdAsQueryKey },
+		...isNullish(queryOptions.useOperationIdAsQueryKey) ? {} : { useOperationIdAsQueryKey: queryOptions.useOperationIdAsQueryKey },
+		...isNullish(globalOptions.signal) ? {} : { signal: globalOptions.signal },
+		...isNullish(queryOptions.signal) ? {} : { signal: queryOptions.signal },
+		...isNullish(globalOptions.version) ? {} : { version: globalOptions.version },
+		...isNullish(queryOptions.version) ? {} : { version: queryOptions.version },
+		...queryOptions.mutationInvalidates ? { mutationInvalidates: queryOptions.mutationInvalidates } : {},
+		...isNullish(globalOptions.runtimeValidation) ? {} : { runtimeValidation: globalOptions.runtimeValidation },
+		...isNullish(queryOptions.runtimeValidation) ? {} : { runtimeValidation: queryOptions.runtimeValidation }
+	};
+}
+function getDefaultFilesHeader({ title, description, version: version$1 } = {}) {
+	return [
+		`Generated by ${name} v${version} 🍺`,
+		`Do not edit manually.`,
+		...title ? [title] : [],
+		...description ? [description] : [],
+		...version$1 ? [`OpenAPI spec version: ${version$1}`] : []
+	];
+}
+//#endregion
+//#region src/import-specs.ts
+async function resolveSpec(input, { parserOptions, transformer, workspace, unsafeDisableValidation = false }) {
+	const allowedRefs = parserOptions?.externalRefs?.allow ?? [];
+	const isWildcard = allowedRefs.includes("*");
+	const { data: specData, origin } = await loadSpec(input, parserOptions?.headers);
+	if (!isWildcard) {
+		const disallowed = collectExternalRefs(specData).filter((ref) => !isAllowedRef(ref, allowedRefs, origin));
+		if (disallowed.length > 0) throw new Error(formatDisallowedRefsError(disallowed, allowedRefs));
+	} else {
+		const docs = [...new Set(collectExternalRefs(specData).map(getRefDocument))];
+		if (docs.length > 0) logWarning(`External $ref documents being resolved:\n` + docs.map((d) => `  - ${d}`).join("\n"));
+	}
+	const dereferencedData = await bundleAndDereferenceExternalRefs(specData, parserOptions, origin, isWildcard, allowedRefs);
+	let transformedData = dereferencedData;
+	if (transformer) {
+		const applied = await applyInputTransformer(dereferencedData, transformer, workspace);
+		transformedData = collectExternalRefs(applied).length > 0 ? await bundleAndDereferenceExternalRefs(applied, parserOptions, origin, isWildcard, allowedRefs) : applied;
+	}
+	if (unsafeDisableValidation) logWarning("🚨 OpenAPI spec validation is disabled.\n  Code generation with invalid specs is not guaranteed to work and may break in minor updates.\n  Bug reports with validation disabled will not be accepted.");
+	else {
+		validateComponentKeys(transformedData);
+		const { valid, errors } = await validate(transformedData);
+		if (!valid) throw new Error(`OpenAPI spec validation failed:\n${JSON.stringify(errors, void 0, 2)}`);
+	}
+	const { specification } = upgrade(transformedData);
+	return specification;
+}
+async function applyInputTransformer(data, transformer, workspace) {
+	const transformerFn = await dynamicImport(transformer, workspace);
+	const result = await transformerFn(data);
+	if (!isObject(result)) {
+		const source = isString(transformer) ? transformer : transformerFn.name || "<inline function>";
+		throw new Error(`input.override.transformer must return an OpenAPI document object; got ${result === void 0 ? "undefined" : typeof result} from ${source}. Ensure your transformer returns the (possibly modified) spec.`);
+	}
+	return result;
+}
+/**
+* Bundle external references into the document and then resolve the `x-ext`
+* entries that `@scalar/json-magic` produces. Shared by the initial pass and
+* the post-transformer pass (#3327); `origin` lets the second pass resolve refs
+* relative to the original spec file when the input is an in-memory object.
+*/
+async function bundleAndDereferenceExternalRefs(input, parserOptions, origin, isWildcard = false, allowedExternalRefs = []) {
+	return dereferenceExternalRef(await bundle(input, {
+		plugins: [
+			createSafeFileLoader(origin, isWildcard, allowedExternalRefs),
+			createSafeUrlLoader(origin, isWildcard, allowedExternalRefs, parserOptions?.headers),
+			parseJson(),
+			parseYaml()
+		],
+		treeShake: false,
+		...origin ? { origin } : {}
+	}));
+}
+/**
+* Load the top-level spec into an inline object so we can scan it for external
+* `$ref`s before `bundle()` resolves them. The top-level target is trusted
+* (user-configured `input.target`); only `$ref` values inside the spec are
+* untrusted.
+*/
+function parseSpec(text) {
+	const result = jsYaml.load(text);
+	if (!isObject(result)) throw new Error("OpenAPI spec must be a valid JSON/YAML object.");
+	return result;
+}
+async function loadSpec(input, headers) {
+	if (!isString(input)) return { data: input };
+	if (isUrl(input)) {
+		const response = await fetch(input, { headers: getHeadersForUrl(input, headers) });
+		if (!response.ok) throw new Error(`Failed to fetch OpenAPI spec from ${input}: ${response.status} ${response.statusText}`);
+		return {
+			data: parseSpec(await response.text()),
+			origin: input
+		};
+	}
+	return {
+		data: parseSpec(await readFile(input, "utf-8")),
+		origin: input
+	};
+}
+/**
+* Strip the JSON pointer fragment (`#/...`) from a `$ref` value, leaving only
+* the document target (file path or URL).
+*/
+function getRefDocument(ref) {
+	const hashIndex = ref.indexOf("#");
+	return hashIndex === -1 ? ref : ref.slice(0, hashIndex);
+}
+/**
+* Collect all external `$ref` document targets from a spec object. Returns
+* deduplicated ref strings in their raw form (before fragment stripping).
+*/
+function collectExternalRefs(obj) {
+	const refs = /* @__PURE__ */ new Set();
+	function walk(val) {
+		if (Array.isArray(val)) {
+			val.forEach(walk);
+			return;
+		}
+		if (isObject(val)) {
+			if ("$ref" in val && isString(val.$ref) && !val.$ref.startsWith("#")) refs.add(val.$ref);
+			Object.values(val).forEach(walk);
+		}
+	}
+	walk(obj);
+	return [...refs];
+}
+/**
+* Resolve a ref document target (the part before `#`) to a canonical path or
+* URL, so it can be compared against allow-list entries that were resolved the
+* same way.
+*/
+function resolveRefTarget(ref, origin) {
+	const doc = getRefDocument(ref);
+	if (isUrl(doc)) return new URL(doc).href;
+	if (origin && isUrl(origin)) return new URL(doc, origin).href;
+	if (origin) return path.resolve(path.dirname(origin), doc);
+	return path.resolve(doc);
+}
+/**
+* Check whether a `$ref` is allowed by the user's allow-list. Both the ref and
+* the allow-list entries are resolved against the spec origin so that
+* `./schemas/pet.yaml` in the spec matches `./schemas/pet.yaml` in the config.
+*/
+function isAllowedRef(ref, allowedExternalRefs, origin) {
+	const resolved = resolveRefTarget(ref, origin);
+	return allowedExternalRefs.some((entry) => resolveRefTarget(entry, origin) === resolved);
+}
+function formatDisallowedRefsError(disallowed, currentAllowed) {
+	const docs = [...new Set(disallowed.map(getRefDocument))];
+	const all = [...new Set([...currentAllowed, ...docs])];
+	const configSnippet = JSON.stringify({ input: { parserOptions: { externalRefs: { allow: all } } } }, null, 2);
+	return `External \$ref targets are not allowed by default.
+Add them to your config, or use externalRefs.allow: ['*'] to allow all.
+
+Disallowed refs:\n${disallowed.map((r) => `  - ${r}`).join("\n")}\n\nSuggested config:\n${configSnippet}`;
+}
+/**
+* Wrap `readFiles()` so every file read is checked against the allow-list.
+* The top-level spec file (matching `origin`) is always allowed; subsequent
+* reads must match an explicit entry or the wildcard.
+*/
+function createSafeFileLoader(origin, isWildcard, allowedExternalRefs) {
+	const base = readFiles();
+	return {
+		type: "loader",
+		validate: base.validate,
+		async exec(value) {
+			if (isWildcard) return base.exec(value);
+			if (origin && path.resolve(value) === path.resolve(origin)) return base.exec(value);
+			if (!isAllowedRef(value, allowedExternalRefs, origin)) throw new Error(`Refused to read external file: ${value}\nAdd it to externalRefs.allow or use ['*'] to allow all.`);
+			return base.exec(value);
+		}
+	};
+}
+/**
+* Wrap `fetchUrls()` so every URL fetch is checked against the allow-list.
+* The top-level spec URL (matching `origin`) is always allowed; subsequent
+* fetches must match an explicit entry or the wildcard.
+*/
+function createSafeUrlLoader(origin, isWildcard, allowedExternalRefs, headers) {
+	const base = fetchUrls({ headers });
+	return {
+		type: "loader",
+		validate: base.validate,
+		async exec(value) {
+			if (isWildcard) return base.exec(value);
+			const resolved = resolveRefTarget(value, origin);
+			if (origin && resolved === resolveRefTarget(origin)) return base.exec(value);
+			if (!isAllowedRef(value, allowedExternalRefs, origin)) throw new Error(`Refused to fetch external URL: ${value}\nAdd it to externalRefs.allow or use ['*'] to allow all.`);
+			return base.exec(value);
+		}
+	};
+}
+async function importSpecs(workspace, options, projectName) {
+	const { input, output } = options;
+	return importOpenApi({
+		spec: await resolveSpec(input.target, {
+			parserOptions: input.parserOptions,
+			transformer: input.override.transformer,
+			workspace,
+			unsafeDisableValidation: input.unsafeDisableValidation
+		}),
+		input,
+		output,
+		target: isString(input.target) ? input.target : workspace,
+		workspace,
+		projectName
+	});
+}
+const COMPONENT_KEY_PATTERN = /^[a-zA-Z0-9.\-_]+$/;
+const COMPONENT_SECTIONS = [
+	"schemas",
+	"responses",
+	"parameters",
+	"examples",
+	"requestBodies",
+	"headers",
+	"securitySchemes",
+	"links",
+	"callbacks",
+	"pathItems"
+];
+/**
+* Validate that all component keys conform to the OAS regex: ^[a-zA-Z0-9.\-_]+$
+* @see https://spec.openapis.org/oas/v3.0.3.html#fixed-fields-5
+* @see https://spec.openapis.org/oas/v3.1.0#fixed-fields-5
+*/
+function validateComponentKeys(data) {
+	const components = data.components;
+	if (!isObject(components)) return;
+	const invalidKeys = [];
+	for (const section of COMPONENT_SECTIONS) {
+		const sectionObj = components[section];
+		if (!isObject(sectionObj)) continue;
+		for (const key of Object.keys(sectionObj)) if (!COMPONENT_KEY_PATTERN.test(key)) invalidKeys.push(`components.${section}.${key}`);
+	}
+	if (invalidKeys.length > 0) throw new Error(`Invalid component key${invalidKeys.length > 1 ? "s" : ""} found. OpenAPI component keys must match the pattern ${COMPONENT_KEY_PATTERN} (non-ASCII characters are not allowed per the spec).\n  See: https://spec.openapis.org/oas/v3.0.3.html#components-object\n  Invalid keys:\n` + invalidKeys.map((k) => `    - ${k}`).join("\n"));
+}
+/**
+* The plugins from `@scalar/json-magic` does not dereference $ref.
+* Instead it fetches them and puts them under x-ext, and changes the $ref to point to #x-ext/<name>.
+* This function:
+* 1. Merges external schemas into main spec's components.schemas (with collision handling)
+* 2. Replaces x-ext refs with standard component refs or inlined content
+*/
+function dereferenceExternalRef(data) {
+	const extensions = data["x-ext"] ?? {};
+	const schemaNameMappings = mergeExternalSchemas(data, extensions);
+	const result = {};
+	for (const [key, value] of Object.entries(data)) if (key !== "x-ext") result[key] = replaceXExtRefs(value, extensions, schemaNameMappings);
+	return result;
+}
+/**
+* Merge external document schemas into main spec's components.schemas
+* Returns mapping of original schema names to final names (with suffixes for collisions)
+*/
+function mergeExternalSchemas(data, extensions) {
+	const schemaNameMappings = {};
+	if (Object.keys(extensions).length === 0) return schemaNameMappings;
+	data.components ??= {};
+	const mainComponents = data.components;
+	mainComponents.schemas ??= {};
+	const mainSchemas = mainComponents.schemas;
+	for (const [extKey, extDoc] of Object.entries(extensions)) {
+		schemaNameMappings[extKey] = {};
+		if (isObject(extDoc) && "components" in extDoc) {
+			const extComponents = extDoc.components;
+			if (isObject(extComponents) && "schemas" in extComponents) {
+				const extSchemas = extComponents.schemas;
+				for (const [schemaName, schema] of Object.entries(extSchemas)) {
+					const existingSchema = mainSchemas[schemaName];
+					const isXExtRef = isObject(existingSchema) && "$ref" in existingSchema && isString(existingSchema.$ref) && existingSchema.$ref.startsWith("#/x-ext/");
+					let finalSchemaName = schemaName;
+					if (schemaName in mainSchemas && !isXExtRef) {
+						finalSchemaName = `${schemaName}_${extKey.replaceAll(/[^a-zA-Z0-9]/g, "_")}`;
+						schemaNameMappings[extKey][schemaName] = finalSchemaName;
+					} else schemaNameMappings[extKey][schemaName] = schemaName;
+					mainSchemas[finalSchemaName] = scrubUnwantedKeys(schema);
+				}
+			}
+		}
+	}
+	for (const [extKey, mapping] of Object.entries(schemaNameMappings)) for (const [, finalName] of Object.entries(mapping)) {
+		const schema = mainSchemas[finalName];
+		if (schema) mainSchemas[finalName] = updateInternalRefs(schema, extKey, schemaNameMappings);
+	}
+	return schemaNameMappings;
+}
+/**
+* Remove unwanted keys like $schema and $id from objects
+*/
+function scrubUnwantedKeys(obj) {
+	const UNWANTED_KEYS = new Set(["$schema", "$id"]);
+	if (obj === null || obj === void 0) return obj;
+	if (Array.isArray(obj)) return obj.map((x) => scrubUnwantedKeys(x));
+	if (isObject(obj)) {
+		const rec = obj;
+		const out = {};
+		for (const [k, v] of Object.entries(rec)) {
+			if (UNWANTED_KEYS.has(k)) continue;
+			out[k] = scrubUnwantedKeys(v);
+		}
+		return out;
+	}
+	return obj;
+}
+/**
+* Update internal refs within an external schema to use suffixed names
+*/
+function updateInternalRefs(obj, extKey, schemaNameMappings) {
+	if (obj === null || obj === void 0) return obj;
+	if (Array.isArray(obj)) return obj.map((element) => updateInternalRefs(element, extKey, schemaNameMappings));
+	if (isObject(obj)) {
+		const record = obj;
+		if ("$ref" in record && isString(record.$ref)) {
+			const refValue = record.$ref;
+			if (refValue.startsWith("#/components/schemas/")) {
+				const schemaName = refValue.replace("#/components/schemas/", "");
+				const mappedName = schemaNameMappings[extKey][schemaName];
+				if (mappedName) return { $ref: `#/components/schemas/${mappedName}` };
+			}
+		}
+		const result = {};
+		for (const [key, value] of Object.entries(record)) result[key] = updateInternalRefs(value, extKey, schemaNameMappings);
+		return result;
+	}
+	return obj;
+}
+/**
+* Decode a single JSON Pointer reference token taken from an x-ext `$ref`.
+*
+* The token carries two layers of encoding: it sits in a URI fragment, so it
+* may be percent-encoded (e.g. `%7B` for `{` in templated paths), and it is a
+* JSON Pointer token, so `~1`/`~0` stand for `/`/`~` (RFC 6901). Percent-
+* encoding is the outer layer and is removed first; a malformed sequence is
+* left as-is rather than throwing. Without this, tokens such as `~1pets`
+* never match the real `/pets` key and the external `$ref` fails to resolve.
+*/
+function decodeRefToken(token) {
+	let decoded = token;
+	try {
+		decoded = decodeURIComponent(token);
+	} catch {}
+	return decoded.replaceAll("~1", "/").replaceAll("~0", "~");
+}
+/**
+* Replace x-ext refs with standard component refs, or inline the content.
+* `inliningRefs` tracks the inline chain to break cycles in recursive
+* external schemas that aren't under `components.schemas` (#1642).
+*/
+function replaceXExtRefs(obj, extensions, schemaNameMappings, inliningRefs = /* @__PURE__ */ new Set()) {
+	if (isNullish$1(obj)) return obj;
+	if (Array.isArray(obj)) return obj.map((element) => replaceXExtRefs(element, extensions, schemaNameMappings, inliningRefs));
+	if (isObject(obj)) {
+		const record = obj;
+		if ("$ref" in record && isString(record.$ref)) {
+			const refValue = record.$ref;
+			if (refValue.startsWith("#/x-ext/")) {
+				const parts = refValue.replace("#/x-ext/", "").split("/");
+				const extKey = parts.shift();
+				if (extKey) {
+					if (parts.length >= 3 && parts[0] === "components" && parts[1] === "schemas") {
+						const schemaName = parts.slice(2).join("/");
+						return { $ref: `#/components/schemas/${schemaNameMappings[extKey][schemaName] || schemaName}` };
+					}
+					if (inliningRefs.has(refValue)) {
+						logWarning(`Detected a circular external $ref while inlining "${refValue}". Replacing with an empty schema to avoid infinite recursion. Move the schema under "components.schemas" in its source file or pre-bundle the spec to keep the recursion intact.`);
+						return {};
+					}
+					let refObj = extensions[extKey];
+					for (const rawPart of parts) {
+						const p = decodeRefToken(rawPart);
+						if (refObj && (isObject(refObj) || Array.isArray(refObj)) && p in refObj) refObj = refObj[p];
+						else {
+							refObj = void 0;
+							break;
+						}
+					}
+					if (refObj) {
+						const cleaned = scrubUnwantedKeys(refObj);
+						const nextInlining = new Set(inliningRefs);
+						nextInlining.add(refValue);
+						return replaceXExtRefs(cleaned, extensions, schemaNameMappings, nextInlining);
+					}
+				}
+			}
+		}
+		const result = {};
+		for (const [key, value] of Object.entries(record)) result[key] = replaceXExtRefs(value, extensions, schemaNameMappings, inliningRefs);
+		return result;
+	}
+	return obj;
+}
+//#endregion
+//#region src/formatters/prettier.ts
+/**
+* Format files with prettier.
+* Tries the programmatic API first (project dependency),
+* then falls back to the globally installed CLI.
+*/
+async function formatWithPrettier(paths, projectTitle) {
+	const prettier = await tryImportPrettier();
+	if (prettier) {
+		const filePaths = [...new Set(await collectFilePaths(paths))];
+		if (filePaths.length === 0) return;
+		const config = await prettier.resolveConfig(filePaths[0]) ?? {};
+		await Promise.all(filePaths.map(async (filePath) => {
+			try {
+				const content = await fs.readFile(filePath, "utf8");
+				const formatted = await prettier.format(content, {
+					...config,
+					filepath: filePath
+				});
+				await fs.writeFile(filePath, formatted);
+			} catch (error) {
+				if (isMissingFileError(error)) return;
+				if (error instanceof Error) if (error.name === "UndefinedParserError") {} else logWarning(`⚠️  ${projectTitle ? `${projectTitle} - ` : ""}Failed to format file ${filePath}: ${error.toString()}`);
+				else logWarning(`⚠️  ${projectTitle ? `${projectTitle} - ` : ""}Failed to format file ${filePath}: unknown error`);
 			}
-			continue;
-		}
-		const resolvedTarget = normalizePath(target, workspace);
-		try {
-			await access(resolvedTarget);
-			return resolvedTarget;
-		} catch {
-			continue;
-		}
+		}));
+		return;
 	}
-	throw new Error(styleText("red", `None of the input targets could be resolved:\n${targets.map((target) => `  - ${target}`).join("\n")}`));
-}
-function getHeadersForUrl(url, headersConfig) {
-	if (!headersConfig) return {};
-	const { hostname } = new URL(url);
-	const matchedHeaders = {};
-	for (const headerEntry of headersConfig) if (headerEntry.domains.some((domain) => hostname === domain || hostname.endsWith(`.${domain}`))) Object.assign(matchedHeaders, headerEntry.headers);
-	return matchedHeaders;
-}
-async function fetchWithTimeout(target, init) {
-	const controller = new AbortController();
-	const timeoutId = setTimeout(() => {
-		controller.abort();
-	}, INPUT_TARGET_FETCH_TIMEOUT_MS);
 	try {
-		return await fetch(target, {
-			...init,
-			signal: controller.signal
-		});
-	} finally {
-		clearTimeout(timeoutId);
+		await execa("prettier", ["--write", ...paths]);
+	} catch {
+		logWarning(`⚠️  ${projectTitle ? `${projectTitle} - ` : ""}prettier not found. Install it as a project dependency or globally.`);
 	}
 }
-function normalizePathOrUrl(path, workspace) {
-	if (isString(path) && !isUrl(path)) return normalizePath(path, workspace);
-	return path;
-}
-function normalizePath(path$1, workspace) {
-	if (!isString(path$1)) return path$1;
-	return path.resolve(workspace, path$1);
-}
-function normalizeOperationsAndTags(operationsOrTags, workspace, global, source) {
-	const unsupportedZodKeys = [
-		"version",
-		"variant",
-		"dateTimeOptions",
-		"timeOptions",
-		"generateEachHttpStatus",
-		"generateReusableSchemas",
-		"generateMeta",
-		"generateDiscriminatedUnion"
-	];
-	return Object.fromEntries(Object.entries(operationsOrTags).map(([key, { transformer, mutator, formData, formUrlEncoded, paramsSerializer, paramsFilter, query, angular, zod, effect, ...rest }]) => {
-		const unsupportedOperationZodKeys = zod && unsupportedZodKeys.filter((unsupportedKey) => zod[unsupportedKey] !== void 0);
-		if (unsupportedOperationZodKeys && unsupportedOperationZodKeys.length) logWarning(`⚠️  override.${source}.${key}.zod only supports strict, generate, coerce, preprocess, params, and useBrandedTypes. Ignoring unsupported ${unsupportedOperationZodKeys.length === 1 ? "field" : "fields"}: ${unsupportedOperationZodKeys.map((unsupportedKey) => `zod.${unsupportedKey}`).join(", ")}.`);
-		const hasSupportedOperationZodConfig = !!zod && (zod.strict !== void 0 || zod.generate !== void 0 || zod.coerce !== void 0 || zod.preprocess !== void 0 || zod.params !== void 0 || zod.useBrandedTypes !== void 0);
-		return [key, {
-			...rest,
-			...angular ? { angular: {
-				provideIn: angular.provideIn ?? "root",
-				client: angular.retrievalClient ?? angular.client ?? "httpClient",
-				runtimeValidation: angular.runtimeValidation ?? false,
-				queryObjectSerialization: angular.queryObjectSerialization ?? "spec",
-				...angular.httpResource ? { httpResource: angular.httpResource } : {}
-			} } : {},
-			...query ? { query: normalizeQueryOptions(query, workspace, global.query) } : {},
-			...hasSupportedOperationZodConfig && zod ? { zod: {
-				strict: {
-					param: zod.strict?.param ?? false,
-					query: zod.strict?.query ?? false,
-					header: zod.strict?.header ?? false,
-					body: zod.strict?.body ?? false,
-					response: zod.strict?.response ?? false
-				},
-				generate: {
-					param: zod.generate?.param ?? true,
-					query: zod.generate?.query ?? true,
-					header: zod.generate?.header ?? true,
-					body: zod.generate?.body ?? true,
-					response: zod.generate?.response ?? true
-				},
-				coerce: {
-					param: zod.coerce?.param ?? false,
-					query: zod.coerce?.query ?? false,
-					header: zod.coerce?.header ?? false,
-					body: zod.coerce?.body ?? false,
-					response: zod.coerce?.response ?? false
-				},
-				preprocess: {
-					...zod.preprocess?.param ? { param: normalizeMutator(workspace, zod.preprocess.param) } : {},
-					...zod.preprocess?.query ? { query: normalizeMutator(workspace, zod.preprocess.query) } : {},
-					...zod.preprocess?.header ? { header: normalizeMutator(workspace, zod.preprocess.header) } : {},
-					...zod.preprocess?.body ? { body: normalizeMutator(workspace, zod.preprocess.body) } : {},
-					...zod.preprocess?.response ? { response: normalizeMutator(workspace, zod.preprocess.response) } : {}
-				},
-				...zod.params ? { params: normalizeMutator(workspace, zod.params) } : {},
-				useBrandedTypes: zod.useBrandedTypes ?? false
-			} } : {},
-			...effect ? { effect: normalizeEffectOptions(effect) } : {},
-			...transformer ? { transformer: normalizePath(transformer, workspace) } : {},
-			...mutator ? { mutator: normalizeMutator(workspace, mutator) } : {},
-			...formData === void 0 ? {} : { formData: createFormData(workspace, formData) },
-			...formUrlEncoded ? { formUrlEncoded: isBoolean(formUrlEncoded) ? formUrlEncoded : normalizeMutator(workspace, formUrlEncoded) } : {},
-			...paramsSerializer ? { paramsSerializer: normalizeMutator(workspace, paramsSerializer) } : {},
-			...paramsFilter ? { paramsFilter: normalizeMutator(workspace, paramsFilter) } : {}
-		}];
-	}));
+function isMissingFileError(error) {
+	return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
-function normalizeOutputMode(mode) {
-	if (!mode) return OutputMode.SINGLE;
-	if (!Object.values(OutputMode).includes(mode)) {
-		logWarning(`⚠️  Unknown provided mode => ${mode}`);
-		return OutputMode.SINGLE;
+/**
+* Try to import prettier from the project's dependencies.
+* Returns undefined if prettier is not installed.
+*/
+async function tryImportPrettier() {
+	try {
+		return await import("prettier");
+	} catch {
+		return;
 	}
-	return mode;
-}
-function normalizeHooks(hooks) {
-	const keys = Object.keys(hooks);
-	const result = {};
-	for (const key of keys) if (isString(hooks[key])) result[key] = [hooks[key]];
-	else if (Array.isArray(hooks[key])) result[key] = hooks[key];
-	else if (isFunction(hooks[key])) result[key] = [hooks[key]];
-	else if (isObject(hooks[key])) result[key] = [hooks[key]];
-	return result;
-}
-function normalizeHonoOptions(hono = {}, workspace) {
-	return {
-		...hono.handlers ? { handlers: path.resolve(workspace, hono.handlers) } : {},
-		handlerGenerationStrategy: hono.handlerGenerationStrategy ?? "smart",
-		compositeRoute: hono.compositeRoute ? path.resolve(workspace, hono.compositeRoute) : "",
-		validator: hono.validator ?? true,
-		validatorOutputPath: hono.validatorOutputPath ? path.resolve(workspace, hono.validatorOutputPath) : ""
-	};
-}
-function normalizeMcpServerOptions(server, workspace) {
-	return {
-		path: path.resolve(workspace, server.path),
-		name: server.name,
-		default: server.default ?? !server.name
-	};
-}
-function normalizeMcpOptions(mcp = {}, workspace) {
-	return mcp.server ? { server: normalizeMcpServerOptions(mcp.server, workspace) } : {};
 }
-function normalizeJSDocOptions(jsdoc = {}) {
-	return { ...jsdoc };
+/**
+* Recursively collect absolute file paths from a mix of files and directories.
+*/
+async function collectFilePaths(paths) {
+	const results = [];
+	for (const p of paths) {
+		const absolute = path.resolve(p);
+		try {
+			const stat = await fs.stat(absolute);
+			if (stat.isFile()) results.push(absolute);
+			else if (stat.isDirectory()) {
+				const subFiles = await collectFilePaths((await fs.readdir(absolute)).map((entry) => path.join(absolute, entry)));
+				results.push(...subFiles);
+			}
+		} catch {}
+	}
+	return results;
 }
-function normalizeQueryOptions(queryOptions = {}, outputWorkspace, globalOptions = {}) {
-	if (queryOptions.options) logWarning("⚠️  Using query options is deprecated and will be removed in a future major release. Please use queryOptions or mutationOptions instead.");
-	return {
-		...isNullish(queryOptions.usePrefetch) ? {} : { usePrefetch: queryOptions.usePrefetch },
-		...isNullish(queryOptions.useInvalidate) ? {} : { useInvalidate: queryOptions.useInvalidate },
-		...isNullish(queryOptions.useSetQueryData) ? {} : { useSetQueryData: queryOptions.useSetQueryData },
-		...isNullish(queryOptions.useGetQueryData) ? {} : { useGetQueryData: queryOptions.useGetQueryData },
-		...isNullish(queryOptions.useQuery) ? {} : { useQuery: queryOptions.useQuery },
-		...isNullish(queryOptions.useSuspenseQuery) ? {} : { useSuspenseQuery: queryOptions.useSuspenseQuery },
-		...isNullish(queryOptions.useMutation) ? {} : { useMutation: queryOptions.useMutation },
-		...isNullish(queryOptions.useInfinite) ? {} : { useInfinite: queryOptions.useInfinite },
-		...isNullish(queryOptions.useSuspenseInfiniteQuery) ? {} : { useSuspenseInfiniteQuery: queryOptions.useSuspenseInfiniteQuery },
-		...queryOptions.useInfiniteQueryParam ? { useInfiniteQueryParam: queryOptions.useInfiniteQueryParam } : {},
-		...queryOptions.options ? { options: queryOptions.options } : {},
-		...globalOptions.queryKey ? { queryKey: globalOptions.queryKey } : {},
-		...queryOptions.queryKey ? { queryKey: normalizeMutator(outputWorkspace, queryOptions.queryKey) } : {},
-		...globalOptions.queryOptions ? { queryOptions: globalOptions.queryOptions } : {},
-		...queryOptions.queryOptions ? { queryOptions: normalizeMutator(outputWorkspace, queryOptions.queryOptions) } : {},
-		...globalOptions.mutationOptions ? { mutationOptions: globalOptions.mutationOptions } : {},
-		...queryOptions.mutationOptions ? { mutationOptions: normalizeMutator(outputWorkspace, queryOptions.mutationOptions) } : {},
-		...isNullish(globalOptions.shouldExportQueryKey) ? {} : { shouldExportQueryKey: globalOptions.shouldExportQueryKey },
-		...isNullish(queryOptions.shouldExportQueryKey) ? {} : { shouldExportQueryKey: queryOptions.shouldExportQueryKey },
-		...isNullish(globalOptions.shouldFilterQueryKey) ? {} : { shouldFilterQueryKey: globalOptions.shouldFilterQueryKey },
-		...isNullish(queryOptions.shouldFilterQueryKey) ? {} : { shouldFilterQueryKey: queryOptions.shouldFilterQueryKey },
-		...isNullish(globalOptions.queryKeyFilter) ? {} : { queryKeyFilter: globalOptions.queryKeyFilter },
-		...isNullish(queryOptions.queryKeyFilter) ? {} : { queryKeyFilter: queryOptions.queryKeyFilter },
-		...isNullish(globalOptions.shouldExportHttpClient) ? {} : { shouldExportHttpClient: globalOptions.shouldExportHttpClient },
-		...isNullish(queryOptions.shouldExportHttpClient) ? {} : { shouldExportHttpClient: queryOptions.shouldExportHttpClient },
-		...isNullish(globalOptions.shouldExportMutatorHooks) ? {} : { shouldExportMutatorHooks: globalOptions.shouldExportMutatorHooks },
-		...isNullish(queryOptions.shouldExportMutatorHooks) ? {} : { shouldExportMutatorHooks: queryOptions.shouldExportMutatorHooks },
-		...isNullish(globalOptions.shouldSplitQueryKey) ? {} : { shouldSplitQueryKey: globalOptions.shouldSplitQueryKey },
-		...isNullish(queryOptions.shouldSplitQueryKey) ? {} : { shouldSplitQueryKey: queryOptions.shouldSplitQueryKey },
-		...isNullish(globalOptions.signal) ? {} : { signal: globalOptions.signal },
-		...isNullish(globalOptions.useOperationIdAsQueryKey) ? {} : { useOperationIdAsQueryKey: globalOptions.useOperationIdAsQueryKey },
-		...isNullish(queryOptions.useOperationIdAsQueryKey) ? {} : { useOperationIdAsQueryKey: queryOptions.useOperationIdAsQueryKey },
-		...isNullish(globalOptions.signal) ? {} : { signal: globalOptions.signal },
-		...isNullish(queryOptions.signal) ? {} : { signal: queryOptions.signal },
-		...isNullish(globalOptions.version) ? {} : { version: globalOptions.version },
-		...isNullish(queryOptions.version) ? {} : { version: queryOptions.version },
-		...queryOptions.mutationInvalidates ? { mutationInvalidates: queryOptions.mutationInvalidates } : {},
-		...isNullish(globalOptions.runtimeValidation) ? {} : { runtimeValidation: globalOptions.runtimeValidation },
-		...isNullish(queryOptions.runtimeValidation) ? {} : { runtimeValidation: queryOptions.runtimeValidation }
-	};
+//#endregion
+//#region src/utils/execute-hook.ts
+const executeHook = async (name, commands = [], args = []) => {
+	log(styleText("white", `Running ${name} hook...`));
+	for (const command of commands) try {
+		if (isString(command)) await executeCommand(command, args);
+		else if (isFunction(command)) await command(args);
+		else if (isObject(command)) await executeObjectCommand(command, args);
+	} catch (error) {
+		logError(error, `Failed to run ${name} hook`);
+	}
+};
+async function executeCommand(command, args) {
+	const [cmd, ..._args] = [...parseArgsStringToArgv(command), ...args];
+	await execa(cmd, _args);
 }
-function getDefaultFilesHeader({ title, description, version: version$1 } = {}) {
-	return [
-		`Generated by ${name} v${version} 🍺`,
-		`Do not edit manually.`,
-		...title ? [title] : [],
-		...description ? [description] : [],
-		...version$1 ? [`OpenAPI spec version: ${version$1}`] : []
-	];
+async function executeObjectCommand(command, args) {
+	if (command.injectGeneratedDirsAndFiles === false) args = [];
+	if (isString(command.command)) await executeCommand(command.command, args);
+	else if (isFunction(command.command)) await command.command();
 }
 //#endregion
 //#region src/utils/watcher.ts
@@ -1801,8 +1916,8 @@ async function writeZodSchemaIndex(schemasPath, fileExtension, header, schemaNam
 	const importFileExtension = getImportExtension(fileExtension, tsconfig);
 	const indexPath = path.join(schemasPath, `index.ts`);
 	let existingExports = "";
-	if (shouldMergeExisting && await fs.pathExists(indexPath)) {
-		const existingContent = await fs.readFile(indexPath, "utf8");
+	if (shouldMergeExisting && await fs$2.pathExists(indexPath)) {
+		const existingContent = await fs$2.readFile(indexPath, "utf8");
 		const headerMatch = /^(\/\*\*[\s\S]*?\*\/\n)?/.exec(existingContent);
 		const headerPart = headerMatch ? headerMatch[0] : "";
 		existingExports = existingContent.slice(headerPart.length).trim();
@@ -1812,7 +1927,7 @@ async function writeZodSchemaIndex(schemasPath, fileExtension, header, schemaNam
 	}).toSorted().join("\n");
 	const allExports = existingExports ? `${existingExports}\n${newExports}` : newExports;
 	const uniqueExports = [...new Set(allExports.split("\n"))].filter((line) => line.trim()).toSorted().join("\n");
-	await fs.outputFile(indexPath, `${header}\n${uniqueExports}\n`);
+	await fs$2.outputFile(indexPath, `${header}\n${uniqueExports}\n`);
 }
 async function writeZodSchemaTagsSplitBarrel(schemasPath, fileExtension, header, componentDirs, verbDirs, namingConvention, tsconfig) {
 	const importExt = getImportExtension(fileExtension, tsconfig);
@@ -1835,7 +1950,7 @@ async function writeZodSchemaTagsSplitBarrel(schemasPath, fileExtension, header,
 	const allExports = [...rootExports, ...tagExports];
 	const rootIndexPath = path.join(schemasPath, "index.ts");
 	const content = `${header}\n${allExports.join("\n")}\n`;
-	await fs.outputFile(rootIndexPath, content);
+	await fs$2.outputFile(rootIndexPath, content);
 }
 function generateZodSchemasInline(builder, output, includeZodImport = true, paramsMutator, includeParamsImport = false) {
 	if (output.override.zod.generateReusableSchemas === true) return generateZodSchemasInlineReusable(builder, output, includeZodImport, paramsMutator, includeParamsImport);
@@ -1938,7 +2053,7 @@ async function writeZodSchemas(builder, schemasPath, fileExtension, header, outp
 	const groupedSchemasToWrite = groupSchemasByFilePath(schemasToWrite);
 	for (const schemaGroup of groupedSchemasToWrite) {
 		const fileContent = generateZodSchemaFileContent(header, schemaGroup, output.override.zod.variant);
-		await fs.outputFile(schemaGroup[0].filePath, fileContent);
+		await fs$2.outputFile(schemaGroup[0].filePath, fileContent);
 	}
 	const writtenSchemaNames = groupedSchemasToWrite.map((schemaGroup) => schemaGroup[0].schemaName);
 	if (output.indexFiles && !isSplit) await writeZodSchemaIndex(schemasPath, fileExtension, header, writtenSchemaNames, output.namingConvention, false, output.tsconfig);
@@ -2005,7 +2120,7 @@ async function writeZodSchemasReusable(builder, schemasPath, fileExtension, head
 		}) : void 0;
 		const imports = [...mutatorImportStr ? [mutatorImportStr] : [], ...refImports ? [refImports] : []].join("\n");
 		const fileContent = `${header}${getZodSchemaImportStatement(output.override.zod.variant)}\n` + (imports ? `${imports}\n\n` : "\n") + `${rendered.content}\n`;
-		await fs.outputFile(filePath, fileContent);
+		await fs$2.outputFile(filePath, fileContent);
 	}
 	if (output.indexFiles && !isSplit && rewritten.length > 0) await writeZodSchemaIndex(schemasPath, fileExtension, header, rewritten.map((e) => e.name), output.namingConvention, true, output.tsconfig);
 	if (isSplit) {
@@ -2127,7 +2242,7 @@ async function writeZodSchemasFromVerbs(verbOptions, schemasPath, fileExtension,
 	const groupedSchemasToWrite = groupSchemasByFilePath(schemasToWrite);
 	for (const schemaGroup of groupedSchemasToWrite) {
 		const fileContent = generateZodSchemaFileContent(header, schemaGroup, output.override.zod.variant);
-		await fs.outputFile(schemaGroup[0].filePath, fileContent);
+		await fs$2.outputFile(schemaGroup[0].filePath, fileContent);
 	}
 	const writtenSchemaNames = groupedSchemasToWrite.map((schemaGroup) => schemaGroup[0].schemaName);
 	if (output.indexFiles && !isSplit && uniqueVerbsSchemas.length > 0) await writeZodSchemaIndex(schemasPath, fileExtension, header, writtenSchemaNames, output.namingConvention, true, output.tsconfig);
@@ -2177,7 +2292,7 @@ function getComparableFilePath(filePath) {
 	const resolvedPath = path.resolve(filePath);
 	let comparablePath = resolvedPath;
 	try {
-		comparablePath = fs.realpathSync(resolvedPath);
+		comparablePath = fs$2.realpathSync(resolvedPath);
 	} catch (error) {
 		if (error.code !== "ENOENT") throw error;
 	}
@@ -2207,12 +2322,12 @@ async function addOperationSchemasReExport(schemaPath, operationSchemasPath, hea
 	const schemaIndexPath = path.join(schemaPath, `index.ts`);
 	const esmImportPath = upath.getRelativeImportPath(schemaIndexPath, operationSchemasPath);
 	const exportLine = `export * from '${esmImportPath}';\n`;
-	if (await fs.pathExists(schemaIndexPath)) {
-		const existingContent = await fs.readFile(schemaIndexPath, "utf8");
-		if (!new RegExp(String.raw`export\s*\*\s*from\s*['"]${esmImportPath.replaceAll(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`)}['"]`).test(existingContent)) await fs.appendFile(schemaIndexPath, exportLine);
+	if (await fs$2.pathExists(schemaIndexPath)) {
+		const existingContent = await fs$2.readFile(schemaIndexPath, "utf8");
+		if (!new RegExp(String.raw`export\s*\*\s*from\s*['"]${esmImportPath.replaceAll(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`)}['"]`).test(existingContent)) await fs$2.appendFile(schemaIndexPath, exportLine);
 	} else {
 		const content = header && header.trim().length > 0 ? `${header}\n${exportLine}` : exportLine;
-		await fs.outputFile(schemaIndexPath, content);
+		await fs$2.outputFile(schemaIndexPath, content);
 	}
 }
 /**
@@ -2465,16 +2580,16 @@ async function writeSpecs(builder, workspace, options, projectName) {
 		}
 		if (output.operationSchemas) imports.push(upath.getRelativeImportPath(indexFile, getFileInfo(output.operationSchemas).dirname));
 		if (output.indexFiles) {
-			if (await fs.pathExists(indexFile)) {
-				const data = await fs.readFile(indexFile, "utf8");
+			if (await fs$2.pathExists(indexFile)) {
+				const data = await fs$2.readFile(indexFile, "utf8");
 				const importsNotDeclared = imports.filter((imp) => !data.includes(`export * from '${imp}'`));
-				await fs.appendFile(indexFile, unique(importsNotDeclared).map((imp) => `export * from '${imp}';\n`).join(""));
-			} else await fs.outputFile(indexFile, unique(imports).map((imp) => `export * from '${imp}';`).join("\n") + "\n");
+				await fs$2.appendFile(indexFile, unique(importsNotDeclared).map((imp) => `export * from '${imp}';\n`).join(""));
+			} else await fs$2.outputFile(indexFile, unique(imports).map((imp) => `export * from '${imp}';`).join("\n") + "\n");
 			implementationPaths = [indexFile, ...implementationPathsForIndex];
 		}
 	}
 	if (builder.extraFiles.length > 0) {
-		await Promise.all(builder.extraFiles.map(async (file) => fs.outputFile(file.path, file.content)));
+		await Promise.all(builder.extraFiles.map(async (file) => fs$2.outputFile(file.path, file.content)));
 		implementationPaths = [...implementationPaths, ...builder.extraFiles.map((file) => file.path)];
 	}
 	const paths = [
@@ -2577,7 +2692,7 @@ async function generateSpec(workspace, options, projectName) {
 function findConfigFile(configFilePath) {
 	if (configFilePath) {
 		const absolutePath = path.isAbsolute(configFilePath) ? configFilePath : path.resolve(process.cwd(), configFilePath);
-		if (!fs$2.existsSync(absolutePath)) throw new Error(`Config file ${configFilePath} does not exist`);
+		if (!fs$1.existsSync(absolutePath)) throw new Error(`Config file ${configFilePath} does not exist`);
 		return absolutePath;
 	}
 	const root = process.cwd();
@@ -2588,7 +2703,7 @@ function findConfigFile(configFilePath) {
 		".mts"
 	]) {
 		const fullPath = path.resolve(root, `orval.config${ext}`);
-		if (fs$2.existsSync(fullPath)) return fullPath;
+		if (fs$1.existsSync(fullPath)) return fullPath;
 	}
 	throw new Error(`No config file found in ${root}`);
 }
@@ -2610,4 +2725,4 @@ async function loadConfigFile(configFilePath) {
 //#endregion
 export { defineConfig as a, description as c, startWatcher as i, name as l, loadConfigFile as n, defineTransformer as o, generateSpec as r, normalizeOptions as s, findConfigFile as t, version as u };
 
-//# sourceMappingURL=config-DGhExJ4J.mjs.map
+//# sourceMappingURL=config-CotJKggp.mjs.map