vite-plugin-openapi-codegen 1.1.1 → 1.1.2

package/README.md

@@ -149,6 +149,25 @@ export default defineConfig({
 });
 ```
 
+If you want shorter generated type references, enable `typeAliases`. This keeps the type name suffixes, but avoids long chains like `components["schemas"]["CreateUserRequest"]` and `operations["list_users"]["parameters"]["query"]` in the generated output:
+
+```ts
+import { defineConfig } from "vite-plus";
+import { openapiCodegen } from "vite-plugin-openapi-codegen";
+
+export default defineConfig({
+  plugins: [
+    openapiCodegen({
+      input: "openapi.json",
+      output: "src/generated",
+      typeAliases: true,
+    }),
+  ],
+});
+```
+
+When enabled, the plugin writes the raw OpenAPI types to `api-types.d.ts` and adds top-level aliases for schema and operation types that the generated `api.ts` and `client.ts` files import directly.
+
 ## Generated Output
 
 Given a spec path like `/api/users/{user_id}`, the plugin generates a path builder:
@@ -201,6 +220,7 @@ interface Options {
   output: string;
   pathPrefix?: string;
   stripPrefix?: boolean;
+  typeAliases?: boolean;
   httpClient?: {
     module?: string;
     jsonFunction?: string;
@@ -229,6 +249,10 @@ Only paths starting with this prefix are included. The default is `"/api/"`.
 
 Controls whether the `pathPrefix` is removed from generated path builders. The default is `true`.
 
+### `typeAliases`
+
+When enabled, the plugin generates top-level aliases for schema and operation types and makes the emitted `api.ts` and `client.ts` import those shorter names. The suffixes stay intact, so generated names remain readable while avoiding long `components["schemas"][...]` and `operations["..."][...]` chains. The default is `false` to preserve existing output.
+
 ### `httpClient`
 
 Overrides the runtime import path and symbol names used by generated clients.

package/dist/index.d.mts

@@ -75,12 +75,15 @@ interface Options {
   stripPrefix?: boolean;
   /** HTTP client configuration */
   httpClient?: HttpClientConfig;
+  /** Generate and consume top-level type aliases. Default: false */
+  typeAliases?: boolean;
 }
 interface GeneratedArtifacts {
   api: string;
+  apiTypes?: string;
   client: string;
 }
-declare function renderGeneratedArtifacts(spec: OpenAPISpec, options: Pick<Options, "httpClient" | "pathPrefix" | "stripPrefix">, preCollectedOperations?: OperationEntry[]): GeneratedArtifacts;
+declare function renderGeneratedArtifacts(spec: OpenAPISpec, options: Pick<Options, "httpClient" | "pathPrefix" | "stripPrefix" | "typeAliases">, preCollectedOperations?: OperationEntry[]): GeneratedArtifacts;
 declare function openapiCodegen(options: Options): Plugin;
 //#endregion
 export { type HttpClientConfig, type OpenAPISpec, type OperationEntry, type Options, openapiCodegen, renderGeneratedArtifacts };

package/dist/index.mjs

@@ -23,9 +23,9 @@ function renderApiSource(entries, generatedHeader) {
 function renderClientSource(model, generatedHeader, httpClient) {
 	const statements = [createTypeOnlyImport([httpClient.requestOptionsType], httpClient.module), createValueImport([{ name: httpClient.jsonFunction }, { name: httpClient.voidFunction }], httpClient.module)];
 	const apiTypeImports = collectApiTypeImports(model.operations.flatMap((operation) => [
-		operation.bodyChannel.typeExpr,
-		operation.pathChannel.typeExpr,
-		operation.queryChannel.typeExpr,
+		operation.bodyChannel.typeRef?.sourceExpr,
+		operation.pathChannel.typeRef?.sourceExpr,
+		operation.queryChannel.typeRef?.sourceExpr,
 		operation.responseTypeExpr,
 		operation.returnTypeExpr
 	]));
@@ -46,6 +46,10 @@ function renderClientSource(model, generatedHeader, httpClient) {
 	}
 	return printGeneratedFile(statements, generatedHeader);
 }
+function renderOperationTypeAliases(typeAliases) {
+	if (typeAliases.length === 0) return "";
+	return `${typeAliases.map((alias) => `export type ${alias.typeName} = ${alias.definitionExpr};`).join("\n")}\n`;
+}
 function printGeneratedFile(statements, generatedHeader) {
 	const sourceFile = ts.factory.createSourceFile(statements, ts.factory.createToken(ts.SyntaxKind.EndOfFileToken), ts.NodeFlags.None);
 	const printed = AST_PRINTER.printFile(sourceFile).trim();
@@ -75,10 +79,41 @@ function collectApiTypeImports(typeExprs) {
 	for (const typeExpr of typeExprs) {
 		if (!typeExpr) continue;
 		if (typeExpr.includes("components[")) names.add("components");
-		if (typeExpr.includes("operations[")) names.add("operations");
+		if (typeExpr.includes("operations[")) {
+			names.add("operations");
+			continue;
+		}
+		const name = typeExpr.trim();
+		if (/^[A-Za-z_$][\w$]*$/.test(name) && !isBuiltinTypeName(name)) names.add(name);
 	}
 	return [...names].sort();
 }
+function isBuiltinTypeName(name) {
+	return new Set([
+		"AbortSignal",
+		"Array",
+		"Blob",
+		"Date",
+		"Error",
+		"File",
+		"FormData",
+		"Map",
+		"Omit",
+		"Promise",
+		"Record",
+		"Set",
+		"URLSearchParams",
+		"boolean",
+		"never",
+		"null",
+		"number",
+		"object",
+		"string",
+		"undefined",
+		"unknown",
+		"void"
+	]).has(name);
+}
 function createPathExpression(strippedPath) {
 	const matches = [...strippedPath.matchAll(/\{(\w+)\}/g)];
 	if (matches.length === 0) return ts.factory.createStringLiteral(strippedPath);
@@ -104,7 +139,7 @@ function createClientOptionsDeclaration(operation) {
 	]);
 }
 function createClientChannelField(key, channel) {
-	return ts.factory.createPropertySignature(void 0, ts.factory.createIdentifier(key), channel.present && channel.required ? void 0 : ts.factory.createToken(ts.SyntaxKind.QuestionToken), channel.present && channel.typeExpr ? createTypeNodeFromText(channel.typeExpr) : ts.factory.createKeywordTypeNode(ts.SyntaxKind.NeverKeyword));
+	return ts.factory.createPropertySignature(void 0, ts.factory.createIdentifier(key), channel.present && channel.required ? void 0 : ts.factory.createToken(ts.SyntaxKind.QuestionToken), channel.present && channel.typeRef ? createTypeNodeFromText(channel.typeRef.sourceExpr) : ts.factory.createKeywordTypeNode(ts.SyntaxKind.NeverKeyword));
 }
 function createClientFunctionDeclaration(operation) {
 	const requestProperties = [ts.factory.createSpreadAssignment(ts.factory.createIdentifier("requestOptions")), ts.factory.createPropertyAssignment(ts.factory.createIdentifier("method"), ts.factory.createStringLiteral(operation.methodUpper))];
@@ -145,7 +180,8 @@ function buildClientRenderModelFromOperations(operations, spec, requestFunctionN
 	const normalized = operations.map((entry) => normalizeOperation(entry, context, requestFunctionNames));
 	return {
 		operations: normalized,
-		needsSearchParamsHelper: normalized.some((operation) => operation.queryChannel.present)
+		needsSearchParamsHelper: normalized.some((operation) => operation.queryChannel.present),
+		typeAliases: collectTypeAliases(normalized)
 	};
 }
 function collectOperations(spec, pathPrefix = "/api/", stripPrefix = true) {
@@ -161,7 +197,7 @@ function collectOperations(spec, pathPrefix = "/api/", stripPrefix = true) {
 			const strippedPath = stripPrefix ? apiPath.replace(pathPrefix, "") : apiPath;
 			entries.push({
 				apiPath,
-				funcName: makeFuncName(method, apiPath, pathPrefix),
+				funcName: makeFuncName(operation.operationId, method, apiPath, pathPrefix),
 				group: strippedPath.split("/")[0] ?? "misc",
 				method,
 				operation,
@@ -194,7 +230,8 @@ function buildNormalizationContext(spec) {
 	}
 	return {
 		schemaAliasIndex,
-		schemaNames
+		schemaNames,
+		usedTypeNames: new Set(schemaNames)
 	};
 }
 function getParametersByLocation(operation, location) {
@@ -236,7 +273,9 @@ function getBuilderAlias(funcName) {
 function getClientOptionTypeName(funcName) {
 	return `${capitalize(funcName)}Options`;
 }
-function makeFuncName(method, apiPath, pathPrefix = "/api/") {
+function makeFuncName(operationId, method, apiPath, pathPrefix = "/api/") {
+	const normalizedOperationId = toFunctionName(operationId);
+	if (normalizedOperationId.length > 0) return normalizedOperationId;
 	const segments = apiPath.replace(pathPrefix, "").split("/");
 	const result = [];
 	for (const segment of segments) {
@@ -252,6 +291,13 @@ function makeFuncName(method, apiPath, pathPrefix = "/api/") {
 		return index === 0 ? clean : `${clean[0].toUpperCase()}${clean.slice(1)}`;
 	}).join(""))}`;
 }
+function toFunctionName(value) {
+	const segments = value.split(/[^a-zA-Z0-9]+/g).map((segment) => segment.trim()).filter((segment) => segment.length > 0);
+	if (segments.length === 0) return "";
+	const [firstSegment, ...restSegments] = segments;
+	const normalized = [firstSegment[0].toLowerCase() + firstSegment.slice(1), ...restSegments.map((segment) => capitalize(segment.toLowerCase()))].join("");
+	return /^[A-Za-z_$]/.test(normalized) ? normalized : `_${normalized}`;
+}
 function capitalize(value) {
 	if (value.length === 0) return value;
 	return `${value[0].toUpperCase()}${value.slice(1)}`;
@@ -264,13 +310,23 @@ function getTemplateParameterNames(apiPath) {
 	const matches = apiPath.match(/\{(\w+)\}/g) ?? [];
 	return new Set(matches.map((match) => match.slice(1, -1)));
 }
-function resolveParameterTypeExpression(entry, context, location) {
+function resolveParameterTypeReference(entry, context, location) {
 	const effectiveParameters = getEffectiveParametersByLocation(entry, location);
-	if (effectiveParameters.length === 0) return "never";
-	const schemaTypeExpr = resolveAlias(context, effectiveParameters.map((parameter) => parameter.name), entry.operation.tags?.[0]);
-	if (schemaTypeExpr) return schemaTypeExpr;
-	if (hasSameParameterNames(getParametersByLocation(entry.operation, location), effectiveParameters)) return `operations['${entry.operationId}']['parameters']['${location}']`;
-	return renderInlineParameterObject(effectiveParameters);
+	if (effectiveParameters.length === 0) return null;
+	const schemaTypeRef = resolveAlias(context, effectiveParameters.map((parameter) => parameter.name), entry.operation.tags?.[0]);
+	if (schemaTypeRef) return schemaTypeRef;
+	const rawParameters = getParametersByLocation(entry.operation, location);
+	const typeName = allocateOperationTypeName(context, entry.funcName, location === "path" ? "Path" : "Query");
+	if (hasSameParameterNames(rawParameters, effectiveParameters)) return {
+		aliasDefinitionExpr: `operations['${entry.operationId}']['parameters']['${location}']`,
+		sourceExpr: `operations['${entry.operationId}']['parameters']['${location}']`,
+		typeName
+	};
+	return {
+		aliasDefinitionExpr: renderInlineParameterObject(effectiveParameters),
+		sourceExpr: renderInlineParameterObject(effectiveParameters),
+		typeName
+	};
 }
 function normalizeOperation(entry, context, requestFunctionNames) {
 	const successResponse = getSuccessResponseInfo(entry.operation);
@@ -278,7 +334,7 @@ function normalizeOperation(entry, context, requestFunctionNames) {
 	const pathChannel = normalizeParameterChannel(entry, context, "path");
 	const queryChannel = normalizeParameterChannel(entry, context, "query");
 	const bodyChannel = normalizeBodyChannel(entry, context);
-	const responseTypeExpr = resolveResponseTypeExpression(entry, context, successResponse);
+	const responseTypeRef = resolveResponseTypeReference(entry, context, successResponse);
 	return {
 		bodyChannel,
 		builderAlias,
@@ -287,9 +343,9 @@ function normalizeOperation(entry, context, requestFunctionNames) {
 		pathChannel,
 		pathInvocationExpr: pathChannel.present ? `${builderAlias}(options.path)` : `${builderAlias}()`,
 		queryChannel,
-		requestFunction: responseTypeExpr ? requestFunctionNames.json : requestFunctionNames.void,
-		responseTypeExpr,
-		returnTypeExpr: responseTypeExpr ? `Promise<${responseTypeExpr}>` : "Promise<void>"
+		requestFunction: responseTypeRef ? requestFunctionNames.json : requestFunctionNames.void,
+		responseTypeRef,
+		returnTypeExpr: responseTypeRef ? `Promise<${responseTypeRef.typeName}>` : "Promise<void>"
 	};
 }
 function normalizeParameterChannel(entry, context, location) {
@@ -297,40 +353,48 @@ function normalizeParameterChannel(entry, context, location) {
 	if (parameters.length === 0) return {
 		present: false,
 		required: false,
-		typeExpr: null
+		typeRef: null
 	};
 	return {
 		present: true,
 		required: hasRequiredChannel(parameters),
-		typeExpr: resolveParameterTypeExpression(entry, context, location)
+		typeRef: resolveParameterTypeReference(entry, context, location)
 	};
 }
 function normalizeBodyChannel(entry, context) {
-	const typeExpr = resolveRequestBodyTypeExpression(entry, context);
-	if (!typeExpr) return {
+	const typeRef = resolveRequestBodyTypeReference(entry, context);
+	if (!typeRef) return {
 		present: false,
 		required: false,
-		typeExpr: null
+		typeRef: null
 	};
 	return {
 		present: true,
 		required: entry.operation.requestBody?.required !== false,
-		typeExpr
+		typeRef
 	};
 }
-function resolveRequestBodyTypeExpression(entry, context) {
+function resolveRequestBodyTypeReference(entry, context) {
 	const jsonBody = getJsonRequestBody(entry.operation);
 	if (!jsonBody) return null;
-	const schemaTypeExpr = resolveSchemaTypeExpression(context, jsonBody.schema);
-	if (schemaTypeExpr) return schemaTypeExpr;
-	return `operations['${entry.operationId}']['requestBody']['content']['application/json']`;
+	const schemaTypeRef = resolveSchemaTypeReference(context, jsonBody.schema);
+	if (schemaTypeRef) return schemaTypeRef;
+	return {
+		aliasDefinitionExpr: `operations['${entry.operationId}']['requestBody']['content']['application/json']`,
+		sourceExpr: `operations['${entry.operationId}']['requestBody']['content']['application/json']`,
+		typeName: allocateOperationTypeName(context, entry.funcName, "Request")
+	};
 }
-function resolveResponseTypeExpression(entry, context, successResponse) {
+function resolveResponseTypeReference(entry, context, successResponse) {
 	if (!successResponse.hasJsonBody) return null;
 	const jsonContent = (entry.operation.responses?.[successResponse.statusKey])?.content?.["application/json"];
-	const schemaTypeExpr = resolveSchemaTypeExpression(context, jsonContent?.schema);
-	if (schemaTypeExpr) return schemaTypeExpr;
-	return `operations['${entry.operationId}']['responses'][${formatStatusKey(successResponse.statusKey)}]['content']['application/json']`;
+	const schemaTypeRef = resolveSchemaTypeReference(context, jsonContent?.schema);
+	if (schemaTypeRef) return schemaTypeRef;
+	return {
+		aliasDefinitionExpr: `operations['${entry.operationId}']['responses'][${formatStatusKey(successResponse.statusKey)}]['content']['application/json']`,
+		sourceExpr: `operations['${entry.operationId}']['responses'][${formatStatusKey(successResponse.statusKey)}]['content']['application/json']`,
+		typeName: allocateOperationTypeName(context, entry.funcName, "Response")
+	};
 }
 function hasSameParameterNames(left, right) {
 	if (left.length !== right.length) return false;
@@ -342,24 +406,28 @@ function resolveAlias(context, parameterNames, tag) {
 	const key = [...parameterNames].sort().join(",");
 	const candidates = context.schemaAliasIndex.get(key);
 	if (!candidates || candidates.length === 0) return;
-	if (candidates.length === 1) return createSchemaTypeExpression(candidates[0]);
+	if (candidates.length === 1) return createSchemaTypeReference(candidates[0]);
 	if (tag) {
 		const singularTag = tag.replace(/s$/, "");
 		const prefix = `${singularTag[0]?.toUpperCase() ?? ""}${singularTag.slice(1)}`;
 		const match = candidates.find((candidate) => candidate.startsWith(prefix));
-		if (match) return createSchemaTypeExpression(match);
+		if (match) return createSchemaTypeReference(match);
 	}
-	return createSchemaTypeExpression(candidates[0]);
+	return createSchemaTypeReference(candidates[0]);
 }
-function resolveSchemaTypeExpression(context, schema) {
+function resolveSchemaTypeReference(context, schema) {
 	const ref = readSchemaRef(schema);
 	if (!ref) return;
 	const schemaName = ref.split("/").pop();
 	if (!schemaName || !context.schemaNames.has(schemaName)) return;
-	return createSchemaTypeExpression(schemaName);
+	return createSchemaTypeReference(schemaName);
 }
-function createSchemaTypeExpression(schemaName) {
-	return `components['schemas']['${schemaName}']`;
+function createSchemaTypeReference(schemaName) {
+	return {
+		aliasDefinitionExpr: null,
+		sourceExpr: `components['schemas']['${schemaName}']`,
+		typeName: schemaName
+	};
 }
 function readSchemaRef(schema) {
 	if (!schema || typeof schema !== "object") return;
@@ -378,6 +446,40 @@ function renderPrimitiveSchemaType(schema) {
 	if (Array.isArray(type)) return type.map((memberType) => mapPrimitiveType(memberType)).join(" | ");
 	return mapPrimitiveType(type);
 }
+function allocateOperationTypeName(context, funcName, suffix) {
+	const preferredName = `${capitalize(funcName)}${suffix}`;
+	if (!context.usedTypeNames.has(preferredName)) {
+		context.usedTypeNames.add(preferredName);
+		return preferredName;
+	}
+	let counter = 2;
+	let candidate = `${preferredName}_${counter}`;
+	while (context.usedTypeNames.has(candidate)) {
+		counter += 1;
+		candidate = `${preferredName}_${counter}`;
+	}
+	context.usedTypeNames.add(candidate);
+	return candidate;
+}
+function collectTypeAliases(operations) {
+	const aliases = /* @__PURE__ */ new Map();
+	for (const operation of operations) {
+		collectTypeAlias(aliases, operation.pathChannel.typeRef);
+		collectTypeAlias(aliases, operation.queryChannel.typeRef);
+		collectTypeAlias(aliases, operation.bodyChannel.typeRef);
+		collectTypeAlias(aliases, operation.responseTypeRef);
+	}
+	return [...aliases.entries()].map(([typeName, definitionExpr]) => ({
+		definitionExpr,
+		typeName
+	})).sort((left, right) => left.typeName.localeCompare(right.typeName));
+}
+function collectTypeAlias(aliases, typeRef) {
+	if (!typeRef || typeRef.aliasDefinitionExpr == null) return;
+	const existing = aliases.get(typeRef.typeName);
+	if (existing && existing !== typeRef.aliasDefinitionExpr) throw new Error(`Conflicting generated type alias "${typeRef.typeName}" with incompatible definitions.`);
+	aliases.set(typeRef.typeName, typeRef.aliasDefinitionExpr);
+}
 function mapPrimitiveType(type) {
 	switch (type) {
 		case "integer":
@@ -409,50 +511,71 @@ function resolveHttpClientConfig(config) {
 	};
 }
 const GENERATED_HEADER = ["// This file is auto-generated by vite-plugin-openapi-codegen.", "// Do not edit manually. Changes will be overwritten on next build."];
-async function generateApiTypes(source, outputDir) {
+async function generateApiTypes(source, outputDir, useTypeAliases) {
 	const { default: openapiTS, astToString } = await import("openapi-typescript");
-	const contents = astToString(await openapiTS(source));
+	const contents = astToString(await openapiTS(source, useTypeAliases ? {
+		rootTypes: true,
+		rootTypesKeepCasing: true,
+		rootTypesNoSchemaPrefix: true
+	} : void 0));
 	writeFileSync(resolve(outputDir, "api-types.d.ts"), `${GENERATED_HEADER.join("\n")}\n\n${contents}`);
 }
-function createApiEntries(normalizedOps) {
+function createApiEntries(normalizedOps, useTypeAliases) {
 	return normalizedOps.map((op) => ({
 		funcName: op.entry.funcName,
 		group: op.entry.group,
-		pathTypeExpr: op.pathChannel.present ? op.pathChannel.typeExpr : null,
+		pathTypeExpr: op.pathChannel.typeRef == null ? null : useTypeAliases ? op.pathChannel.typeRef.typeName : op.pathChannel.typeRef.sourceExpr,
 		strippedPath: op.entry.strippedPath
 	}));
 }
-function createClientRenderModel(model) {
+function createClientRenderModel(model, useTypeAliases) {
+	const resolveTypeExpr = (typeRef) => typeRef == null ? null : useTypeAliases ? typeRef.typeName : typeRef.sourceExpr;
+	const resolveReturnTypeExpr = (operation) => {
+		const responseTypeExpr = resolveTypeExpr(operation.responseTypeRef);
+		return responseTypeExpr ? `Promise<${responseTypeExpr}>` : "Promise<void>";
+	};
 	return {
 		needsSearchParamsHelper: model.needsSearchParamsHelper,
 		operations: model.operations.map((operation) => ({
-			bodyChannel: operation.bodyChannel,
+			bodyChannel: resolveChannel(operation.bodyChannel, useTypeAliases),
 			builderAlias: operation.builderAlias,
 			funcName: operation.entry.funcName,
 			group: operation.entry.group,
 			methodUpper: operation.entry.method.toUpperCase(),
 			optionTypeName: operation.optionTypeName,
-			pathChannel: operation.pathChannel,
+			pathChannel: resolveChannel(operation.pathChannel, useTypeAliases),
 			pathInvocationExpr: operation.pathInvocationExpr,
-			queryChannel: operation.queryChannel,
+			queryChannel: resolveChannel(operation.queryChannel, useTypeAliases),
 			requestFunction: operation.requestFunction,
-			responseTypeExpr: operation.responseTypeExpr,
-			returnTypeExpr: operation.returnTypeExpr
+			responseTypeExpr: resolveTypeExpr(operation.responseTypeRef),
+			returnTypeExpr: resolveReturnTypeExpr(operation)
 		}))
 	};
 }
+function resolveChannel(channel, useTypeAliases) {
+	if (!channel.typeRef) return channel;
+	return {
+		...channel,
+		typeRef: {
+			...channel.typeRef,
+			sourceExpr: useTypeAliases ? channel.typeRef.typeName : channel.typeRef.sourceExpr
+		}
+	};
+}
 function renderGeneratedArtifacts(spec, options, preCollectedOperations) {
 	const pathPrefix = options.pathPrefix ?? "/api/";
 	const stripPrefix = options.stripPrefix ?? true;
 	const httpClient = resolveHttpClientConfig(options.httpClient);
+	const useTypeAliases = options.typeAliases ?? false;
 	const clientModel = buildClientRenderModelFromOperations(preCollectedOperations ?? collectOperations(spec, pathPrefix, stripPrefix), spec, {
 		json: httpClient.jsonFunction,
 		void: httpClient.voidFunction
 	});
 	if (clientModel.operations.length === 0) throw new Error(`No paths matching prefix "${pathPrefix}" found in openapi.json`);
 	return {
-		api: renderApiSource(createApiEntries(clientModel.operations), GENERATED_HEADER),
-		client: renderClientSource(createClientRenderModel(clientModel), GENERATED_HEADER, httpClient)
+		api: renderApiSource(createApiEntries(clientModel.operations, useTypeAliases), GENERATED_HEADER),
+		client: renderClientSource(createClientRenderModel(clientModel, useTypeAliases), GENERATED_HEADER, httpClient),
+		...useTypeAliases && clientModel.typeAliases.length > 0 ? { apiTypes: renderOperationTypeAliases(clientModel.typeAliases) } : {}
 	};
 }
 async function loadOpenAPIInput(root, input) {
@@ -495,7 +618,8 @@ async function generate(root, options) {
 	const operations = collectOperations(spec, options.pathPrefix ?? "/api/", options.stripPrefix ?? true);
 	const artifacts = renderGeneratedArtifacts(spec, options, operations);
 	warnOnParameterLocationMismatch(operations);
-	await generateApiTypes(apiTypesSource, outputDir);
+	await generateApiTypes(apiTypesSource, outputDir, options.typeAliases ?? false);
+	if (artifacts.apiTypes) writeFileSync(resolve(outputDir, "api-types.d.ts"), artifacts.apiTypes, { flag: "a" });
 	writeFileSync(resolve(outputDir, "api.ts"), artifacts.api);
 	writeFileSync(resolve(outputDir, "client.ts"), artifacts.client);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vite-plugin-openapi-codegen",
-  "version": "1.1.1",
+  "version": "1.1.2",
   "description": "Vite plugin that generates typed API clients and route builders from OpenAPI specs",
   "keywords": [
     "api-client",