vite-plugin-openapi-codegen 1.1.1 → 1.1.3

package/dist/cli.mjs

@@ -0,0 +1,812 @@
+#!/usr/bin/env node
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { loadConfigFromFile } from "vite-plus";
+import { pathToFileURL } from "node:url";
+import { parse } from "yaml";
+import * as ts from "typescript";
+//#region src/ast.ts
+const AST_PRINTER = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
+function renderApiSource(entries, generatedHeader) {
+	const statements = [];
+	const seenGroups = /* @__PURE__ */ new Set();
+	for (const entry of entries) {
+		const parameters = entry.pathTypeExpr == null ? [] : [ts.factory.createParameterDeclaration(void 0, void 0, ts.factory.createIdentifier("params"), void 0, createTypeNodeFromText(entry.pathTypeExpr))];
+		const declaration = ts.factory.createFunctionDeclaration([createExportModifier()], void 0, ts.factory.createIdentifier(entry.funcName), void 0, parameters, ts.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword), ts.factory.createBlock([ts.factory.createReturnStatement(entry.pathTypeExpr == null ? ts.factory.createStringLiteral(entry.strippedPath) : createPathExpression(entry.strippedPath))], true));
+		statements.push(seenGroups.has(entry.group) ? declaration : createGeneratedBannerComment(declaration, capitalize$1(entry.group)));
+		seenGroups.add(entry.group);
+	}
+	const sourceStatements = [];
+	const apiTypeImports = collectApiTypeImports(entries.map((entry) => entry.pathTypeExpr));
+	if (apiTypeImports.length > 0) sourceStatements.push(createTypeOnlyImport(apiTypeImports, "./api-types"));
+	sourceStatements.push(...statements);
+	return printGeneratedFile(sourceStatements, 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.typeRef?.sourceExpr,
+		operation.pathChannel.typeRef?.sourceExpr,
+		operation.queryChannel.typeRef?.sourceExpr,
+		operation.responseTypeExpr,
+		operation.returnTypeExpr
+	]));
+	if (apiTypeImports.length > 0) statements.push(createTypeOnlyImport(apiTypeImports, "./api-types"));
+	statements.push(createValueImport(model.operations.map((operation) => ({
+		alias: operation.builderAlias,
+		name: operation.funcName
+	})), "./api"));
+	const runtimeTypeExpr = httpClient.omitKeys.length > 0 ? `Omit<${httpClient.requestOptionsType}, ${httpClient.omitKeys.map((k) => `'${k}'`).join(" | ")}>` : httpClient.requestOptionsType;
+	statements.push(ts.factory.createTypeAliasDeclaration(void 0, ts.factory.createIdentifier("RuntimeRequestOptions"), void 0, createTypeNodeFromText(runtimeTypeExpr)));
+	if (model.needsSearchParamsHelper) statements.push(createBuildSearchParamsFunction());
+	const seenGroups = /* @__PURE__ */ new Set();
+	for (const operation of model.operations) {
+		const optionsInterface = createClientOptionsDeclaration(operation);
+		statements.push(seenGroups.has(operation.group) ? optionsInterface : createGeneratedBannerComment(optionsInterface, capitalize$1(operation.group)));
+		statements.push(createClientFunctionDeclaration(operation));
+		seenGroups.add(operation.group);
+	}
+	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();
+	return printed.length > 0 ? `${generatedHeader.join("\n")}\n\n${printed}\n` : `${generatedHeader.join("\n")}\n`;
+}
+function parseExpression(sourceText) {
+	const statement = ts.createSourceFile("generated-expression.ts", `const value = ${sourceText}`, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS).statements[0];
+	if (!statement || !ts.isVariableStatement(statement)) throw new Error(`Failed to parse expression: ${sourceText}`);
+	const declaration = statement.declarationList.declarations[0];
+	if (!declaration?.initializer) throw new Error(`Missing parsed initializer for: ${sourceText}`);
+	return declaration.initializer;
+}
+function createTypeOnlyImport(names, moduleSpecifier) {
+	return ts.factory.createImportDeclaration(void 0, ts.factory.createImportClause(true, void 0, ts.factory.createNamedImports(names.map((name) => ts.factory.createImportSpecifier(false, void 0, ts.factory.createIdentifier(name))))), ts.factory.createStringLiteral(moduleSpecifier));
+}
+function createValueImport(specifiers, moduleSpecifier) {
+	return ts.factory.createImportDeclaration(void 0, ts.factory.createImportClause(false, void 0, ts.factory.createNamedImports(specifiers.map((specifier) => ts.factory.createImportSpecifier(false, specifier.alias ? ts.factory.createIdentifier(specifier.name) : void 0, ts.factory.createIdentifier(specifier.alias ?? specifier.name))))), ts.factory.createStringLiteral(moduleSpecifier));
+}
+function createExportModifier() {
+	return ts.factory.createModifier(ts.SyntaxKind.ExportKeyword);
+}
+function createGeneratedBannerComment(node, text) {
+	return ts.addSyntheticLeadingComment(node, ts.SyntaxKind.SingleLineCommentTrivia, ` ${text}`, true);
+}
+function collectApiTypeImports(typeExprs) {
+	const names = /* @__PURE__ */ new Set();
+	for (const typeExpr of typeExprs) {
+		if (!typeExpr) continue;
+		if (typeExpr.includes("components[")) names.add("components");
+		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);
+	const [firstMatch] = matches;
+	const spans = matches.map((match, index) => {
+		const nextMatch = matches[index + 1];
+		const literalText = strippedPath.slice(match.index + match[0].length, nextMatch?.index ?? strippedPath.length);
+		return ts.factory.createTemplateSpan(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("params"), match[1]), nextMatch ? ts.factory.createTemplateMiddle(literalText) : ts.factory.createTemplateTail(literalText));
+	});
+	return ts.factory.createTemplateExpression(ts.factory.createTemplateHead(strippedPath.slice(0, firstMatch.index)), spans);
+}
+function createTypeNodeFromText(sourceText) {
+	const stmt = ts.createSourceFile("__type__.ts", `type __T__ = ${sourceText}`, ts.ScriptTarget.Latest, false, ts.ScriptKind.TS).statements[0];
+	if (!stmt || !ts.isTypeAliasDeclaration(stmt)) throw new Error(`Failed to parse type expression: ${sourceText}`);
+	return stmt.type;
+}
+function createClientOptionsDeclaration(operation) {
+	return ts.factory.createInterfaceDeclaration([createExportModifier()], ts.factory.createIdentifier(operation.optionTypeName), void 0, void 0, [
+		createClientChannelField("query", operation.queryChannel),
+		createClientChannelField("path", operation.pathChannel),
+		createClientChannelField("body", operation.bodyChannel),
+		ts.factory.createPropertySignature(void 0, ts.factory.createIdentifier("signal"), ts.factory.createToken(ts.SyntaxKind.QuestionToken), ts.factory.createTypeReferenceNode("AbortSignal"))
+	]);
+}
+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.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))];
+	if (operation.queryChannel.present) requestProperties.push(ts.factory.createPropertyAssignment(ts.factory.createIdentifier("searchParams"), ts.factory.createCallExpression(ts.factory.createIdentifier("buildSearchParams"), void 0, [ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("options"), "query")])));
+	if (operation.bodyChannel.present) requestProperties.push(ts.factory.createPropertyAssignment(ts.factory.createIdentifier("json"), ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("options"), "body")));
+	requestProperties.push(ts.factory.createPropertyAssignment(ts.factory.createIdentifier("signal"), ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("options"), "signal")));
+	const requestCall = ts.factory.createCallExpression(ts.factory.createIdentifier(operation.requestFunction), operation.responseTypeExpr ? [createTypeNodeFromText(operation.responseTypeExpr)] : void 0, [parseExpression(operation.pathInvocationExpr), ts.factory.createObjectLiteralExpression(requestProperties, true)]);
+	return ts.factory.createFunctionDeclaration([createExportModifier()], void 0, ts.factory.createIdentifier(operation.funcName), void 0, [ts.factory.createParameterDeclaration(void 0, void 0, ts.factory.createIdentifier("options"), void 0, ts.factory.createTypeReferenceNode(operation.optionTypeName)), ts.factory.createParameterDeclaration(void 0, void 0, ts.factory.createIdentifier("requestOptions"), void 0, ts.factory.createTypeReferenceNode("RuntimeRequestOptions"), ts.factory.createObjectLiteralExpression())], createTypeNodeFromText(operation.returnTypeExpr), ts.factory.createBlock([ts.factory.createReturnStatement(requestCall)], true));
+}
+function createBuildSearchParamsFunction() {
+	return ts.factory.createFunctionDeclaration(void 0, void 0, ts.factory.createIdentifier("buildSearchParams"), void 0, [ts.factory.createParameterDeclaration(void 0, void 0, ts.factory.createIdentifier("query"), void 0, createTypeNodeFromText("Record<string, unknown> | undefined"))], createTypeNodeFromText("URLSearchParams | undefined"), ts.factory.createBlock([
+		ts.factory.createIfStatement(ts.factory.createBinaryExpression(ts.factory.createIdentifier("query"), ts.factory.createToken(ts.SyntaxKind.EqualsEqualsEqualsToken), ts.factory.createIdentifier("undefined")), ts.factory.createReturnStatement(ts.factory.createIdentifier("undefined"))),
+		ts.factory.createVariableStatement(void 0, ts.factory.createVariableDeclarationList([ts.factory.createVariableDeclaration(ts.factory.createIdentifier("entries"), void 0, void 0, parseExpression("Object.entries(query).filter(([, value]) => value != null)"))], ts.NodeFlags.Const)),
+		ts.factory.createIfStatement(ts.factory.createBinaryExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("entries"), "length"), ts.factory.createToken(ts.SyntaxKind.EqualsEqualsEqualsToken), ts.factory.createNumericLiteral("0")), ts.factory.createReturnStatement(ts.factory.createIdentifier("undefined"))),
+		ts.factory.createVariableStatement(void 0, ts.factory.createVariableDeclarationList([ts.factory.createVariableDeclaration(ts.factory.createIdentifier("searchParams"), void 0, void 0, ts.factory.createNewExpression(ts.factory.createIdentifier("URLSearchParams"), void 0, []))], ts.NodeFlags.Const)),
+		ts.factory.createForOfStatement(void 0, ts.factory.createVariableDeclarationList([ts.factory.createVariableDeclaration(ts.factory.createArrayBindingPattern([ts.factory.createBindingElement(void 0, void 0, "key"), ts.factory.createBindingElement(void 0, void 0, "value")]))], ts.NodeFlags.Const), ts.factory.createIdentifier("entries"), ts.factory.createBlock([ts.factory.createExpressionStatement(ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("searchParams"), "set"), void 0, [ts.factory.createIdentifier("key"), ts.factory.createCallExpression(ts.factory.createIdentifier("String"), void 0, [ts.factory.createIdentifier("value")])]))], true)),
+		ts.factory.createReturnStatement(ts.factory.createIdentifier("searchParams"))
+	], true));
+}
+function capitalize$1(value) {
+	if (value.length === 0) return value;
+	return `${value[0].toUpperCase()}${value.slice(1)}`;
+}
+//#endregion
+//#region src/normalization.ts
+const HTTP_METHODS = [
+	"get",
+	"put",
+	"post",
+	"delete",
+	"patch"
+];
+function buildClientRenderModelFromOperations(operations, spec, requestFunctionNames = {
+	json: "requestJson",
+	void: "requestVoid"
+}) {
+	const context = buildNormalizationContext(spec);
+	const normalized = operations.map((entry) => normalizeOperation(entry, context, requestFunctionNames));
+	return {
+		operations: normalized,
+		needsSearchParamsHelper: normalized.some((operation) => operation.queryChannel.present),
+		typeAliases: collectTypeAliases(normalized)
+	};
+}
+function collectOperations(spec, pathPrefix = "/api/", stripPrefix = true) {
+	const apiPaths = Object.keys(spec.paths ?? {}).filter((path) => path.startsWith(pathPrefix)).sort();
+	if (apiPaths.length === 0) throw new Error(`No paths matching prefix "${pathPrefix}" found in openapi.json`);
+	const entries = [];
+	for (const apiPath of apiPaths) {
+		const pathItem = spec.paths?.[apiPath];
+		if (!pathItem) continue;
+		for (const method of HTTP_METHODS) {
+			const operation = pathItem[method];
+			if (!operation?.operationId) continue;
+			const strippedPath = stripPrefix ? apiPath.replace(pathPrefix, "") : apiPath;
+			entries.push({
+				apiPath,
+				funcName: makeFuncName(operation.operationId, method, apiPath, pathPrefix),
+				group: strippedPath.split("/")[0] ?? "misc",
+				method,
+				operation,
+				operationId: operation.operationId,
+				strippedPath
+			});
+		}
+	}
+	return entries;
+}
+function getEffectiveParametersByLocation(entry, location) {
+	return (entry.operation.parameters ?? []).filter((parameter) => getEffectiveParameterLocation(entry.apiPath, parameter) === location);
+}
+function warnOnParameterLocationMismatch(operations) {
+	for (const entry of operations) for (const parameter of entry.operation.parameters ?? []) {
+		const effectiveLocation = getEffectiveParameterLocation(entry.apiPath, parameter);
+		if (effectiveLocation === parameter.in) continue;
+		console.warn(`[openapi-codegen] normalized parameter "${parameter.name}" for "${entry.operationId}" from ${parameter.in} to ${effectiveLocation}.`);
+	}
+}
+function buildNormalizationContext(spec) {
+	const schemaAliasIndex = /* @__PURE__ */ new Map();
+	const schemaNames = /* @__PURE__ */ new Set();
+	for (const [name, schema] of Object.entries(spec.components?.schemas ?? {})) {
+		schemaNames.add(name);
+		const props = Object.keys(schema.properties ?? {}).sort().join(",");
+		if (!props) continue;
+		if (!schemaAliasIndex.has(props)) schemaAliasIndex.set(props, []);
+		schemaAliasIndex.get(props)?.push(name);
+	}
+	return {
+		schemaAliasIndex,
+		schemaNames,
+		usedTypeNames: new Set(schemaNames)
+	};
+}
+function getParametersByLocation(operation, location) {
+	return (operation.parameters ?? []).filter((parameter) => parameter.in === location);
+}
+function hasRequiredChannel(parameters) {
+	return parameters.some((parameter) => parameter.required);
+}
+function getJsonRequestBody(operation) {
+	const requestBody = operation.requestBody;
+	if (!requestBody) return void 0;
+	const jsonBody = requestBody.content?.["application/json"];
+	if (!jsonBody) throw new Error(`Operation "${operation.operationId ?? "unknown"}" has a requestBody but no application/json content`);
+	return jsonBody;
+}
+function getSuccessResponseInfo(operation) {
+	const successResponses = Object.entries(operation.responses ?? {}).filter(([statusKey]) => isSuccessStatus(statusKey)).sort(([left], [right]) => Number(left) - Number(right));
+	if (successResponses.length === 0) throw new Error(`Operation "${operation.operationId ?? "unknown"}" has no 2xx success response`);
+	const withJson = successResponses.find(([, response]) => response.content?.["application/json"]);
+	if (withJson) return {
+		hasJsonBody: true,
+		statusKey: withJson[0]
+	};
+	return {
+		hasJsonBody: false,
+		statusKey: successResponses[0][0]
+	};
+}
+function isSuccessStatus(statusKey) {
+	const value = Number(statusKey);
+	return Number.isInteger(value) && value >= 200 && value < 300;
+}
+function formatStatusKey(statusKey) {
+	return Number.isInteger(Number(statusKey)) ? statusKey : `'${statusKey}'`;
+}
+function getBuilderAlias(funcName) {
+	return `build${capitalize(funcName)}Path`;
+}
+function getClientOptionTypeName(funcName) {
+	return `${capitalize(funcName)}Options`;
+}
+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) {
+		if (segment.startsWith("{")) {
+			const resource = segment.slice(1, -1).replace(/_id$/, "");
+			if (result.length > 0) result[result.length - 1] = resource;
+			continue;
+		}
+		result.push(segment);
+	}
+	return `${method}${capitalize(result.map((segment, index) => {
+		const clean = segment.replace(/-([a-z])/g, (_, char) => char.toUpperCase());
+		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)}`;
+}
+function getEffectiveParameterLocation(apiPath, parameter) {
+	if (parameter.in !== "path") return parameter.in;
+	return getTemplateParameterNames(apiPath).has(parameter.name) ? "path" : "query";
+}
+function getTemplateParameterNames(apiPath) {
+	const matches = apiPath.match(/\{(\w+)\}/g) ?? [];
+	return new Set(matches.map((match) => match.slice(1, -1)));
+}
+function resolveParameterTypeReference(entry, context, location) {
+	const effectiveParameters = getEffectiveParametersByLocation(entry, location);
+	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);
+	const builderAlias = getBuilderAlias(entry.funcName);
+	const pathChannel = normalizeParameterChannel(entry, context, "path");
+	const queryChannel = normalizeParameterChannel(entry, context, "query");
+	const bodyChannel = normalizeBodyChannel(entry, context);
+	const responseTypeRef = resolveResponseTypeReference(entry, context, successResponse);
+	return {
+		bodyChannel,
+		builderAlias,
+		entry,
+		optionTypeName: getClientOptionTypeName(entry.funcName),
+		pathChannel,
+		pathInvocationExpr: pathChannel.present ? `${builderAlias}(options.path)` : `${builderAlias}()`,
+		queryChannel,
+		requestFunction: responseTypeRef ? requestFunctionNames.json : requestFunctionNames.void,
+		responseTypeRef,
+		returnTypeExpr: responseTypeRef ? `Promise<${responseTypeRef.typeName}>` : "Promise<void>"
+	};
+}
+function normalizeParameterChannel(entry, context, location) {
+	const parameters = getEffectiveParametersByLocation(entry, location);
+	if (parameters.length === 0) return {
+		present: false,
+		required: false,
+		typeRef: null
+	};
+	return {
+		present: true,
+		required: hasRequiredChannel(parameters),
+		typeRef: resolveParameterTypeReference(entry, context, location)
+	};
+}
+function normalizeBodyChannel(entry, context) {
+	const typeRef = resolveRequestBodyTypeReference(entry, context);
+	if (!typeRef) return {
+		present: false,
+		required: false,
+		typeRef: null
+	};
+	return {
+		present: true,
+		required: entry.operation.requestBody?.required !== false,
+		typeRef
+	};
+}
+function resolveRequestBodyTypeReference(entry, context) {
+	const jsonBody = getJsonRequestBody(entry.operation);
+	if (!jsonBody) return null;
+	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 resolveResponseTypeReference(entry, context, successResponse) {
+	if (!successResponse.hasJsonBody) return null;
+	const jsonContent = (entry.operation.responses?.[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;
+	const leftNames = left.map((parameter) => parameter.name).sort();
+	const rightNames = right.map((parameter) => parameter.name).sort();
+	return leftNames.every((name, index) => name === rightNames[index]);
+}
+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 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 createSchemaTypeReference(match);
+	}
+	return createSchemaTypeReference(candidates[0]);
+}
+function resolveSchemaTypeReference(context, schema) {
+	const ref = readSchemaRef(schema);
+	if (!ref) return;
+	const schemaName = ref.split("/").pop();
+	if (!schemaName || !context.schemaNames.has(schemaName)) return;
+	return createSchemaTypeReference(schemaName);
+}
+function createSchemaTypeReference(schemaName) {
+	return {
+		aliasDefinitionExpr: null,
+		sourceExpr: `components['schemas']['${schemaName}']`,
+		typeName: schemaName
+	};
+}
+function readSchemaRef(schema) {
+	if (!schema || typeof schema !== "object") return;
+	const maybeRef = schema.$ref;
+	return typeof maybeRef === "string" ? maybeRef : void 0;
+}
+function renderInlineParameterObject(parameters) {
+	return `{ ${parameters.map((parameter) => {
+		const optionalMarker = parameter.required ? "" : "?";
+		return `${parameter.name}${optionalMarker}: ${renderPrimitiveSchemaType(parameter.schema)}`;
+	}).join("; ")} }`;
+}
+function renderPrimitiveSchemaType(schema) {
+	const type = schema?.type;
+	if (!type) return "unknown";
+	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":
+		case "number": return "number";
+		case "boolean": return "boolean";
+		case "null": return "null";
+		case "string": return "string";
+		default: return "unknown";
+	}
+}
+//#endregion
+//#region src/plugin.ts
+const HTTP_CLIENT_DEFAULTS = {
+	module: "#/integrations/http",
+	jsonFunction: "requestJson",
+	voidFunction: "requestVoid",
+	requestOptionsType: "ApiRequestOptions",
+	omitKeys: [
+		"json",
+		"method",
+		"searchParams",
+		"signal"
+	]
+};
+function resolveHttpClientConfig(config) {
+	return {
+		...HTTP_CLIENT_DEFAULTS,
+		...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, useTypeAliases) {
+	const { default: openapiTS, astToString } = await import("openapi-typescript");
+	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, useTypeAliases) {
+	return normalizedOps.map((op) => ({
+		funcName: op.entry.funcName,
+		group: op.entry.group,
+		pathTypeExpr: op.pathChannel.typeRef == null ? null : useTypeAliases ? op.pathChannel.typeRef.typeName : op.pathChannel.typeRef.sourceExpr,
+		strippedPath: op.entry.strippedPath
+	}));
+}
+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: resolveChannel(operation.bodyChannel, useTypeAliases),
+			builderAlias: operation.builderAlias,
+			funcName: operation.entry.funcName,
+			group: operation.entry.group,
+			methodUpper: operation.entry.method.toUpperCase(),
+			optionTypeName: operation.optionTypeName,
+			pathChannel: resolveChannel(operation.pathChannel, useTypeAliases),
+			pathInvocationExpr: operation.pathInvocationExpr,
+			queryChannel: resolveChannel(operation.queryChannel, useTypeAliases),
+			requestFunction: operation.requestFunction,
+			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, 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) {
+	if (isHttpUrl(input)) {
+		const sourceText = await fetchRemoteOpenAPIInput(input);
+		return {
+			apiTypesSource: sourceText,
+			spec: parseOpenAPISpec(sourceText, input)
+		};
+	}
+	const inputPath = resolve(root, input);
+	const sourceText = readFileSync(inputPath, "utf-8");
+	return {
+		apiTypesSource: pathToFileURL(inputPath),
+		spec: parseOpenAPISpec(sourceText, inputPath)
+	};
+}
+function isHttpUrl(value) {
+	try {
+		const url = new URL(value);
+		return url.protocol === "http:" || url.protocol === "https:";
+	} catch {
+		return false;
+	}
+}
+async function fetchRemoteOpenAPIInput(input) {
+	const response = await fetch(input);
+	if (!response.ok) throw new Error(`[openapi-codegen] Failed to fetch OpenAPI document from ${input}: ${response.status} ${response.statusText}`);
+	return response.text();
+}
+function parseOpenAPISpec(sourceText, inputLabel) {
+	const parsed = parse(sourceText);
+	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error(`[openapi-codegen] Expected OpenAPI document object from ${inputLabel}`);
+	return parsed;
+}
+async function generateOpenAPIArtifacts(root, options) {
+	const outputDir = resolve(root, options.output);
+	mkdirSync(outputDir, { recursive: true });
+	const { apiTypesSource, spec } = await loadOpenAPIInput(root, options.input);
+	const operations = collectOperations(spec, options.pathPrefix ?? "/api/", options.stripPrefix ?? true);
+	const artifacts = renderGeneratedArtifacts(spec, options, operations);
+	warnOnParameterLocationMismatch(operations);
+	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);
+}
+//#endregion
+//#region src/cli.ts
+const CONFIG_FILE_NAMES = [
+	"vite.config.ts",
+	"vite.config.mts",
+	"vite.config.js",
+	"vite.config.mjs",
+	"vite.config.cjs",
+	"vite.config.cts"
+];
+async function main(argv) {
+	const flags = parseArgs(argv);
+	if (flags.help) {
+		printHelp();
+		return;
+	}
+	const root = resolve(process.cwd(), flags.root ?? ".");
+	const options = mergeOptions(await loadOptionsFromViteConfig(root, flags.config), createOptionsFromFlags(flags));
+	if (!options.input || !options.output) throw new Error("[openapi-codegen] Missing required options. Provide --input and --output or configure openapiCodegen() in vite.config.");
+	await generateOpenAPIArtifacts(root, options);
+	console.log(`[openapi-codegen] generated files in ${resolve(root, options.output)}`);
+}
+function parseArgs(argv) {
+	const flags = {};
+	for (let index = 0; index < argv.length; index++) {
+		const arg = argv[index];
+		const [name, inlineValue] = arg.split("=", 2);
+		switch (name) {
+			case "--config":
+				flags.config = readValue(argv, ++index, inlineValue, name);
+				break;
+			case "--help":
+			case "-h":
+				flags.help = true;
+				break;
+			case "--http-client-json-function":
+				flags.httpClientJsonFunction = readValue(argv, ++index, inlineValue, name);
+				break;
+			case "--http-client-module":
+				flags.httpClientModule = readValue(argv, ++index, inlineValue, name);
+				break;
+			case "--http-client-omit-keys":
+				flags.httpClientOmitKeys = parseCommaList(readValue(argv, ++index, inlineValue, name));
+				break;
+			case "--http-client-request-options-type":
+				flags.httpClientRequestOptionsType = readValue(argv, ++index, inlineValue, name);
+				break;
+			case "--http-client-void-function":
+				flags.httpClientVoidFunction = readValue(argv, ++index, inlineValue, name);
+				break;
+			case "--input":
+				flags.input = readValue(argv, ++index, inlineValue, name);
+				break;
+			case "--output":
+				flags.output = readValue(argv, ++index, inlineValue, name);
+				break;
+			case "--path-prefix":
+				flags.pathPrefix = readValue(argv, ++index, inlineValue, name);
+				break;
+			case "--root":
+				flags.root = readValue(argv, ++index, inlineValue, name);
+				break;
+			case "--strip-prefix":
+				flags.stripPrefix = parseBoolean(readValue(argv, ++index, inlineValue, name), name);
+				break;
+			case "--type-aliases":
+				flags.typeAliases = true;
+				break;
+			case "--no-strip-prefix":
+				flags.stripPrefix = false;
+				break;
+			case "--no-type-aliases":
+				flags.typeAliases = false;
+				break;
+			default: throw new Error(`[openapi-codegen] Unknown option: ${arg}`);
+		}
+		if (inlineValue !== void 0) index--;
+	}
+	return flags;
+}
+function readValue(argv, index, inlineValue, name) {
+	if (inlineValue !== void 0) return inlineValue;
+	const value = argv[index];
+	if (!value || value.startsWith("--")) throw new Error(`[openapi-codegen] Missing value for ${name}`);
+	return value;
+}
+function parseBoolean(value, name) {
+	if (value === "true") return true;
+	if (value === "false") return false;
+	throw new Error(`[openapi-codegen] Expected ${name} to be true or false`);
+}
+function parseCommaList(value) {
+	if (value.length === 0) return [];
+	return value.split(",").map((item) => item.trim()).filter(Boolean);
+}
+async function loadOptionsFromViteConfig(root, configPath) {
+	const resolvedConfigPath = resolveViteConfigPath(root, configPath);
+	if (!resolvedConfigPath) return {};
+	return extractOpenAPICodegenOptions((await loadConfigFromFile({
+		command: "serve",
+		mode: "development"
+	}, resolvedConfigPath, root, "silent"))?.config.plugins) ?? {};
+}
+function resolveViteConfigPath(root, configPath) {
+	if (configPath) {
+		const resolved = resolve(root, configPath);
+		if (!existsSync(resolved)) throw new Error(`[openapi-codegen] Vite config not found: ${resolved}`);
+		return resolved;
+	}
+	return CONFIG_FILE_NAMES.map((fileName) => resolve(root, fileName)).find((filePath) => existsSync(filePath));
+}
+function extractOpenAPICodegenOptions(plugins) {
+	return flattenPlugins(plugins).find(isOpenAPICodegenPlugin)?.api?.options;
+}
+function flattenPlugins(value) {
+	if (!Array.isArray(value)) return [];
+	return value.flatMap((plugin) => {
+		if (Array.isArray(plugin)) return flattenPlugins(plugin);
+		if (!plugin || typeof plugin !== "object") return [];
+		return [plugin];
+	});
+}
+function isOpenAPICodegenPlugin(plugin) {
+	return plugin.name === "openapi-codegen" && Boolean(plugin.api?.options);
+}
+function createOptionsFromFlags(flags) {
+	const httpClient = createHttpClientConfigFromFlags(flags);
+	return {
+		...flags.input ? { input: flags.input } : {},
+		...flags.output ? { output: flags.output } : {},
+		...flags.pathPrefix ? { pathPrefix: flags.pathPrefix } : {},
+		...flags.stripPrefix !== void 0 ? { stripPrefix: flags.stripPrefix } : {},
+		...flags.typeAliases !== void 0 ? { typeAliases: flags.typeAliases } : {},
+		...httpClient ? { httpClient } : {}
+	};
+}
+function createHttpClientConfigFromFlags(flags) {
+	const httpClient = {
+		...flags.httpClientModule ? { module: flags.httpClientModule } : {},
+		...flags.httpClientJsonFunction ? { jsonFunction: flags.httpClientJsonFunction } : {},
+		...flags.httpClientVoidFunction ? { voidFunction: flags.httpClientVoidFunction } : {},
+		...flags.httpClientRequestOptionsType ? { requestOptionsType: flags.httpClientRequestOptionsType } : {},
+		...flags.httpClientOmitKeys ? { omitKeys: flags.httpClientOmitKeys } : {}
+	};
+	return Object.keys(httpClient).length > 0 ? httpClient : void 0;
+}
+function mergeOptions(configOptions, explicitOptions) {
+	return {
+		...configOptions,
+		...explicitOptions,
+		httpClient: configOptions.httpClient || explicitOptions.httpClient ? {
+			...configOptions.httpClient,
+			...explicitOptions.httpClient
+		} : void 0
+	};
+}
+function printHelp() {
+	console.log(`Usage: vg [options]
+
+Generate OpenAPI client files once.
+
+Options:
+  --input <path-or-url>                    OpenAPI JSON/YAML input
+  --output <dir>                           Generated output directory
+  --root <dir>                             Project root, defaults to cwd
+  --config <file>                          Vite config path, defaults to vite.config.*
+  --path-prefix <prefix>                   Path prefix filter
+  --strip-prefix <true|false>              Strip path prefix from generated paths
+  --no-strip-prefix                        Disable path prefix stripping
+  --type-aliases                           Enable top-level generated type aliases
+  --no-type-aliases                        Disable top-level generated type aliases
+  --http-client-module <module>            Runtime HTTP module import path
+  --http-client-json-function <name>       JSON request function name
+  --http-client-void-function <name>       Void request function name
+  --http-client-request-options-type <name> Request options type name
+  --http-client-omit-keys <keys>           Comma-separated keys omitted from request options
+  -h, --help                               Show help
+`);
+}
+main(process.argv.slice(2)).catch((error) => {
+	console.error(error instanceof Error ? error.message : error);
+	process.exitCode = 1;
+});
+//#endregion
+export {};