@spec2ts/openapi-client 3.1.3 → 4.0.1

package/README.md

@@ -8,15 +8,16 @@
 
 ## Features
 
-* **AST-based:** Unlike other code generators `@spec2ts/openapi-client` does not use templates to generate code but uses TypeScript's built-in API to generate and pretty-print an abstract syntax tree.
-* **Tree-shakeable:** Individually exported types allows you to bundle only the ones you actually use.
-* **YAML or JSON:** Use YAML or JSON for your OpenAPI v3 specification.
-* **External references:** Resolves automatically external references and bundle or import them in generated files.
-* **Implementation agnostic:** Use generated types in any projet or framework.
+- **AST-based:** Unlike other code generators `@spec2ts/openapi-client` does not use templates to generate code but uses TypeScript's built-in API to generate and pretty-print an abstract syntax tree.
+- **Tree-shakeable:** Individually exported types allows you to bundle only the ones you actually use.
+- **YAML or JSON:** Use YAML or JSON for your OpenAPI v3 specification.
+- **External references:** Resolves automatically external references and bundle or import them in generated files.
+- **Implementation agnostic:** Use generated types in any projet or framework.
 
 ## Installation
 
 Install in your project:
+
 ```bash
 npm install @spec2ts/openapi-client
 ```
@@ -65,9 +66,11 @@ async function generate(path: string): Promise<string> {
 ## Compatibility Matrix
 
 | TypeScript version | spec2ts version |
-|--------------------|-----------------|
-| v3.x.x             | v1              | 
-| v4.x.x             | v2              | 
+| ------------------ | --------------- |
+| v3.x.x             | v1              |
+| v4.x.x             | v2              |
+| v5.x.x             | v3              |
+| v6.x.x             | v4              |
 
 ## License
 

package/dist/bin/oapi2tsclient.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/bin/oapi2tsclient.mjs

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+import { i as usage, n as describe, r as handler, t as builder } from "../command-C4XUi5ys.mjs";
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+//#region src/bin/oapi2tsclient.ts
+yargs(hideBin(process.argv)).command(usage, describe, builder, handler).help("help", "Show help usage").demandCommand().argv;
+//#endregion
+export {};

package/dist/cli/index.d.mts

@@ -0,0 +1,24 @@
+import { t as OApiGeneratorOptions } from "../openapi-generator-B6yW0z4d.mjs";
+import { Argv } from "yargs";
+//#region src/cli/command.d.ts
+interface BuildClientFromOpenApiOptions extends OApiGeneratorOptions {
+  input: string | string[];
+  output?: string;
+  banner?: string;
+  importFetchVersion?: string;
+  importFormDataVersion?: string;
+  packageName?: string;
+  packageVersion?: string;
+  packageAuthor?: string;
+  packageLicense?: string;
+  packagePrivate?: boolean;
+  packageBuildTarget?: string;
+  packageBuildModule?: string;
+  packageBuildModuleResolution?: string;
+}
+declare const usage = "$0 <input..>";
+declare const describe = "Generate TypeScript HTTP client from OpenAPI specification";
+declare function builder(argv: Argv): Argv<BuildClientFromOpenApiOptions>;
+declare function handler(options: BuildClientFromOpenApiOptions): Promise<void>;
+//#endregion
+export { BuildClientFromOpenApiOptions, builder, describe, handler, usage };

package/dist/cli/index.mjs

@@ -0,0 +1,2 @@
+import { i as usage, n as describe, r as handler, t as builder } from "../command-C4XUi5ys.mjs";
+export { builder, describe, handler, usage };

package/dist/command-C4XUi5ys.mjs

@@ -0,0 +1,143 @@
+import { n as generateClientFromFile } from "./openapi-generator-IB_huQ-a.mjs";
+import { cli, printer } from "@spec2ts/core";
+import path from "node:path";
+import fs from "node:fs/promises";
+//#region src/cli/command.ts
+const usage = "$0 <input..>";
+const describe = "Generate TypeScript HTTP client from OpenAPI specification";
+function builder(argv) {
+	return argv.positional("input", {
+		array: true,
+		type: "string",
+		describe: "Path to OpenAPI Specification(s) to convert to TypeScript HTTP client",
+		demandOption: true
+	}).option("output", {
+		type: "string",
+		alias: "o",
+		describe: "Output file for generated client"
+	}).option("cwd", {
+		type: "string",
+		alias: "c",
+		describe: "Root directory for resolving $refs"
+	}).option("baseUrl", {
+		type: "string",
+		describe: "Base url of the server"
+	}).option("prefix", {
+		type: "string",
+		describe: "Only generate paths with this prefix"
+	}).option("avoidAny", {
+		type: "boolean",
+		describe: "Avoid the `any` type and use `unknown` instead"
+	}).option("enableDate", {
+		choices: [
+			true,
+			"strict",
+			"lax"
+		],
+		describe: "Build `Date` for format `date` and `date-time`"
+	}).option("inlineRequired", {
+		type: "boolean",
+		describe: "Create a method argument for each required parameter"
+	}).option("importFetch", {
+		choices: [
+			"node-fetch",
+			"cross-fetch",
+			"isomorphic-fetch"
+		],
+		describe: "Use a custom fetch implementation"
+	}).option("typesPath", {
+		type: "string",
+		describe: "Generate client types in external file relative to the output file"
+	}).option("importFetchVersion", {
+		type: "string",
+		describe: "Use a custom fetch implementation version"
+	}).option("importFormDataVersion", {
+		type: "string",
+		describe: "Use a custom form-data implementation version"
+	}).option("packageName", {
+		type: "string",
+		describe: "Generate a package.json with given name"
+	}).option("packageVersion", {
+		type: "string",
+		describe: "Set the version of the package.json"
+	}).option("packageAuthor", {
+		type: "string",
+		describe: "Set the author of the package.json"
+	}).option("packageLicense", {
+		type: "string",
+		describe: "Set the license of the package.json"
+	}).option("packagePrivate", {
+		type: "boolean",
+		describe: "Set the package.json private"
+	}).option("packageBuildTarget", {
+		type: "string",
+		describe: "Set the TypeScript build target"
+	}).option("packageBuildModule", {
+		type: "string",
+		describe: "Set the TypeScript build module"
+	}).option("packageBuildModuleResolution", {
+		type: "string",
+		describe: "Set the TypeScript build module resolution"
+	}).option("banner", {
+		type: "string",
+		alias: "b",
+		describe: "Comment prepended to the top of each generated file"
+	});
+}
+async function handler(options) {
+	const files = await cli.findFiles(options.input);
+	for (const file of files) {
+		const output = options.output || cli.getOutputPath(file, options);
+		await cli.mkdirp(output);
+		if (options.typesPath) {
+			if (!options.typesPath.startsWith(".")) options.typesPath = "./" + options.typesPath;
+			const res = await generateClientFromFile(file, options);
+			await printFile(res.client, output, options);
+			const outputTypes = path.resolve(path.dirname(output), options.typesPath + ".ts");
+			await printFile(res.types, outputTypes, options);
+		} else await printFile(await generateClientFromFile(file, options), output, options);
+		if (options.packageName) await generatePackage(output, options);
+	}
+}
+async function printFile(file, output, options) {
+	const content = printer.printFile(file);
+	await cli.mkdirp(output);
+	await cli.writeFile(output, (options.banner || defaultBanner()) + "\n\n" + content);
+}
+function defaultBanner() {
+	return `/**
+ * DO NOT MODIFY
+ * Generated using @spec2ts/openapi-client.
+ * See https://www.npmjs.com/package/@spec2ts/openapi-client
+ */
+
+/* eslint-disable */`;
+}
+async function generatePackage(output, options) {
+	const outputDir = path.dirname(output);
+	const main = path.relative(outputDir, output);
+	const pkg = {
+		name: options.packageName,
+		version: options.packageVersion || "1.0.0",
+		description: "OpenAPI v3 client for " + options.packageName,
+		author: options.packageAuthor || "@spec2ts/openapi-client",
+		license: options.packageLicense || "UNLICENSED",
+		main: main.replace(/\.ts$/, ".js"),
+		files: ["*.js", "*.d.ts"],
+		scripts: {
+			build: `tsc ${main} --strict --target ${options.packageBuildTarget || "ES2018"} --module ${options.packageBuildModule || "node16"} --moduleResolution ${options.packageBuildModuleResolution || "node16"} --skipLibCheck`,
+			prepublishOnly: "npm run build"
+		},
+		dependencies: {},
+		devDependencies: { typescript: "^6.0.0" }
+	};
+	if (options.importFetch) {
+		pkg.dependencies[options.importFetch] = options.importFetchVersion || "*";
+		pkg.dependencies["form-data"] = options.importFormDataVersion || "*";
+		pkg.devDependencies["@types/node"] = "*";
+	}
+	if (options.packagePrivate) pkg.private = options.packagePrivate;
+	await fs.writeFile(path.join(outputDir, "package.json"), JSON.stringify(pkg, null, 2), "utf8");
+}
+//#endregion
+export { usage as i, describe as n, handler as r, builder as t };

package/dist/index.d.mts

@@ -0,0 +1,2 @@
+import { i as generateClientFromFile, n as SeparatedClientResult, r as generateClient, t as OApiGeneratorOptions } from "./openapi-generator-B6yW0z4d.mjs";
+export { OApiGeneratorOptions, SeparatedClientResult, generateClient, generateClientFromFile };

package/dist/index.mjs

@@ -0,0 +1,2 @@
+import { n as generateClientFromFile, t as generateClient } from "./openapi-generator-IB_huQ-a.mjs";
+export { generateClient, generateClientFromFile };

package/dist/openapi-generator-B6yW0z4d.d.mts

@@ -0,0 +1,25 @@
+import { ParserOptions } from "@spec2ts/jsonschema";
+import ts from "typescript";
+import { OpenAPIObject } from "openapi3-ts/oas31";
+//#region src/lib/openapi-generator.d.ts
+interface OApiGeneratorOptions extends ParserOptions {
+  inlineRequired?: boolean;
+  importFetch?: "node-fetch" | "cross-fetch" | "isomorphic-fetch";
+  typesPath?: string;
+  baseUrl?: string;
+  prefix?: string;
+}
+declare function generateClientFromFile(file: string, options: OApiGeneratorOptions & {
+  typesPath: string;
+}): Promise<SeparatedClientResult>;
+declare function generateClientFromFile(file: string, options?: OApiGeneratorOptions): Promise<ts.SourceFile>;
+declare function generateClient(spec: OpenAPIObject, options: OApiGeneratorOptions & {
+  typesPath: string;
+}): Promise<SeparatedClientResult>;
+declare function generateClient(spec: OpenAPIObject, options?: OApiGeneratorOptions): Promise<ts.SourceFile>;
+interface SeparatedClientResult {
+  client: ts.SourceFile;
+  types: ts.SourceFile;
+}
+//#endregion
+export { generateClientFromFile as i, SeparatedClientResult as n, generateClient as r, OApiGeneratorOptions as t };

package/dist/openapi-generator-IB_huQ-a.mjs

@@ -0,0 +1,414 @@
+import $RefParser from "@apidevtools/json-schema-ref-parser";
+import * as core from "@spec2ts/core";
+import { createContext, getTypeFromSchema, isReference, resolveReference } from "@spec2ts/jsonschema";
+import { getOperationName, getResponseName, parseReference } from "@spec2ts/openapi";
+import path from "node:path";
+import ts from "typescript";
+//#region src/lib/util.ts
+function camelCase(str) {
+	const words = str.match(/[A-Z\xC0-\xD6\xD8-\xDE_$]?[a-z\xDF-\xF6\xF8-\xFF_$]+|[A-Z\xC0-\xD6\xD8-\xDE_$]+(?![a-z\xDF-\xF6\xF8-\xFF_$])|\d+/g);
+	if (!words) return "";
+	let result = "";
+	const len = words.length;
+	for (let i = 0; i < len; i++) {
+		let tmp = words[i].toLowerCase();
+		if (i !== 0) tmp = tmp[0].toUpperCase() + tmp.substr(1);
+		result += tmp;
+	}
+	return result;
+}
+//#endregion
+//#region src/lib/core-parser.ts
+const methods = [
+	"GET",
+	"PUT",
+	"POST",
+	"DELETE",
+	"OPTIONS",
+	"HEAD",
+	"PATCH",
+	"TRACE"
+];
+const contentTypes = {
+	"*/*": "json",
+	"application/json": "json",
+	"application/x-www-form-urlencoded": "form",
+	"multipart/form-data": "multipart"
+};
+function parseOperation(path, item, method, operation, context) {
+	const result = {
+		name: getOperationVar(method, path, operation.operationId, context),
+		paramsVars: {},
+		args: [],
+		query: [],
+		header: [],
+		response: core.keywordType.void
+	};
+	parseArgs(result, item, operation, context);
+	parseResponses(result, path, method, operation, context);
+	return result;
+}
+function parseArgs(result, item, operation, context) {
+	parseParameters(result, item, operation, context);
+	if (operation.requestBody) parseRequestBody(result, operation.requestBody, context);
+	result.args.push(core.createParameter("options", {
+		type: ts.factory.createTypeReferenceNode("RequestOptions", void 0),
+		questionToken: true
+	}));
+}
+function parseResponses(result, path, method, operation, context) {
+	const operationName = getOperationName(method, path, operation.operationId, context);
+	if (operation.responses) {
+		result.response = getTypeFromResponses(operationName, operation.responses, context);
+		result.responseJSON = isJSONResponse(operation.responses, context);
+		result.responseVoid = result.response === core.keywordType.void;
+	} else {
+		result.response = core.keywordType.unknown;
+		result.responseJSON = false;
+		result.responseVoid = false;
+	}
+}
+function parseParameters(result, item, operation, context) {
+	const parameters = fixDeepObjects([...resolveReferences(item.parameters, context), ...resolveReferences(operation.parameters, context)]);
+	result.query = parameters.filter((p) => p.in === "query");
+	result.header = parameters.filter((p) => p.in === "header");
+	const argNames = result.paramsVars = createParametersNames(parameters);
+	let objectBindingParams = parameters;
+	if (context.options.inlineRequired) {
+		const [required, optional] = splitParameters(parameters);
+		objectBindingParams = optional;
+		required.forEach((p) => {
+			result.args.push(core.createParameter(argNames[p.name], { type: getTypeFromSchema(p.schema, context) }));
+		});
+	}
+	if (!objectBindingParams.length) return;
+	result.args.push(core.createParameter(core.createObjectBinding(objectBindingParams.map(({ name }) => ({ name: argNames[name] }))), {
+		initializer: objectBindingParams.some((p) => p.required) ? void 0 : ts.factory.createObjectLiteralExpression(),
+		type: ts.factory.createTypeLiteralNode(objectBindingParams.map((p) => core.createPropertySignature({
+			name: argNames[p.name],
+			questionToken: !p.required,
+			type: getTypeFromSchema(p.schema, context)
+		})))
+	}));
+}
+function parseRequestBody(result, requestBody, context) {
+	const [schema, mode] = getSchemaFromContent(resolveReference(requestBody, context).content);
+	const type = getTypeFromSchema(schema, context);
+	const bodyVar = result.bodyVar = camelCase(type.name || getReferenceName(schema) || "body");
+	result.bodyMode = mode;
+	result.args.push(core.createParameter(bodyVar, { type }));
+}
+function createParametersNames(parameters) {
+	const argNames = {};
+	parameters.forEach(({ name }) => {
+		const stripped = camelCase(name.replace(/.+\./, ""));
+		argNames[name] = stripped in argNames ? camelCase(name) : stripped;
+	});
+	return argNames;
+}
+function splitParameters(parameters) {
+	const required = [];
+	const optional = [];
+	parameters.forEach((p) => {
+		if (p.required) required.push(p);
+		else optional.push(p);
+	});
+	return [required, optional];
+}
+function getTypeFromResponses(operationName, res, context) {
+	const codes = Object.keys(res);
+	const types = [];
+	codes.forEach((code) => {
+		const isOK = isOKResponse(code, codes.length);
+		const type = getTypeFromResponse(res[code], context);
+		if (!type) console.log(res[code]);
+		if (ts.isTypeReferenceNode(type) || core.isKeywordTypeNode(type)) {
+			if (isOK) types.push(type);
+		} else {
+			const name = getResponseName(operationName, code, context);
+			context.aliases.push(core.createTypeOrInterfaceDeclaration({
+				modifiers: [core.modifier.export],
+				name,
+				type
+			}));
+			if (isOK) types.push(ts.factory.createTypeReferenceNode(name, void 0));
+		}
+	});
+	if (types.length === 1) return types[0];
+	return ts.factory.createUnionTypeNode(types);
+}
+function isJSONResponse(responses, context) {
+	const codes = Object.keys(responses);
+	const resCode = codes.find((code) => isOKResponse(code, codes.length));
+	if (!resCode) return false;
+	const response = resolveReference(responses[resCode], context);
+	return !!response?.content?.["application/json"] || !!response?.content?.["*/*"];
+}
+function isOKResponse(code, codesCount) {
+	return codesCount === 1 || parseInt(code, 10) < 400;
+}
+function isMethod(method) {
+	return methods.includes(method);
+}
+function getTypeFromResponse(res, context) {
+	res = resolveReference(res, context);
+	if (!res?.content) return core.keywordType.void;
+	return getTypeFromSchema(getSchemaFromContent(res.content)[0], context);
+}
+function getSchemaFromContent(content) {
+	const res = Object.entries(contentTypes).find(([t]) => t in content);
+	let schema;
+	let mode;
+	if (res) {
+		const [contentType, contentMode] = res;
+		mode = contentMode;
+		schema = content?.[contentType]?.schema;
+	}
+	return [schema || { type: "string" }, mode];
+}
+function resolveReferences(array, context) {
+	return array?.map((ref) => resolveReference(ref, context)) ?? [];
+}
+function getReferenceName(obj) {
+	if (isReference(obj)) return camelCase(obj.$ref.split("/").slice(-1)[0]);
+}
+/**
+* Despite its name, OpenApi's `deepObject` serialization does not support
+* deeply nested objects. As a workaround we detect parameters that contain
+* square brackets and merge them into a single object.
+*/
+function fixDeepObjects(params) {
+	const res = [];
+	const merged = {};
+	params.forEach((p) => {
+		const m = /^(.+?)\[(.*?)\]/.exec(p.name);
+		if (!m) {
+			res.push(p);
+			return;
+		}
+		const [, name, prop] = m;
+		let obj = merged[name];
+		if (!obj) {
+			obj = merged[name] = {
+				name,
+				in: p.in,
+				style: "deepObject",
+				schema: {
+					type: "object",
+					properties: {}
+				}
+			};
+			res.push(obj);
+		}
+		obj.schema.properties[prop] = p.schema;
+	});
+	return res;
+}
+function getOperationVar(verb, path, operationId, context) {
+	const id = getOperationVarId(operationId);
+	if (id) return id;
+	return getPathVar(`${verb} ${path}`, context);
+}
+function getPathVar(path, context) {
+	path = path.replace(/\{(.+?)\}/, "by $1").replace(/\{(.+?)\}/g, "and $1");
+	let name = camelCase(path);
+	const count = context.names[name] = (context.names[name] || 0) + 1;
+	if (count > 1) name += count;
+	return name;
+}
+function getOperationVarId(id) {
+	if (!id) return;
+	if (id.match(/[^\w\s]/)) return;
+	id = camelCase(id);
+	if (core.isValidIdentifier(id)) return id;
+}
+//#endregion
+//#region src/lib/server-parser.ts
+function parseServers(servers) {
+	const props = servers.map((server, i) => [serverName(server, i), generateServerExpression(server)]);
+	return core.createObjectLiteral(props);
+}
+function defaultBaseUrl(servers) {
+	return ts.factory.createStringLiteral(defaultUrl(servers[0]));
+}
+function serverName(server, index) {
+	return server.description ? camelCase(server.description.replace(/\W+/, " ")) : `server${index + 1}`;
+}
+function generateServerExpression(server) {
+	return server.variables ? createServerFunction(server.url, server.variables) : ts.factory.createStringLiteral(server.url);
+}
+function createServerFunction(template, vars) {
+	const params = [core.createParameter(core.createObjectBinding(Object.entries(vars || {}).map(([name, value]) => {
+		return {
+			name,
+			initializer: createLiteral(value.default)
+		};
+	})), { type: ts.factory.createTypeLiteralNode(Object.entries(vars || {}).map(([name, value]) => {
+		return core.createPropertySignature({
+			name,
+			type: value.enum ? ts.factory.createUnionTypeNode(createUnion(value.enum)) : ts.factory.createUnionTypeNode([
+				core.keywordType.string,
+				core.keywordType.number,
+				core.keywordType.boolean
+			])
+		});
+	})) })];
+	return core.createArrowFunction(params, createTemplate(template));
+}
+function createUnion(strs) {
+	return strs.map((e) => ts.factory.createLiteralTypeNode(createLiteral(e)));
+}
+function createTemplate(url) {
+	const tokens = url.split(/{([\s\S]+?)}/g);
+	const spans = [];
+	const len = tokens.length;
+	for (let i = 1; i < len; i += 2) {
+		const template_factory = i === len - 2 ? ts.factory.createTemplateTail.bind(ts.factory) : ts.factory.createTemplateMiddle.bind(ts.factory);
+		spans.push(ts.factory.createTemplateSpan(ts.factory.createIdentifier(tokens[i]), template_factory(tokens[i + 1])));
+	}
+	return ts.factory.createTemplateExpression(ts.factory.createTemplateHead(tokens[0]), spans);
+}
+function createLiteral(v) {
+	switch (typeof v) {
+		case "string": return ts.factory.createStringLiteral(v);
+		case "boolean": return v ? ts.factory.createTrue() : ts.factory.createFalse();
+		case "number": return ts.factory.createNumericLiteral(String(v));
+	}
+}
+function defaultUrl(server) {
+	if (!server) return "/";
+	const { url, variables } = server;
+	if (!variables) return url;
+	return url.replace(/\{(.+?)\}/g, (m, name) => variables[name] ? String(variables[name].default) : m);
+}
+//#endregion
+//#region src/lib/core-generator.ts
+function generateServers(file, { servers }, context) {
+	servers = servers || [];
+	if (context.options.baseUrl) servers = [{ url: context.options.baseUrl }];
+	const serversConst = core.findFirstVariableStatement(file.statements, "servers");
+	const defaultsConst = core.findFirstVariableStatement(file.statements, "defaults");
+	if (!serversConst || !defaultsConst) throw new Error("Invalid template: missing servers or defaults const");
+	file = core.replaceSourceFileStatement(file, serversConst, core.updateVariableStatementValue(serversConst, "servers", parseServers(servers)));
+	file = core.replaceSourceFileStatement(file, defaultsConst, core.updateVariableStatementPropertyValue(defaultsConst, "defaults", "baseUrl", defaultBaseUrl(servers)));
+	return file;
+}
+function generateDefaults(file, context) {
+	if (context.options.importFetch) {
+		const defaultsConst = core.findFirstVariableStatement(file.statements, "defaults");
+		if (!defaultsConst) throw new Error("Invalid template: missing defaults const");
+		file = core.prependSourceFileStatements(file, core.createDefaultImportDeclaration({
+			moduleSpecifier: context.options.importFetch,
+			name: "fetch",
+			bindings: ["RequestInit", "Headers"]
+		}), core.createNamespaceImportDeclaration({
+			moduleSpecifier: "form-data",
+			name: "FormData"
+		}));
+		file = core.replaceSourceFileStatement(file, defaultsConst, core.updateVariableStatementPropertyValue(defaultsConst, "defaults", "fetch", core.toExpression("fetch")));
+	}
+	return file;
+}
+function generateFunctions(file, spec, context) {
+	const paths = Object.fromEntries(Object.entries(spec.paths ?? {}).filter(([path]) => !context.options.prefix || path.startsWith(context.options.prefix)));
+	const functions = Object.entries(paths).map(([path, pathSpec]) => {
+		const item = resolveReference(pathSpec, context);
+		return Object.entries(item).filter(([verb]) => isMethod(verb.toUpperCase())).map(([verb, entry]) => generateFunction(path, item, verb.toUpperCase(), entry, context));
+	}).flat();
+	if (context.options.typesPath && context.typesFile) {
+		context.typesFile = core.updateSourceFileStatements(context.typesFile, context.aliases);
+		file = core.updateSourceFileStatements(file, [
+			core.createNamedImportDeclaration({
+				isTypeOnly: true,
+				moduleSpecifier: context.options.typesPath,
+				bindings: context.aliases.map((a) => a.name.text)
+			}),
+			...file.statements,
+			...functions
+		]);
+	} else file = core.appendSourceFileStatements(file, ...context.aliases, ...functions);
+	return file;
+}
+function generateFunction(path, item, method, operation, context) {
+	const { name, query, header, paramsVars, args, bodyMode, bodyVar, response, responseVoid, responseJSON } = parseOperation(path, item, method, operation, context);
+	const url = generateUrl(path, generateQs(query, paramsVars));
+	const init = [ts.factory.createSpreadAssignment(ts.factory.createIdentifier("options"))];
+	if (method !== "GET") init.push(ts.factory.createPropertyAssignment("method", ts.factory.createStringLiteral(method)));
+	if (bodyVar) init.push(core.createPropertyAssignment("body", ts.factory.createIdentifier(bodyVar)));
+	if (header.length) init.push(ts.factory.createPropertyAssignment("headers", ts.factory.createObjectLiteralExpression([ts.factory.createSpreadAssignment(ts.factory.createPropertyAccessChain(ts.factory.createIdentifier("options"), core.questionDotToken, ts.factory.createIdentifier("headers"))), ...header.map(({ name }) => core.createPropertyAssignment(name, ts.factory.createIdentifier(paramsVars[name])))], true)));
+	const fetchArgs = [url];
+	if (init.length) {
+		const initObj = ts.factory.createObjectLiteralExpression(init, true);
+		fetchArgs.push(bodyMode ? callFunction("http", bodyMode, [initObj]) : initObj);
+	}
+	return core.addComment(core.createFunctionDeclaration(name, {
+		modifiers: [core.modifier.export, core.modifier.async],
+		type: ts.factory.createTypeReferenceNode("Promise", [ts.factory.createTypeReferenceNode("ApiResponse", [response])])
+	}, args, core.block(ts.factory.createReturnStatement(ts.factory.createAwaitExpression(callFunction("http", responseJSON ? "fetchJson" : responseVoid ? "fetchVoid" : "fetch", fetchArgs))))), operation.summary || operation.description);
+}
+function generateQs(parameters, paramsVars) {
+	if (!parameters.length) return;
+	const paramsByFormatter = groupByFormatter(parameters);
+	return callFunction("QS", "query", Object.entries(paramsByFormatter).map(([format, params]) => {
+		return callFunction("QS", format, [core.createObjectLiteral(params.map((p) => [p.name, paramsVars[p.name]]))]);
+	}));
+}
+function generateUrl(path, qs) {
+	const spans = [];
+	const head = path.replace(/(.*?)\{(.+?)\}(.*?)(?=\{|$)/g, (_, head, name, literal) => {
+		const expression = camelCase(name);
+		spans.push({
+			expression: ts.factory.createIdentifier(expression),
+			literal
+		});
+		return head;
+	});
+	if (qs) spans.push({
+		expression: qs,
+		literal: ""
+	});
+	return core.createTemplateString(head, spans);
+}
+function callFunction(ns, name, args) {
+	return core.createCall(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier(ns), name), { args });
+}
+function groupByFormatter(parameters) {
+	const res = {};
+	parameters.forEach((param) => {
+		const formatter = getFormatter(param);
+		res[formatter] = res[formatter] || [];
+		res[formatter].push(param);
+	});
+	return res;
+}
+function getFormatter({ style, explode }) {
+	if (style === "spaceDelimited") return "space";
+	if (style === "pipeDelimited") return "pipe";
+	if (style === "deepObject") return "deep";
+	if (style === "form") return explode === false ? "form" : "explode";
+	return explode ? "explode" : "form";
+}
+//#endregion
+//#region src/lib/openapi-generator.ts
+async function generateClientFromFile(file, options = {}) {
+	return generateClient(await $RefParser.parse(file), {
+		cwd: path.resolve(path.dirname(file)) + "/",
+		...options
+	});
+}
+async function generateClient(spec, options = {}) {
+	if (!options.parseReference) options.parseReference = parseReference;
+	const context = await createContext(spec, options);
+	let file = await core.createSourceFileFromFile(import.meta.dirname + "/templates/_client.tpl.ts");
+	if (context.options.typesPath) context.typesFile = ts.createSourceFile("types.ts", "", ts.ScriptTarget.Latest, false, ts.ScriptKind.TS);
+	file = generateServers(file, spec, context);
+	file = generateDefaults(file, context);
+	file = generateFunctions(file, spec, context);
+	if (context.options.typesPath) return {
+		client: file,
+		types: context.typesFile
+	};
+	return file;
+}
+//#endregion
+export { generateClientFromFile as n, generateClient as t };