@orval/core 8.3.0 → 8.4.0

package/dist/index.mjs

@@ -1,11 +1,12 @@
-import { t as __export } from "./chunk-C6wwvPpM.mjs";
+import { t as __export } from "./chunk-1-as6MWF.mjs";
+import { createRequire } from "node:module";
 import { entries, groupBy, isArray, isBoolean, isBoolean as isBoolean$1, isEmptyish, isFunction, isNullish, isNullish as isNullish$1, isNumber, isString, isString as isString$1, prop, unique, uniqueBy, uniqueWith } from "remeda";
 import { keyword } from "esutils";
 import path from "node:path";
 import { compare } from "compare-versions";
 import debug from "debug";
 import { pathToFileURL } from "node:url";
-import fs from "node:fs";
+import fs, { existsSync, readFileSync } from "node:fs";
 import { globby } from "globby";
 import readline from "node:readline";
 import chalk from "chalk";
@@ -720,6 +721,47 @@ function joinSafe(...values) {
 	return result;
 }
 
+//#endregion
+//#region src/utils/resolve-version.ts
+function resolveInstalledVersion(packageName, fromDir) {
+	try {
+		const require = createRequire(path.join(fromDir, "noop.js"));
+		try {
+			return require(`${packageName}/package.json`).version;
+		} catch (directError) {
+			if (directError instanceof Error && "code" in directError && directError.code === "ERR_PACKAGE_PATH_NOT_EXPORTED") {
+				const entryPath = require.resolve(packageName);
+				let dir = path.dirname(entryPath);
+				while (dir !== path.parse(dir).root) {
+					const pkgPath = path.join(dir, "package.json");
+					if (existsSync(pkgPath)) {
+						const pkgData = JSON.parse(readFileSync(pkgPath, "utf8"));
+						if (pkgData.name === packageName) return pkgData.version;
+					}
+					dir = path.dirname(dir);
+				}
+				return;
+			}
+			throw directError;
+		}
+	} catch {
+		return;
+	}
+}
+function resolveInstalledVersions(packageJson, fromDir) {
+	const resolved = {};
+	const allDeps = new Set([
+		...Object.keys(packageJson.dependencies ?? {}),
+		...Object.keys(packageJson.devDependencies ?? {}),
+		...Object.keys(packageJson.peerDependencies ?? {})
+	]);
+	for (const pkgName of allDeps) {
+		const version = resolveInstalledVersion(pkgName, fromDir);
+		if (version) resolved[pkgName] = version;
+	}
+	return resolved;
+}
+
 //#endregion
 //#region src/utils/sort.ts
 const sortByPriority = (arr) => arr.toSorted((a, b) => {
@@ -1437,7 +1479,25 @@ function getResReqTypes(responsesOrRequests, name, context, defaultType = "unkno
 	return uniqueBy(responsesOrRequests.filter(([, res]) => Boolean(res)).map(([key, res]) => {
 		if (isReference(res)) {
 			const { schema: bodySchema, imports: [{ name: name$1, schemaName }] } = resolveRef(res, context);
-			const [contentType, mediaType] = Object.entries(bodySchema.content ?? {})[0] ?? [];
+			const firstEntry = Object.entries(bodySchema.content ?? {}).at(0);
+			if (!firstEntry) return [{
+				value: name$1,
+				imports: [{
+					name: name$1,
+					schemaName
+				}],
+				schemas: [],
+				type: "unknown",
+				isEnum: false,
+				isRef: true,
+				hasReadonlyProps: false,
+				originalSchema: void 0,
+				example: void 0,
+				examples: void 0,
+				key,
+				contentType: void 0
+			}];
+			const [contentType, mediaType] = firstEntry;
 			const isFormData = formDataContentTypes.has(contentType);
 			const isFormUrlEncoded = formUrlEncodedContentTypes.has(contentType);
 			if (!isFormData && !isFormUrlEncoded || !mediaType.schema) return [{
@@ -1594,6 +1654,17 @@ function getResReqTypes(responsesOrRequests, name, context, defaultType = "unkno
 	}).flat(), uniqueKey);
 }
 /**
+* Determine the responseType option based on success content types only.
+* This avoids error-response content types influencing the responseType.
+*/
+function getSuccessResponseType(response) {
+	const successContentTypes = response.types.success.map((t) => t.contentType).filter(Boolean);
+	if (response.isBlob) return "blob";
+	const hasJsonResponse = successContentTypes.some((contentType) => contentType.includes("json") || contentType.includes("+json"));
+	const hasTextResponse = successContentTypes.some((contentType) => contentType.startsWith("text/") || contentType.includes("xml"));
+	if (!hasJsonResponse && hasTextResponse) return "text";
+}
+/**
 * Determine the response type category for a given content type.
 * Used to set the correct responseType option in HTTP clients.
 *
@@ -2677,13 +2748,27 @@ function getProps({ body, queryParams, params, operationName, headers, context }
 	]);
 }
 function getQueryParamDefinition(queryParams, context) {
-	let paramType = queryParams?.schema.name;
-	if (OutputClient.ANGULAR === context.output.client) paramType = `DeepNonNullable<${paramType}>`;
+	const paramType = queryParams?.schema.name;
 	return `params${(queryParams?.isOptional || context.output.allParamsOptional) && !context.output.optionsParamRequired ? "?" : ""}: ${paramType}`;
 }
 
 //#endregion
 //#region src/getters/query-params.ts
+const isOpenApiSchemaObject = (value) => {
+	if (!value || typeof value !== "object") return false;
+	return !("$ref" in value);
+};
+const isSchemaNullable = (schema) => {
+	if (schema.nullable === true) return true;
+	if (schema.type === "null") return true;
+	if (Array.isArray(schema.type) && schema.type.includes("null")) return true;
+	const oneOfVariants = Array.isArray(schema.oneOf) ? schema.oneOf : [];
+	const anyOfVariants = Array.isArray(schema.anyOf) ? schema.anyOf : [];
+	return [...oneOfVariants, ...anyOfVariants].some((variant) => {
+		if (!isOpenApiSchemaObject(variant)) return false;
+		return isSchemaNullable(variant);
+	});
+};
 function getQueryParamsTypes(queryParams, operationName, context) {
 	return queryParams.map(({ parameter, imports: parameterImports }) => {
 		const { name, required, schema: schemaParam, content } = parameter;
@@ -2708,6 +2793,8 @@ function getQueryParamsTypes(queryParams, operationName, context) {
 			...schemaForDoc
 		}, void 0, context);
 		if (parameterImports.length > 0) return {
+			name,
+			required,
 			definition: `${doc}${key}${!required || schema.default ? "?" : ""}: ${parameterImports[0].name};`,
 			imports: parameterImports,
 			schemas: [],
@@ -2717,6 +2804,8 @@ function getQueryParamsTypes(queryParams, operationName, context) {
 			const enumName = queryName;
 			const enumValue = getEnum(resolvedValue.value, enumName, getEnumNames(resolvedValue.originalSchema), context.output.override.enumGenerationType, getEnumDescriptions(resolvedValue.originalSchema), context.output.override.namingConvention.enum);
 			return {
+				name,
+				required,
 				definition: `${doc}${key}${!required || schema.default ? "?" : ""}: ${enumName};`,
 				imports: [{ name: enumName }],
 				schemas: [...resolvedValue.schemas, {
@@ -2728,6 +2817,8 @@ function getQueryParamsTypes(queryParams, operationName, context) {
 			};
 		}
 		return {
+			name,
+			required,
 			definition: `${doc}${key}${!required || schema.default ? "?" : ""}: ${resolvedValue.value};`,
 			imports: resolvedValue.imports,
 			schemas: resolvedValue.schemas,
@@ -2743,6 +2834,7 @@ function getQueryParams({ queryParams, operationName, context, suffix = "params"
 	const name = `${pascal(operationName)}${pascal(suffix)}`;
 	const type = types.map(({ definition }) => definition).join("\n");
 	const allOptional = queryParams.every(({ parameter }) => !parameter.required);
+	const requiredNullableKeys = types.filter(({ required, originalSchema }) => required && isSchemaNullable(originalSchema)).map(({ name: name$1 }) => name$1);
 	return {
 		schema: {
 			name,
@@ -2750,14 +2842,15 @@ function getQueryParams({ queryParams, operationName, context, suffix = "params"
 			imports
 		},
 		deps: schemas,
-		isOptional: allOptional
+		isOptional: allOptional,
+		requiredNullableKeys
 	};
 }
 
 //#endregion
 //#region src/getters/response.ts
 function getResponse({ responses, operationName, context, contentType }) {
-	const filteredTypes = filterByContentType(getResReqTypes(Object.entries(responses), operationName, context, "void", (type) => `${type.key}-${type.value}`), contentType);
+	const filteredTypes = filterByContentType(getResReqTypes(Object.entries(responses), operationName, context, "void", (type) => `${type.key}-${type.value}-${type.contentType}`), contentType);
 	const imports = filteredTypes.flatMap(({ imports: imports$1 }) => imports$1);
 	const schemas = filteredTypes.flatMap(({ schemas: schemas$1 }) => schemas$1);
 	const contentTypes = [...new Set(filteredTypes.map(({ contentType: contentType$1 }) => contentType$1))];
@@ -2876,7 +2969,7 @@ function generateComponentDefinition(responses = {}, context, suffix) {
 //#region src/generators/imports.ts
 function generateImports({ imports, namingConvention = NamingConvention.CAMEL_CASE }) {
 	if (imports.length === 0) return "";
-	const grouped = groupBy(uniqueWith(imports, (a, b) => a.name === b.name && a.default === b.default).map((imp) => ({
+	const grouped = groupBy(uniqueWith(imports, (a, b) => a.name === b.name && a.default === b.default && a.alias === b.alias && a.values === b.values && a.isConstant === b.isConstant && a.namespaceImport === b.namespaceImport && a.syntheticDefaultImport === b.syntheticDefaultImport && a.importPath === b.importPath).map((imp) => ({
 		...imp,
 		importPath: imp.importPath ?? `./${conventionName(imp.name, namingConvention)}`
 	})), (imp) => !imp.default && !imp.namespaceImport && !imp.syntheticDefaultImport && !imp.values && !imp.isConstant ? `aggregate|${imp.importPath}` : `single|${imp.importPath}|${imp.name}|${imp.alias ?? ""}|${String(imp.default)}|${String(imp.namespaceImport)}|${String(imp.syntheticDefaultImport)}|${String(imp.values)}|${String(imp.isConstant)}`);
@@ -2951,7 +3044,7 @@ function addDependency({ implementation, exports, dependency, projectName, isAll
 		if (types.length > 0) {
 			let uniqueTypes = types;
 			if (values.length > 0) {
-				uniqueTypes = types.filter((t) => !values.some((v) => v.name === t.name));
+				uniqueTypes = types.filter((t) => !values.some((v) => v.name === t.name && (v.alias ?? "") === (t.alias ?? "")));
 				dep += "\n";
 			}
 			dep += generateDependency({
@@ -2994,7 +3087,17 @@ function generateVerbImports({ response, body, queryParams, props, headers, para
 		...queryParams ? [{ name: queryParams.schema.name }] : [],
 		...headers ? [{ name: headers.schema.name }] : [],
 		...params.flatMap(({ imports }) => imports)
-	];
+	].flatMap((imp) => {
+		if (imp.name !== "Error" || !imp.values || imp.alias) return [imp];
+		return [{
+			...imp,
+			values: void 0
+		}, {
+			...imp,
+			alias: "ErrorSchema",
+			values: true
+		}];
+	});
 }
 
 //#endregion
@@ -3156,46 +3259,143 @@ function removeComments(file) {
 
 //#endregion
 //#region src/generators/options.ts
+/**
+* Filters query params for Angular's HttpClient.
+*
+* Why: Angular's HttpParams / HttpClient `params` type does not accept `null` or
+* `undefined` values, and arrays must only contain string/number/boolean.
+* Orval models often include nullable query params, so we remove nullish values
+* (including nulls inside arrays) before passing params to HttpClient or a
+* paramsSerializer to avoid runtime and type issues.
+*
+* Returns an inline IIFE expression. For paths that benefit from a shared helper
+* (e.g. observe-mode branches), prefer getAngularFilteredParamsCallExpression +
+* getAngularFilteredParamsHelperBody instead.
+*/
+const getAngularFilteredParamsExpression = (paramsExpression, requiredNullableParamKeys = []) => `(() => {
+  const requiredNullableParamKeys = new Set<string>(${JSON.stringify(requiredNullableParamKeys)});
+  const filteredParams = {} as Record<string, string | number | boolean | null | Array<string | number | boolean>>;
+  for (const [key, value] of Object.entries(${paramsExpression})) {
+    if (Array.isArray(value)) {
+      const filtered = value.filter(
+        (item) =>
+          item != null &&
+          (typeof item === 'string' ||
+            typeof item === 'number' ||
+            typeof item === 'boolean'),
+          ) as Array<string | number | boolean>;
+      if (filtered.length) {
+        filteredParams[key] = filtered;
+      }
+    } else if (value === null && requiredNullableParamKeys.has(key)) {
+      filteredParams[key] = value;
+    } else if (
+      value != null &&
+      (typeof value === 'string' ||
+        typeof value === 'number' ||
+        typeof value === 'boolean')
+    ) {
+      filteredParams[key] = value as string | number | boolean;
+    }
+  }
+  return filteredParams as unknown as Record<string, string | number | boolean | Array<string | number | boolean>>;
+})()`;
+/**
+* Returns the body of a standalone `filterParams` helper function
+* to be emitted once in the generated file header, replacing the
+* inline IIFE that was previously duplicated in every method.
+*/
+const getAngularFilteredParamsHelperBody = () => `function filterParams(
+  params: Record<string, unknown>,
+  requiredNullableKeys: Set<string> = new Set(),
+): Record<string, string | number | boolean | Array<string | number | boolean>> {
+  const filteredParams: Record<string, string | number | boolean | null | Array<string | number | boolean>> = {};
+  for (const [key, value] of Object.entries(params)) {
+    if (Array.isArray(value)) {
+      const filtered = value.filter(
+        (item) =>
+          item != null &&
+          (typeof item === 'string' ||
+            typeof item === 'number' ||
+            typeof item === 'boolean'),
+      ) as Array<string | number | boolean>;
+      if (filtered.length) {
+        filteredParams[key] = filtered;
+      }
+    } else if (value === null && requiredNullableKeys.has(key)) {
+      filteredParams[key] = value;
+    } else if (
+      value != null &&
+      (typeof value === 'string' ||
+        typeof value === 'number' ||
+        typeof value === 'boolean')
+    ) {
+      filteredParams[key] = value as string | number | boolean;
+    }
+  }
+  return filteredParams as Record<string, string | number | boolean | Array<string | number | boolean>>;
+}`;
+/**
+* Returns a call expression to the `filterParams` helper function.
+*/
+const getAngularFilteredParamsCallExpression = (paramsExpression, requiredNullableParamKeys = []) => `filterParams(${paramsExpression}, new Set<string>(${JSON.stringify(requiredNullableParamKeys)}))`;
 function generateBodyOptions(body, isFormData, isFormUrlEncoded) {
 	if (isFormData && body.formData) return "\n      formData,";
 	if (isFormUrlEncoded && body.formUrlEncoded) return "\n      formUrlEncoded,";
 	if (body.implementation) return `\n      ${body.implementation},`;
 	return "";
 }
-function generateAxiosOptions({ response, isExactOptionalPropertyTypes, queryParams, headers, requestOptions, hasSignal, hasSignalParam = false, isVue, isAngular, paramsSerializer, paramsSerializerOptions }) {
+function generateAxiosOptions({ response, isExactOptionalPropertyTypes, angularObserve, angularParamsRef, requiredNullableQueryParamKeys, queryParams, headers, requestOptions, hasSignal, hasSignalParam = false, isVue, isAngular, paramsSerializer, paramsSerializerOptions }) {
 	const isRequestOptions = requestOptions !== false;
 	const signalVar = hasSignalParam ? "querySignal" : "signal";
 	const signalProp = hasSignalParam ? `signal: ${signalVar}` : "signal";
 	if (!queryParams && !headers && !response.isBlob && response.definition.success !== "string") {
-		if (isRequestOptions) return "options";
+		if (isRequestOptions) return isAngular ? angularObserve ? `{
+        ...(options as Omit<NonNullable<typeof options>, 'observe'>),
+        observe: '${angularObserve}',
+      }` : "(options as Omit<NonNullable<typeof options>, 'observe'>)" : "options";
 		if (hasSignal) return isExactOptionalPropertyTypes ? `...(${signalVar} ? { ${signalProp} } : {})` : signalProp;
 		return "";
 	}
 	let value = "";
 	if (!isRequestOptions) {
-		if (queryParams) value += "\n        params,";
+		if (queryParams) if (isAngular) {
+			const iifeExpr = getAngularFilteredParamsExpression("params ?? {}", requiredNullableQueryParamKeys);
+			value += paramsSerializer ? `\n        params: ${paramsSerializer.name}(${iifeExpr}),` : `\n        params: ${iifeExpr},`;
+		} else value += "\n        params,";
 		if (headers) value += "\n        headers,";
 		if (hasSignal) value += isExactOptionalPropertyTypes ? `\n        ...(${signalVar} ? { ${signalProp} } : {}),` : `\n        ${signalProp},`;
 	}
 	if (!isObject(requestOptions) || !Object.hasOwn(requestOptions, "responseType")) {
-		if (response.isBlob) value += `\n        responseType: 'blob',`;
-		else if (response.contentTypes.at(0) === "text/plain") value += `\n        responseType: 'text',`;
+		const successResponseType = getSuccessResponseType(response);
+		if (successResponseType) value += `\n        responseType: '${successResponseType}',`;
 	}
 	if (isObject(requestOptions)) value += `\n ${stringify(requestOptions)?.slice(1, -1)}`;
 	if (isRequestOptions) {
-		value += "\n    ...options,";
+		value += isAngular ? "\n    ...(options as Omit<NonNullable<typeof options>, 'observe'>)," : "\n    ...options,";
+		if (isAngular && angularObserve) value += `\n        observe: '${angularObserve}',`;
 		if (queryParams) if (isVue) value += "\n        params: {...unref(params), ...options?.params},";
-		else if (isAngular && paramsSerializer) value += `\n        params: ${paramsSerializer.name}({...params, ...options?.params}),`;
+		else if (isAngular && angularParamsRef) value += `\n        params: ${angularParamsRef},`;
+		else if (isAngular && paramsSerializer) {
+			const callExpr = getAngularFilteredParamsCallExpression("{...params, ...options?.params}", requiredNullableQueryParamKeys);
+			value += `\n        params: ${paramsSerializer.name}(${callExpr}),`;
+		} else if (isAngular) value += `\n        params: ${getAngularFilteredParamsCallExpression("{...params, ...options?.params}", requiredNullableQueryParamKeys)},`;
 		else value += "\n        params: {...params, ...options?.params},";
 		if (headers) value += "\n        headers: {...headers, ...options?.headers},";
 	}
-	if (!isAngular && queryParams && (paramsSerializer || paramsSerializerOptions?.qs)) value += paramsSerializer ? `\n        paramsSerializer: ${paramsSerializer.name},` : `\n        paramsSerializer: (params) => qs.stringify(params, ${JSON.stringify(paramsSerializerOptions?.qs)}),`;
+	if (!isAngular && queryParams && (paramsSerializer || paramsSerializerOptions?.qs)) {
+		const qsOptions = paramsSerializerOptions?.qs;
+		value += paramsSerializer ? `\n        paramsSerializer: ${paramsSerializer.name},` : `\n        paramsSerializer: (params) => qs.stringify(params, ${JSON.stringify(qsOptions)}),`;
+	}
 	return value;
 }
-function generateOptions({ route, body, headers, queryParams, response, verb, requestOptions, isFormData, isFormUrlEncoded, isAngular, isExactOptionalPropertyTypes, hasSignal, hasSignalParam, isVue, paramsSerializer, paramsSerializerOptions }) {
+function generateOptions({ route, body, angularObserve, angularParamsRef, headers, queryParams, response, verb, requestOptions, isFormData, isFormUrlEncoded, isAngular, isExactOptionalPropertyTypes, hasSignal, hasSignalParam, isVue, paramsSerializer, paramsSerializerOptions }) {
 	const bodyOptions = getIsBodyVerb(verb) ? generateBodyOptions(body, isFormData, isFormUrlEncoded) : "";
 	const axiosOptions = generateAxiosOptions({
 		response,
+		angularObserve,
+		angularParamsRef,
+		requiredNullableQueryParamKeys: queryParams?.requiredNullableKeys,
 		queryParams: queryParams?.schema,
 		headers: headers?.schema,
 		requestOptions,
@@ -3207,12 +3407,15 @@ function generateOptions({ route, body, headers, queryParams, response, verb, re
 		paramsSerializer,
 		paramsSerializerOptions
 	});
-	const options = axiosOptions ? `{${axiosOptions}}` : "";
+	const isRawOptionsArgument = axiosOptions === "options" || axiosOptions.startsWith("(") && axiosOptions.endsWith(")");
+	const optionsArgument = axiosOptions ? isRawOptionsArgument ? axiosOptions : `{${axiosOptions}}` : "";
 	if (verb === Verbs.DELETE) {
-		if (!bodyOptions) return `\n      \`${route}\`,${axiosOptions === "options" ? axiosOptions : options}\n    `;
-		return `\n      \`${route}\`,{${isAngular ? "body" : "data"}:${bodyOptions} ${axiosOptions === "options" ? `...${axiosOptions}` : axiosOptions}}\n    `;
+		if (!bodyOptions) return `\n      \`${route}\`${optionsArgument ? `,${optionsArgument}` : ""}\n    `;
+		const deleteBodyOptions = isRawOptionsArgument ? `...${optionsArgument}` : axiosOptions;
+		return `\n      \`${route}\`,{${isAngular ? "body" : "data"}:${bodyOptions} ${axiosOptions ? deleteBodyOptions : ""}}\n    `;
 	}
-	return `\n      \`${route}\`,${getIsBodyVerb(verb) ? bodyOptions || "undefined," : ""}${axiosOptions === "options" ? axiosOptions : options}\n    `;
+	const bodyOrOptions = getIsBodyVerb(verb) ? bodyOptions || "undefined," : "";
+	return `\n      \`${route}\`${bodyOrOptions || optionsArgument ? "," : ""}${bodyOrOptions}${optionsArgument}\n    `;
 }
 function generateBodyMutatorConfig(body, isFormData, isFormUrlEncoded) {
 	if (isFormData && body.formData) return ",\n       data: formData";
@@ -3220,16 +3423,18 @@ function generateBodyMutatorConfig(body, isFormData, isFormUrlEncoded) {
 	if (body.implementation) return `,\n      data: ${body.implementation}`;
 	return "";
 }
-function generateQueryParamsAxiosConfig(response, isVue, queryParams) {
+function generateQueryParamsAxiosConfig(response, isVue, isAngular, requiredNullableQueryParamKeys, queryParams) {
 	if (!queryParams && !response.isBlob) return "";
 	let value = "";
-	if (queryParams) value += isVue ? ",\n        params: unref(params)" : ",\n        params";
+	if (queryParams) if (isVue) value += ",\n        params: unref(params)";
+	else if (isAngular) value += `,\n        params: ${getAngularFilteredParamsExpression("params ?? {}", requiredNullableQueryParamKeys)}`;
+	else value += ",\n        params";
 	if (response.isBlob) value += `,\n        responseType: 'blob'`;
 	return value;
 }
-function generateMutatorConfig({ route, body, headers, queryParams, response, verb, isFormData, isFormUrlEncoded, hasSignal, hasSignalParam = false, isExactOptionalPropertyTypes, isVue }) {
+function generateMutatorConfig({ route, body, headers, queryParams, response, verb, isFormData, isFormUrlEncoded, hasSignal, hasSignalParam = false, isExactOptionalPropertyTypes, isVue, isAngular }) {
 	const bodyOptions = getIsBodyVerb(verb) ? generateBodyMutatorConfig(body, isFormData, isFormUrlEncoded) : "";
-	const queryParamsOptions = generateQueryParamsAxiosConfig(response, isVue ?? false, queryParams);
+	const queryParamsOptions = generateQueryParamsAxiosConfig(response, isVue ?? false, isAngular ?? false, queryParams?.requiredNullableKeys, queryParams);
 	const headerOptions = body.contentType && !["multipart/form-data"].includes(body.contentType) ? `,\n      headers: {'Content-Type': '${body.contentType}', ${headers ? "...headers" : ""}}` : headers ? ",\n      headers" : "";
 	const signalVar = hasSignalParam ? "querySignal" : "signal";
 	const signalProp = hasSignalParam ? `signal: ${signalVar}` : "signal";
@@ -3862,28 +4067,30 @@ async function writeSchemas({ schemaPath, schemas, target, namingConvention, fil
 //#region src/writers/generate-imports-for-builder.ts
 function generateImportsForBuilder(output, imports, relativeSchemasPath) {
 	const isZodSchemaOutput = isObject(output.schemas) && output.schemas.type === "zod";
-	if (output.indexFiles) return isZodSchemaOutput ? [{
-		exports: imports.map((i) => ({
-			...i,
-			values: true
-		})),
+	let schemaImports = [];
+	if (output.indexFiles) schemaImports = isZodSchemaOutput ? [{
+		exports: imports.filter((i) => !i.importPath),
 		dependency: joinSafe(relativeSchemasPath, "index.zod")
 	}] : [{
-		exports: imports,
+		exports: imports.filter((i) => !i.importPath),
 		dependency: relativeSchemasPath
 	}];
-	else return uniqueBy(imports, (x) => x.name).map((i) => {
+	else schemaImports = uniqueBy(imports.filter((i) => !i.importPath), (x) => x.name).map((i) => {
 		const name = conventionName(i.schemaName ?? i.name, output.namingConvention);
 		const suffix = isZodSchemaOutput ? ".zod" : "";
 		const importExtension = output.fileExtension.replace(/\.ts$/, "") || "";
 		return {
-			exports: isZodSchemaOutput ? [{
-				...i,
-				values: true
-			}] : [i],
+			exports: [i],
 			dependency: joinSafe(relativeSchemasPath, `${name}${suffix}${importExtension}`)
 		};
 	});
+	const otherImports = uniqueBy(imports.filter((i) => !!i.importPath), (x) => x.name + (x.importPath ?? "")).map((i) => {
+		return {
+			exports: [i],
+			dependency: i.importPath
+		};
+	});
+	return [...schemaImports, ...otherImports];
 }
 
 //#endregion
@@ -4440,5 +4647,5 @@ async function writeTagsMode({ builder, output, projectName, header, needSchema
 }
 
 //#endregion
-export { BODY_TYPE_NAME, EnumGeneration, ErrorWithTag, FormDataArrayHandling, GetterPropType, LogLevels, NamingConvention, OutputClient, OutputHttpClient, OutputMockType, OutputMode, PropertySortOrder, RefComponentSuffix, SchemaType, TEMPLATE_TAG_REGEX, URL_REGEX, VERBS_WITH_BODY, Verbs, _filteredVerbs, addDependency, asyncReduce, camel, combineSchemas, compareVersions, conventionName, count, createDebugger, createLogger, createSuccessMessage, createTypeAliasIfNeeded, dedupeUnionType, dynamicImport, escape, filterByContentType, fixCrossDirectoryImports, fixRegularSchemaImports, generalJSTypes, generalJSTypesWithArray, generateAxiosOptions, generateBodyMutatorConfig, generateBodyOptions, generateComponentDefinition, generateDependencyImports, generateFormDataAndUrlEncodedFunction, generateImports, generateModelInline, generateModelsInline, generateMutator, generateMutatorConfig, generateMutatorImports, generateMutatorRequestOptions, generateOptions, generateParameterDefinition, generateQueryParamsAxiosConfig, generateSchemasDefinition, generateTarget, generateTargetForTags, generateVerbImports, generateVerbOptions, generateVerbsOptions, getArray, getBody, getCombinedEnumValue, getDefaultContentType, getEnum, getEnumDescriptions, getEnumImplementation, getEnumNames, getEnumUnionFromSchema, getExtension, getFileInfo, getFormDataFieldFileType, getFullRoute, getIsBodyVerb, getKey, getMockFileExtensionByTypeName, getNumberWord, getObject, getOperationId, getOrvalGeneratedTypes, getParameters, getParams, getParamsInPath, getPropertySafe, getProps, getQueryParams, getRefInfo, getRequestBodyContentTypes, getResReqTypes, getResponse, getResponseTypeCategory, getRoute, getRouteAsArray, getScalar, getTypedResponse, isBinaryContentType, isBoolean, isDirectory, isFunction, isModule, isNullish, isNumber, isNumeric, isObject, isReference, isSchema, isString, isStringLike, isSyntheticDefaultImportsAllow, isUrl, isVerb, jsDoc, jsStringEscape, kebab, keyValuePairsToJsDoc, log, logError, mergeDeep, mismatchArgsMessage, pascal, removeFilesAndEmptyFolders, resolveDiscriminators, resolveExampleRefs, resolveObject, resolveRef, resolveValue, sanitize, snake, sortByPriority, splitSchemasByType, startMessage, stringify, toObjectString, path_exports as upath, upper, writeModelInline, writeModelsInline, writeSchema, writeSchemas, writeSingleMode, writeSplitMode, writeSplitTagsMode, writeTagsMode };
+export { BODY_TYPE_NAME, EnumGeneration, ErrorWithTag, FormDataArrayHandling, GetterPropType, LogLevels, NamingConvention, OutputClient, OutputHttpClient, OutputMockType, OutputMode, PropertySortOrder, RefComponentSuffix, SchemaType, TEMPLATE_TAG_REGEX, URL_REGEX, VERBS_WITH_BODY, Verbs, _filteredVerbs, addDependency, asyncReduce, camel, combineSchemas, compareVersions, conventionName, count, createDebugger, createLogger, createSuccessMessage, createTypeAliasIfNeeded, dedupeUnionType, dynamicImport, escape, filterByContentType, fixCrossDirectoryImports, fixRegularSchemaImports, generalJSTypes, generalJSTypesWithArray, generateAxiosOptions, generateBodyMutatorConfig, generateBodyOptions, generateComponentDefinition, generateDependencyImports, generateFormDataAndUrlEncodedFunction, generateImports, generateModelInline, generateModelsInline, generateMutator, generateMutatorConfig, generateMutatorImports, generateMutatorRequestOptions, generateOptions, generateParameterDefinition, generateQueryParamsAxiosConfig, generateSchemasDefinition, generateTarget, generateTargetForTags, generateVerbImports, generateVerbOptions, generateVerbsOptions, getAngularFilteredParamsCallExpression, getAngularFilteredParamsExpression, getAngularFilteredParamsHelperBody, getArray, getBody, getCombinedEnumValue, getDefaultContentType, getEnum, getEnumDescriptions, getEnumImplementation, getEnumNames, getEnumUnionFromSchema, getExtension, getFileInfo, getFormDataFieldFileType, getFullRoute, getIsBodyVerb, getKey, getMockFileExtensionByTypeName, getNumberWord, getObject, getOperationId, getOrvalGeneratedTypes, getParameters, getParams, getParamsInPath, getPropertySafe, getProps, getQueryParams, getRefInfo, getRequestBodyContentTypes, getResReqTypes, getResponse, getResponseTypeCategory, getRoute, getRouteAsArray, getScalar, getSuccessResponseType, getTypedResponse, isBinaryContentType, isBoolean, isDirectory, isFunction, isModule, isNullish, isNumber, isNumeric, isObject, isReference, isSchema, isString, isStringLike, isSyntheticDefaultImportsAllow, isUrl, isVerb, jsDoc, jsStringEscape, kebab, keyValuePairsToJsDoc, log, logError, mergeDeep, mismatchArgsMessage, pascal, removeFilesAndEmptyFolders, resolveDiscriminators, resolveExampleRefs, resolveInstalledVersion, resolveInstalledVersions, resolveObject, resolveRef, resolveValue, sanitize, snake, sortByPriority, splitSchemasByType, startMessage, stringify, toObjectString, path_exports as upath, upper, writeModelInline, writeModelsInline, writeSchema, writeSchemas, writeSingleMode, writeSplitMode, writeSplitTagsMode, writeTagsMode };
 //# sourceMappingURL=index.mjs.map