@sebspark/openapi-typegen 5.0.5 → 5.0.7

package/dist/index.mjs

@@ -0,0 +1,893 @@
+import { mkdir, readFile, readdir, stat, writeFile } from "node:fs/promises";
+import { parse, resolve } from "node:path";
+import { constantCase, pascalCase } from "change-case";
+import * as YAML from "yaml";
+import { format } from "prettier";
+
+//#region src/generator/formatter.ts
+const options = {
+	parser: "typescript",
+	singleQuote: true,
+	semi: false,
+	trailingComma: "all"
+};
+const format$1 = async (code) => format(code, options);
+
+//#endregion
+//#region src/generator/document.ts
+const document = ({ title, description }) => {
+	if (title || description) {
+		const tokens = [];
+		tokens.push("/**");
+		if (title) tokens.push(` * ${title}`);
+		if (description) tokens.push(` * ${description}`);
+		tokens.push(" */\n");
+		return tokens.join("\n");
+	}
+	return "";
+};
+const documentClientPath = (path, responses) => documentPath(path, responses, [param("url", "string")], [param("opts", "RequestOptions", true)]);
+const documentServerPath = (path, responses) => documentPath(path, responses);
+const documentPath = (path, responses, argsBefore = [], argsAfter = []) => {
+	const tokens = [];
+	tokens.push("/**");
+	if (path.title) tokens.push(` * ${path.title}`);
+	if (path.description) tokens.push(` * ${path.description}`);
+	tokens.push(" *");
+	tokens.push(...argsBefore);
+	if (path.args) tokens.push(...documentArgs(path.args));
+	tokens.push(...argsAfter);
+	tokens.push(` * @returns {Promise<${responses}>}`);
+	tokens.push(" */");
+	return tokens.join("\n");
+};
+const documentArgs = (args) => {
+	const tokens = [];
+	tokens.push(param("args", "Object", argsOptional(args), "The arguments for the request."));
+	tokens.push(...requestArgs(args.path, "params", "Path parameters"));
+	tokens.push(...requestArgs(args.query, "query", "Query parameters"));
+	tokens.push(...requestArgs(args.header, "headers", "Headers"));
+	tokens.push(...requestArgs(args.body, "body", "Request body"));
+	return tokens;
+};
+const buildPath = (path, property) => rxProperVariable.test(property) ? `${path}.${property}` : `${path}["${property}"]`;
+const requestArgs = (args, name, title) => {
+	if (!args) return [];
+	const tokens = [];
+	const type = (args.allOf || []).map((e) => e.type).join(AND) || "Object";
+	tokens.push(param(buildPath("args", name), type, args.optional, `${title} for the request.`));
+	const properties = args.properties.flatMap((prop) => requestProperty(buildPath("args", name), prop));
+	tokens.push(...properties);
+	return tokens;
+};
+const requestProperty = (path, property) => {
+	const tokens = [];
+	const type = property.type.map((t) => t.type).join(OR);
+	tokens.push(param(buildPath(path, property.name), type, property.optional, property.title, property.description));
+	return tokens;
+};
+const param = (name, type, optional = false, title = "", description = "") => {
+	const tokens = [];
+	tokens.push(` * @param {${type}} ${optional ? "[" : ""}${name}${optional ? "]" : ""}`);
+	if (optional || title || description) {
+		tokens.push(" -");
+		if (optional) tokens.push(" Optional.");
+		if (title) tokens.push(` ${title}`);
+		if (description) tokens.push(` ${description}`);
+	}
+	return tokens.join("");
+};
+
+//#endregion
+//#region src/generator/common.ts
+const OR = " | ";
+const AND = " & ";
+const generateType = (parsed) => {
+	let type;
+	switch (parsed.type) {
+		case "enum":
+			type = generateEnum(parsed);
+			break;
+		case "array":
+			type = generateArray(parsed);
+			break;
+		case "object":
+			type = generateObject(parsed);
+			break;
+		case "record":
+			type = generateRecord(parsed);
+			break;
+		case "unknown":
+			type = generateUnknown(parsed);
+			break;
+		case "Date":
+		case "bigint":
+		case "boolean":
+		case "null":
+		case "number":
+		case "string":
+		case "symbol":
+		case "undefined":
+			type = generatePrimitive(parsed);
+			break;
+		default: type = generateCustom(parsed);
+	}
+	return type.replace(/ [&|] \{\s*\}/g, "");
+};
+const generateProperty = (property) => {
+	const types = property.type.map(generateType);
+	return `${document(property)}${propertyName(property.name)}${property.optional ? "?" : ""}: ${types.join(OR) || "unknown"}`;
+};
+const preamble = (type) => type.name ? `${document(type)}export type ${typeName(type.name)} = ` : "";
+const rxProperVariable = /^[a-zA-Z_<>$][a-zA-Z0-9_<>$]*$/;
+const isValidName = (name) => {
+	const namingConventionRegex = /^([A-Z_]\w*)([a-z_]\w*)(<([a-z_]\w*(,\s*)?)+>)?$/;
+	const hasCapitalLetterRegex = /[A-Z]/;
+	if (!namingConventionRegex.test(name)) return false;
+	if (!hasCapitalLetterRegex.test(name)) return false;
+	if (name[0] !== name[0].toUpperCase() && !name.includes("_")) return false;
+	return true;
+};
+const typeName = (name) => {
+	if (isValidName(name)) return name;
+	if (name.includes("<")) return name.replace(/<([^>]+)>/, (_match, genericContent) => `<${typeName(genericContent)}>`);
+	const domainStyleTransformed = name.split(".").map((part, index, array) => {
+		if (index === array.length - 1) return pascalCase(part);
+		return part;
+	}).join("_");
+	const prefixedIfNumberStart = domainStyleTransformed.match(/^\d/) ? `_${domainStyleTransformed}` : domainStyleTransformed;
+	const finalName = prefixedIfNumberStart.includes("_") ? prefixedIfNumberStart : pascalCase(prefixedIfNumberStart);
+	if (finalName.includes("_")) {
+		const lastUnderscoreIndex = finalName.lastIndexOf("_");
+		if (lastUnderscoreIndex !== -1 && lastUnderscoreIndex < finalName.length - 1) return finalName.substring(0, lastUnderscoreIndex + 1) + finalName.charAt(lastUnderscoreIndex + 1).toUpperCase() + finalName.slice(lastUnderscoreIndex + 2);
+		return finalName;
+	}
+	return finalName.charAt(0).toUpperCase() + finalName.slice(1);
+};
+const propertyName = (name) => {
+	if (rxProperVariable.test(name.replace(/\./g, "_"))) return name.replace(/\./g, "_");
+	return `'${name.replace(/\./g, "_")}'`;
+};
+const extensions = (type) => (type.allOf || []).map(generateType).concat("").join(AND) + (type.oneOf || []).map(generateType).concat("").join(OR);
+const generatePrimitive = (parsed) => `${preamble(parsed)}${parsed.type}`;
+const generateCustom = (parsed) => `${preamble(parsed)}${typeName(parsed.type)}`;
+const generateUnknown = (parsed) => `${preamble(parsed)}unknown`;
+const generateObject = (parsed) => {
+	const lines = [];
+	lines.push(`${preamble(parsed)}${extensions(parsed)}{`);
+	lines.push(...parsed.properties.map(generateProperty));
+	lines.push("}");
+	if (parsed.discriminator && parsed.name) lines.push(generateDiscriminator(parsed.discriminator, parsed.name));
+	return lines.join("\n");
+};
+const generateRecord = (parsed) => {
+	return `Record<string, ${parsed.items.type === "undefined" ? "unknown" : generateType(parsed.items)}>`;
+};
+const generateDiscriminator = (discriminator, name) => {
+	const lines = [""];
+	lines.push(`export type ${name}Discriminator = {`);
+	for (const [key, type] of Object.entries(discriminator.mapping)) lines.push(`${key}: ${type.type}`);
+	lines.push("}");
+	return lines.join("\n");
+};
+const generateArray = (parsed) => {
+	const lines = [];
+	let items = generateType(parsed.items);
+	if (parsed.items.type === "enum" || "oneOf" in parsed.items) items = `(${items})`;
+	lines.push(`${preamble(parsed)}${items}[]`);
+	return lines.join("\n");
+};
+const generateEnum = (parsed) => {
+	if (parsed.name) {
+		const values = parsed.values.map(serializeValue).join(", ");
+		const valuesName = constantCase(`${parsed.name}_VALUES`);
+		return [`export const ${valuesName} = [${values}] as const`, `${preamble(parsed)}typeof ${valuesName}[number]`].join("\n");
+	}
+	return `${preamble(parsed)}${parsed.values.map(serializeValue).join(OR)}`;
+};
+const generateHeader = (header) => {
+	return `${preamble(header)}{ ${propertyName(header.name)}${header.optional ? "?" : ""}: ${generateType(header.type)} }`;
+};
+const generateResponseBody = (type, optional = true) => {
+	const customType = type.type;
+	if (customType) return typeName(customType);
+	const body = type;
+	if (!body.data && !body.headers) return "undefined";
+	const tokens = [];
+	tokens.push(preamble(body));
+	tokens.push("APIResponse<");
+	tokens.push(body.data ? generateType(serialized(body.data, optional)) : "undefined");
+	if (body.headers) {
+		tokens.push(", ");
+		tokens.push(body.headers ? generateHeaders(body.headers) : "undefined");
+	}
+	tokens.push(">");
+	return tokens.join("");
+};
+const serialized = (orig, optional = true) => {
+	switch (orig.type) {
+		case "bigint":
+		case "boolean":
+		case "enum":
+		case "null":
+		case "number":
+		case "string":
+		case "symbol":
+		case "undefined": return orig;
+		case "Date": return {
+			...orig,
+			type: "string"
+		};
+		case "array": return {
+			...orig,
+			items: serialized(orig.items, optional)
+		};
+		case "object": return orig;
+		default: {
+			const wrapper = optional ? "PartiallySerialized" : "Serialized";
+			return {
+				...orig,
+				type: `${wrapper}<${typeName(orig.type)}>`
+			};
+		}
+	}
+};
+const generateHeaders = (headers) => {
+	const tokens = [];
+	for (const header of headers) tokens.push(`${propertyName(header.name)}${header.optional ? "?" : ""}: ${generateType(header.type)}`);
+	return `{${tokens.join(", ")}}`;
+};
+const serializeValue = (value) => {
+	if (typeof value === "string") return `'${value}'`;
+	return value;
+};
+
+//#endregion
+//#region src/generator/args.ts
+const generateClientArgs = (args) => generateArgs(args, false);
+const generateServerArgs = (args) => args ? generateArgs(args, true) : "args: Req";
+const parts = [
+	"body",
+	"header",
+	"path",
+	"query"
+];
+const generateArgs = (args, isServer) => {
+	if (args) {
+		const tokens = [];
+		for (const part of parts) {
+			const arg = args[part];
+			if (arg) {
+				const partName = part === "path" ? "params" : part === "header" ? "headers" : part;
+				if (partName === "query" && isServer) tokens.push(`${partName}${arg.optional ? "?" : ""}: QueryParams<${generateType(arg)}>`);
+				else tokens.push(`${partName}${arg.optional ? "?" : ""}: ${wrapArgs(generateType(arg), isServer && part === "header")}`);
+			}
+		}
+		if (!tokens.length) return "";
+		return `args${argsOptional(args) ? "?" : ""}: ${isServer ? "Req & " : ""}{ ${tokens.join(", ")} }, `;
+	}
+	return "";
+};
+const wrapArgs = (args, wrap) => {
+	if (!wrap) return args;
+	return `LowerCaseHeaders<${args}>`;
+};
+const argsOptional = (args) => parts.reduce((o, p) => o && (!args[p] || args[p].optional), true);
+
+//#endregion
+//#region src/generator/client.ts
+const generateClient = (name, paths) => {
+	const groupedCalls = {};
+	for (const path of paths) {
+		if (!groupedCalls[path.method]) groupedCalls[path.method] = [];
+		groupedCalls[path.method]?.push(generateCall(path));
+	}
+	const client = [];
+	const methods = Object.keys(groupedCalls).map(serializeValue).join(OR);
+	client.push(`export type ${name}Client = Pick<BaseClient, ${methods}> & {`);
+	Object.entries(groupedCalls).forEach(([method, calls]) => {
+		client.push(`${method}: {`);
+		client.push(...calls);
+		client.push("}");
+	});
+	client.push("}");
+	return client.join("\n");
+};
+const generateCall = (path) => {
+	const responses = generateResponses$1(path);
+	return `${documentClientPath(path, responses)}
+  (
+    url: '${path.url}', ${generateClientArgs(path.args)}opts?: RequestOptions,
+  ): Promise<${responses}>`;
+};
+const generateResponses$1 = (path) => Object.entries(path.responses).filter(([code]) => Number.parseInt(code, 10) < 400).map(([, type]) => generateResponseBody(type, false)).join(OR);
+
+//#endregion
+//#region src/generator/server.ts
+const generateServer = (name, paths) => {
+	const tokens = [];
+	tokens.push(`export type ${name}ServerPaths = {`);
+	for (const [url, methods] of Object.entries(groupPathsByUrl(paths))) tokens.push(generatePath(url, methods));
+	tokens.push("}");
+	tokens.push("\n");
+	tokens.push(`export type ${name}Server = APIServerDefinition & ${name}ServerPaths`);
+	return tokens.join("\n");
+};
+const groupPathsByUrl = (paths) => paths.reduce((group, path) => {
+	if (!group[path.url]) group[path.url] = [];
+	group[path.url].push(path);
+	return group;
+}, {});
+const generatePath = (url, methods) => `'${url}': {
+    ${methods.map(generateMethod).join("\n")}
+  }`;
+const generateMethod = (path) => {
+	const responses = generateResponses(path.responses);
+	return `${path.method}: {
+      ${documentServerPath(path, responses)}
+      handler: (${generateServerArgs(path.args)}) => Promise<${responses}>
+      pre?: GenericRouteHandler | GenericRouteHandler[]
+    }`;
+};
+const generateResponses = (responses) => Object.entries(responses).filter(([code]) => Number.parseInt(code, 10) < 500).map(([code, response]) => generateResponse(Number.parseInt(code, 10), response)).join(OR);
+const generateResponse = (code, response) => `[${code}, ${generateResponseBody(response)}]`;
+
+//#endregion
+//#region src/generator/generator.ts
+const generate$1 = (name, doc) => `
+ /**
+  * This file was auto-generated.
+  * Do not make direct changes to the file.
+  */
+
+ import type {
+   APIResponse,
+   APIServerDefinition,
+   BaseClient,
+   ExpressRequest,
+   GenericRouteHandler,
+   LowerCaseHeaders,
+   PartiallySerialized,
+   QueryParams,
+   RequestOptions,
+   Serialized,
+ } from '@sebspark/openapi-core'
+
+ type Req = Pick<ExpressRequest, 'url' | 'baseUrl' | 'cookies' | 'hostname'>
+
+ /* tslint:disable */
+ /* eslint-disable */
+
+ ${generateComponents(doc.components)}
+
+ ${doc.paths.length ? generateServer(name, doc.paths) : ""}
+
+ ${doc.paths.length ? generateClient(name, doc.paths) : ""}
+
+`;
+const generateComponents = (components) => {
+	const tokens = [];
+	for (const schema of components.schemas) tokens.push(generateType(schema));
+	for (const header of components.headers) tokens.push(generateHeader(header));
+	for (const param$1 of components.parameters) tokens.push(generateType({
+		type: "object",
+		name: param$1.name,
+		properties: [{
+			name: param$1.parameterName,
+			type: [param$1.type],
+			optional: param$1.optional
+		}]
+	}));
+	for (const req of components.requestBodies) tokens.push(generateType(req));
+	for (const res of components.responseBodies) tokens.push(generateResponseBody(res));
+	for (const param$1 of components.securitySchemes) tokens.push(generateType({
+		type: "object",
+		name: param$1.name,
+		properties: [{
+			name: param$1.parameterName,
+			type: [param$1.type],
+			optional: param$1.optional
+		}]
+	}));
+	return tokens.join("\n\n");
+};
+
+//#endregion
+//#region src/parser/common.ts
+const parseRef = (ref) => ref.substring(ref.lastIndexOf("/") + 1);
+const parseEnumType = (name, schema) => ({
+	name,
+	type: "enum",
+	values: schema.enum || []
+});
+const findRef = (components, ref) => {
+	const [, , path, name] = ref.split("/");
+	const schemaPath = components[path];
+	if (!schemaPath || !schemaPath[name]) throw new Error(`Cannot find ref ${ref}`);
+	return schemaPath[name];
+};
+const parseDocumentation = (source) => {
+	const documented = {};
+	if (source.title) documented.title = source.title;
+	if (source.description) documented.description = source.description;
+	return documented;
+};
+
+//#endregion
+//#region src/parser/schema.ts
+const parseSchemas = (schemas = {}) => Object.entries(schemas || {}).map(([name, schema]) => parseSchema(name, schema));
+const marshall = (type, format$2) => {
+	if (type === "integer") return "number";
+	if (type === "string" && (format$2 === "date" || format$2 === "date-time")) return "Date";
+	return type;
+};
+const parseSchema = (name, schemaOrRef, generateDocs$1 = true) => {
+	const ref = schemaOrRef.$ref;
+	if (ref) return {
+		name,
+		type: parseRef(ref)
+	};
+	const schema = schemaOrRef;
+	switch (schema.type) {
+		case "array": return parseArraySchema(name, schema);
+		case "boolean":
+		case "integer":
+		case "number":
+		case "string": return schema.enum ? parseEnumType(name, schema) : name ? {
+			name,
+			type: marshall(schema.type, schema.format)
+		} : parsePropertyType(schema, generateDocs$1)[0];
+		default: return parseObjectSchema(name, schema);
+	}
+};
+const parseObjectSchema = (name, schema) => {
+	const type = {
+		name,
+		type: "object",
+		properties: [],
+		...parseDocumentation(schema)
+	};
+	if (schema.properties) type.properties = Object.entries(schema.properties).map(([name$1, property]) => parseProperty(name$1, property, schema.required || []));
+	if (schema.allOf) type.allOf = schema.allOf.flatMap((s) => parsePropertyType(s));
+	if (schema.oneOf) type.oneOf = schema.oneOf.flatMap((s) => parsePropertyType(s));
+	if (schema.anyOf) type.oneOf = schema.anyOf.flatMap((s) => parsePropertyType(s));
+	if (schema.discriminator?.mapping) {
+		const mapping = {};
+		for (const [prop, ref] of Object.entries(schema.discriminator.mapping)) mapping[prop] = { type: parseRef(ref) };
+		type.discriminator = {
+			propertyName: schema.discriminator.propertyName,
+			mapping
+		};
+	}
+	if (schema.additionalProperties) {
+		const record = parseAdditionalProperties(schema.additionalProperties);
+		if (!type.allOf) type.allOf = [];
+		type.allOf.push(record);
+	}
+	return type;
+};
+const parseAdditionalProperties = (schema) => {
+	let items;
+	if (schema === true) items = { type: "undefined" };
+	else items = parseSchema(void 0, schema);
+	return {
+		type: "record",
+		items
+	};
+};
+const parseArraySchema = (name, schema) => {
+	if (schema.type !== "array") throw new Error("Not an array");
+	return {
+		name,
+		type: "array",
+		items: schema.items ? parseSchema(void 0, schema.items, false) : { type: "unknown" },
+		...parseDocumentation(schema)
+	};
+};
+const parseProperty = (name, schema, required) => {
+	return {
+		name,
+		optional: !required.includes(name),
+		type: parsePropertyType(schema),
+		...parseDocumentation(schema)
+	};
+};
+const parsePropertyType = (property, generateDocs$1 = true) => {
+	const ref = property.$ref;
+	if (ref) return [{ type: parseRef(ref) }];
+	const schemaObject = property;
+	const docs = generateDocs$1 ? parseDocumentation(schemaObject) : {};
+	if (schemaObject.enum) return [{
+		type: "enum",
+		values: schemaObject.enum,
+		...docs
+	}];
+	if (schemaObject.type) return (Array.isArray(schemaObject.type) ? schemaObject.type : [schemaObject.type]).map((type) => {
+		switch (type) {
+			case "array": return parseArraySchema(void 0, schemaObject);
+			case "object": return parseObjectSchema(void 0, schemaObject);
+			default: return {
+				type: marshall(type, schemaObject.format),
+				...docs
+			};
+		}
+	});
+	if (schemaObject.allOf) {
+		const types = [];
+		for (const allOf of schemaObject.allOf) {
+			const type = parseSchema(void 0, allOf);
+			delete type.name;
+			types.push(type);
+		}
+		return types;
+	}
+	return [];
+};
+
+//#endregion
+//#region src/parser/headers.ts
+const parseHeaders = (schemas = {}) => Object.entries(schemas || {}).map(([name, schema]) => parseHeader(name, schema));
+const parseHeader = (name, schema) => {
+	return {
+		name,
+		optional: !schema.required,
+		type: parseSchema(void 0, schema.schema),
+		...parseDocumentation(schema)
+	};
+};
+
+//#endregion
+//#region src/parser/parameters.ts
+const parseParameters = (schemas = {}) => Object.entries(schemas || {}).map(([name, schema]) => parseParameter(name, schema));
+const parseParameter = (name, schema) => {
+	return {
+		name,
+		in: schema.in,
+		parameterName: schema.name,
+		optional: !schema.required,
+		type: parseSchema(void 0, schema.schema),
+		...parseDocumentation(schema)
+	};
+};
+
+//#endregion
+//#region src/parser/args.ts
+const parseArgs = (path, components) => {
+	if (!path.parameters?.length && !path.security?.length && !path.requestBody) return void 0;
+	return joinArgs([
+		parseParameters$1(path.parameters, components),
+		parseSecurity(path.security, components),
+		parseRequestBody(path.requestBody, components)
+	]);
+};
+const createArgs = (initializer = {}) => ({
+	type: "object",
+	properties: [],
+	optional: true,
+	...initializer
+});
+const joinArgs = (args) => {
+	const reqArg = {};
+	for (const arg of args) for (const [prop, val] of Object.entries(arg)) {
+		const key = prop;
+		if (reqArg[key]) reqArg[key] = joinArg(reqArg[key], val);
+		else reqArg[key] = val;
+	}
+	return reqArg;
+};
+const joinArg = (arg1, arg2) => {
+	const arg = {
+		type: "object",
+		optional: arg1.optional && arg2.optional,
+		properties: arg1.properties.concat(arg2.properties)
+	};
+	if (arg1.allOf || arg2.allOf) arg.allOf = (arg1.allOf || []).concat(arg2.allOf || []);
+	if (arg1.anyOf || arg2.anyOf) arg.anyOf = (arg1.anyOf || []).concat(arg2.anyOf || []);
+	if (arg1.oneOf || arg2.oneOf) arg.oneOf = (arg1.oneOf || []).concat(arg2.oneOf || []);
+	if (arg1.description || arg2.description) arg.description = arg1.description || arg2.description;
+	if (arg1.title || arg2.title) arg.title = arg1.title || arg2.title;
+	return arg;
+};
+const parseSecurity = (security = [], components = {}) => {
+	const args = {};
+	for (const secReq of security) for (const [name] of Object.entries(secReq)) {
+		const param$1 = findRef(components, `#/components/securitySchemes/${name}`);
+		const arg = args.header || createArgs({ ...parseDocumentation(param$1) });
+		arg.optional = false;
+		if (!arg.allOf) arg.allOf = [];
+		arg.allOf.push({ type: parseRef(name) });
+		args.header = arg;
+	}
+	return args;
+};
+const parseParameters$1 = (parameters = [], components = {}) => {
+	const args = {};
+	for (const p of parameters) {
+		const ref = p.$ref;
+		if (ref) switch (ref.split("/")[2]) {
+			case "parameters": {
+				const param$1 = findRef(components, ref);
+				const arg = args[param$1.in] || createArgs({ ...parseDocumentation(param$1) });
+				arg.optional = arg.optional && !param$1.required;
+				if (!arg.allOf) arg.allOf = [];
+				arg.allOf.push({ type: parseRef(ref) });
+				args[param$1.in] = arg;
+				break;
+			}
+			case "headers": {
+				const header = findRef(components, ref);
+				const arg = args.header || createArgs();
+				const name = parseRef(ref);
+				arg.properties.push({
+					name,
+					optional: !header.required,
+					type: [{ type: parseSchema(void 0, header.schema).type }],
+					...parseDocumentation(header.schema || {})
+				});
+				args.header = arg;
+				break;
+			}
+		}
+		else {
+			const param$1 = p;
+			const arg = args[param$1.in] || createArgs({ ...parseDocumentation(param$1) });
+			arg.properties.push({
+				name: param$1.name,
+				optional: !param$1.required,
+				type: [parseSchema(void 0, param$1.schema)]
+			});
+			arg.optional = arg.optional && !param$1.required;
+			args[param$1.in] = arg;
+		}
+	}
+	return args;
+};
+const parseRequestBody = (requestBody, components = {}) => {
+	const args = {};
+	if (!requestBody) return args;
+	const ref = requestBody.$ref;
+	if (ref) args.body = createArgs({
+		optional: !findRef(components, ref).required,
+		allOf: [{ type: parseRef(ref) }]
+	});
+	else {
+		const body = requestBody;
+		const bodyArgs = args.body || createArgs({
+			optional: !body.required,
+			...parseDocumentation(body)
+		});
+		if (body.content["application/json"]) {
+			const schema = body.content["application/json"].schema;
+			if (schema) {
+				const parsed = parseSchema(void 0, schema);
+				if (parsed.type === "object") args.body = {
+					...parsed,
+					optional: !body.required
+				};
+				else if (parsed.type) args.body = createArgs({
+					optional: !body.required,
+					allOf: [parsed],
+					...parseDocumentation(body)
+				});
+			}
+		}
+		if (bodyArgs.allOf?.length || bodyArgs.oneOf?.length || bodyArgs.properties.length) args.body = bodyArgs;
+	}
+	return args;
+};
+
+//#endregion
+//#region src/parser/responseBodies.ts
+const parseResponseBodies = (responses = {}) => {
+	const bodies = [];
+	for (const [name, b] of Object.entries(responses)) {
+		const body = parseResponseBody(name, b);
+		bodies.push(body);
+	}
+	return bodies;
+};
+const parseResponseBody = (name, response) => {
+	const ref = response.$ref;
+	if (ref) return { type: parseRef(ref) };
+	const responseObject = response;
+	const body = {};
+	if (name) body.name = name;
+	if (responseObject.description) body.description = responseObject.description;
+	if (responseObject.content?.["application/json"]?.schema) {
+		const schema = responseObject.content["application/json"].schema;
+		body.data = parseSchema(void 0, schema);
+	}
+	if (responseObject.headers) {
+		body.headers = [];
+		for (const [headerName, header] of Object.entries(responseObject.headers)) {
+			const ref$1 = header.$ref;
+			if (ref$1) body.headers.push({
+				name: headerName,
+				optional: false,
+				type: { type: parseRef(ref$1) },
+				...parseDocumentation(header)
+			});
+			else body.headers.push(parseHeader(headerName, header));
+		}
+	}
+	return body;
+};
+
+//#endregion
+//#region src/parser/paths.ts
+const parsePaths = (doc) => Object.entries(doc.paths || {}).flatMap(([name, path]) => parsePath(name, path, doc.components));
+const parsePath = (url, path, components) => {
+	const paths = [];
+	for (const method of [
+		"delete",
+		"get",
+		"patch",
+		"post",
+		"put"
+	]) if (path[method]) paths.push(parseMethod(url, method, path[method], components));
+	return paths;
+};
+const parseMethod = (url, method, operation, components) => {
+	return {
+		method,
+		url: parseUrl(url),
+		responses: parseResponses(operation.responses),
+		args: parseArgs(operation, components),
+		...parseDocumentation(operation)
+	};
+};
+const parseUrl = (url) => url.replace(/{([^}]+)}/g, ":$1");
+const parseResponses = (responses) => {
+	return Object.assign({}, ...Object.entries(responses).map(([code, response]) => {
+		return { [Number.parseInt(code, 10)]: parseResponseBody(void 0, response) };
+	}));
+};
+
+//#endregion
+//#region src/parser/requestBodies.ts
+const parseRequestBodies = (requestBodies = {}) => {
+	const definitions = [];
+	for (const [name, requestBody] of Object.entries(requestBodies)) if (requestBody.content["application/json"].schema) definitions.push(parseSchema(name, requestBody.content["application/json"].schema));
+	return definitions;
+};
+
+//#endregion
+//#region src/parser/securitySchemes.ts
+const parseSecuritySchemes = (schemes = {}) => {
+	const parameters = [];
+	for (const [name, scheme] of Object.entries(schemes)) parameters.push(parseSecurityScheme(name, scheme));
+	return parameters;
+};
+const parseSecurityScheme = (name, scheme) => {
+	switch (scheme.type) {
+		case "apiKey": return parseApiKey(name, scheme);
+		case "http": return parseHttpSecurity(name, scheme);
+		case "oauth2": return parseOAuth(name, scheme);
+		case "openIdConnect": return parseOpenIdConnect(name, scheme);
+	}
+	throw new Error(`Unknown security scheme '${scheme.type}'`);
+};
+const parseApiKey = (name, scheme) => {
+	const _in = scheme.in || "header";
+	return {
+		name,
+		parameterName: scheme.name,
+		in: _in,
+		optional: false,
+		type: { type: "string" }
+	};
+};
+const parseHttpSecurity = (name, _scheme) => ({
+	name,
+	in: "header",
+	parameterName: "Authorization",
+	optional: false,
+	type: { type: "string" }
+});
+const parseOAuth = (name, _scheme) => ({
+	name,
+	in: "header",
+	parameterName: "Authorization",
+	optional: false,
+	type: { type: "string" }
+});
+const parseOpenIdConnect = (name, _scheme) => ({
+	name,
+	in: "header",
+	parameterName: "Authorization",
+	optional: false,
+	type: { type: "string" }
+});
+
+//#endregion
+//#region src/parser/index.ts
+const parseDocument = (schema) => ({
+	paths: parsePaths(schema),
+	components: parseComponents(schema.components)
+});
+const parseComponents = (components = {}) => ({
+	schemas: parseSchemas(components.schemas),
+	headers: parseHeaders(components.headers),
+	parameters: parseParameters(components.parameters),
+	requestBodies: parseRequestBodies(components.requestBodies),
+	responseBodies: parseResponseBodies(components.responses),
+	securitySchemes: parseSecuritySchemes(components.securitySchemes)
+});
+
+//#endregion
+//#region src/index.ts
+const generateTypescript = async (name, doc) => {
+	return await format$1(generate$1(name, parseDocument(doc)));
+};
+const generate = async (input, output) => {
+	const generated = await generateDocs(await readDocs(input));
+	if (!output) return generated.map((d) => d.ts).join("\n\n");
+	await saveDocs(output, generated);
+};
+const readDocs = async (input) => {
+	const path = resolve(input);
+	const stats = await stat(path);
+	const filePaths = [];
+	if (stats.isFile()) filePaths.push(path);
+	if (stats.isDirectory()) {
+		const files = await readdir(path);
+		filePaths.push(...files.map((f) => resolve(path, f)));
+	}
+	const readFiles = [];
+	for (const p of filePaths) {
+		const { name, ext } = parse(p);
+		let doc;
+		switch (ext) {
+			case ".json": {
+				console.log(`Reading ${p}`);
+				const txt = await readFile(p, "utf8");
+				doc = JSON.parse(txt);
+				break;
+			}
+			case ".yml":
+			case ".yaml": {
+				console.log(`Reading ${p}`);
+				const txt = await readFile(p, "utf8");
+				doc = YAML.parse(txt);
+				break;
+			}
+			default: continue;
+		}
+		readFiles.push({
+			doc,
+			name
+		});
+	}
+	return readFiles;
+};
+const generateDocs = async (files) => {
+	const generated = [];
+	for (const doc of files) {
+		console.log(`Generating ${doc.name}`);
+		const ts = await generateTypescript(classname(doc.name), doc.doc);
+		generated.push({
+			...doc,
+			ts
+		});
+	}
+	return generated;
+};
+const saveDocs = async (output, docs) => {
+	const dir = (await stat(output)).isDirectory() ? output : parse(output).dir;
+	await mkdir(dir, { recursive: true });
+	for (const doc of docs) {
+		const path = resolve(dir, `${filename(doc.name)}.ts`);
+		console.log(`Writing ${path}`);
+		await writeFile(path, doc.ts, "utf8");
+	}
+};
+const classname = (name) => {
+	return pascalCase(name.replace(/\d+/g, ""));
+};
+const filename = (name) => {
+	return name.replace(/\./g, "_");
+};
+
+//#endregion
+export { classname, filename, generate, generateTypescript };
+//# sourceMappingURL=index.mjs.map