@sebspark/openapi-typegen 5.0.5 → 5.0.7

package/dist/index.js

@@ -1,1087 +0,0 @@
-// src/index.ts
-import { mkdir, readdir, readFile, stat, writeFile } from "fs/promises";
-import { parse, resolve } from "path";
-import { pascalCase as pascalCase2 } from "change-case";
-import * as YAML from "yaml";
-
-// src/generator/formatter.ts
-import { format as pFormat } from "prettier";
-var options = {
-  parser: "typescript",
-  singleQuote: true,
-  semi: false,
-  trailingComma: "all"
-};
-var format = async (code) => pFormat(code, options);
-
-// src/generator/common.ts
-import { constantCase, pascalCase } from "change-case";
-
-// src/generator/document.ts
-var 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 "";
-};
-var documentClientPath = (path, responses) => documentPath(
-  path,
-  responses,
-  [param("url", "string")],
-  [param("opts", "RequestOptions", true)]
-);
-var documentServerPath = (path, responses) => documentPath(path, responses);
-var 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");
-};
-var 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;
-};
-var buildPath = (path, property) => rxProperVariable.test(property) ? `${path}.${property}` : `${path}["${property}"]`;
-var 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;
-};
-var 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;
-};
-var 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("");
-};
-
-// src/generator/common.ts
-var OR = " | ";
-var AND = " & ";
-var 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, "");
-};
-var generateProperty = (property) => {
-  const types = property.type.map(generateType);
-  return `${document(property)}${propertyName(property.name)}${property.optional ? "?" : ""}: ${types.join(OR) || "unknown"}`;
-};
-var preamble = (type) => type.name ? `${document(type)}export type ${typeName(type.name)} = ` : "";
-var rxProperVariable = /^[a-zA-Z_<>$][a-zA-Z0-9_<>$]*$/;
-var 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;
-};
-var 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);
-};
-var propertyName = (name) => {
-  if (rxProperVariable.test(name.replace(/\./g, "_")))
-    return name.replace(/\./g, "_");
-  return `'${name.replace(/\./g, "_")}'`;
-};
-var extensions = (type) => (type.allOf || []).map(generateType).concat("").join(AND) + (type.oneOf || []).map(generateType).concat("").join(OR);
-var generatePrimitive = (parsed) => `${preamble(parsed)}${parsed.type}`;
-var generateCustom = (parsed) => `${preamble(parsed)}${typeName(parsed.type)}`;
-var generateUnknown = (parsed) => `${preamble(parsed)}unknown`;
-var 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");
-};
-var generateRecord = (parsed) => {
-  const itemType = parsed.items.type === "undefined" ? "unknown" : generateType(parsed.items);
-  return `Record<string, ${itemType}>`;
-};
-var 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");
-};
-var 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");
-};
-var 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)}`;
-};
-var generateHeader = (header) => {
-  return `${preamble(header)}{ ${propertyName(header.name)}${header.optional ? "?" : ""}: ${generateType(header.type)} }`;
-};
-var 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("");
-};
-var 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)}>` };
-    }
-  }
-};
-var generateHeaders = (headers) => {
-  const tokens = [];
-  for (const header of headers) {
-    tokens.push(
-      `${propertyName(header.name)}${header.optional ? "?" : ""}: ${generateType(header.type)}`
-    );
-  }
-  return `{${tokens.join(", ")}}`;
-};
-var serializeValue = (value) => {
-  if (typeof value === "string") return `'${value}'`;
-  return value;
-};
-
-// src/generator/args.ts
-var generateClientArgs = (args) => generateArgs(args, false);
-var generateServerArgs = (args) => args ? generateArgs(args, true) : "args: Req";
-var parts = ["body", "header", "path", "query"];
-var 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 "";
-    const optional = argsOptional(args);
-    return `args${optional ? "?" : ""}: ${isServer ? "Req & " : ""}{ ${tokens.join(", ")} }, `;
-  }
-  return "";
-};
-var wrapArgs = (args, wrap) => {
-  if (!wrap) return args;
-  return `LowerCaseHeaders<${args}>`;
-};
-var argsOptional = (args) => (
-  // biome-ignore lint/style/noNonNullAssertion: will never be null
-  parts.reduce((o, p) => o && (!args[p] || args[p].optional), true)
-);
-
-// src/generator/client.ts
-var 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");
-};
-var generateCall = (path) => {
-  const responses = generateResponses(path);
-  return `${documentClientPath(path, responses)}
-  (
-    url: '${path.url}', ${generateClientArgs(path.args)}opts?: RequestOptions,
-  ): Promise<${responses}>`;
-};
-var generateResponses = (path) => Object.entries(path.responses).filter(([code]) => Number.parseInt(code, 10) < 400).map(([, type]) => generateResponseBody(type, false)).join(OR);
-
-// src/generator/server.ts
-var 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");
-};
-var groupPathsByUrl = (paths) => paths.reduce(
-  (group, path) => {
-    if (!group[path.url]) group[path.url] = [];
-    group[path.url].push(path);
-    return group;
-  },
-  {}
-);
-var generatePath = (url, methods) => `'${url}': {
-    ${methods.map(generateMethod).join("\n")}
-  }`;
-var generateMethod = (path) => {
-  const responses = generateResponses2(path.responses);
-  return `${path.method}: {
-      ${documentServerPath(path, responses)}
-      handler: (${generateServerArgs(path.args)}) => Promise<${responses}>
-      pre?: GenericRouteHandler | GenericRouteHandler[]
-    }`;
-};
-var generateResponses2 = (responses) => Object.entries(responses).filter(([code]) => Number.parseInt(code, 10) < 500).map(
-  ([code, response]) => generateResponse(Number.parseInt(code, 10), response)
-).join(OR);
-var generateResponse = (code, response) => `[${code}, ${generateResponseBody(response)}]`;
-
-// src/generator/generator.ts
-var generate = (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) : ""}
-
-`;
-var 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 param2 of components.parameters) {
-    tokens.push(
-      generateType({
-        type: "object",
-        name: param2.name,
-        properties: [
-          {
-            name: param2.parameterName,
-            type: [param2.type],
-            optional: param2.optional
-          }
-        ]
-      })
-    );
-  }
-  for (const req of components.requestBodies) {
-    tokens.push(generateType(req));
-  }
-  for (const res of components.responseBodies) {
-    tokens.push(generateResponseBody(res));
-  }
-  for (const param2 of components.securitySchemes) {
-    tokens.push(
-      generateType({
-        type: "object",
-        name: param2.name,
-        properties: [
-          {
-            name: param2.parameterName,
-            type: [param2.type],
-            optional: param2.optional
-          }
-        ]
-      })
-    );
-  }
-  return tokens.join("\n\n");
-};
-
-// src/parser/common.ts
-var parseRef = (ref) => ref.substring(ref.lastIndexOf("/") + 1);
-var parseEnumType = (name, schema) => ({ name, type: "enum", values: schema.enum || [] });
-var 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];
-};
-var parseDocumentation = (source) => {
-  const documented = {};
-  if (source.title) documented.title = source.title;
-  if (source.description) documented.description = source.description;
-  return documented;
-};
-
-// src/parser/schema.ts
-var parseSchemas = (schemas = {}) => Object.entries(schemas || {}).map(
-  ([name, schema]) => parseSchema(name, schema)
-);
-var marshall = (type, format2) => {
-  if (type === "integer") {
-    return "number";
-  }
-  if (type === "string" && (format2 === "date" || format2 === "date-time")) {
-    return "Date";
-  }
-  return type;
-};
-var parseSchema = (name, schemaOrRef, generateDocs2 = 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, generateDocs2)[0];
-    default:
-      return parseObjectSchema(name, schema);
-  }
-};
-var parseObjectSchema = (name, schema) => {
-  const type = {
-    name,
-    type: "object",
-    properties: [],
-    ...parseDocumentation(schema)
-  };
-  if (schema.properties) {
-    type.properties = Object.entries(schema.properties).map(
-      ([name2, property]) => parseProperty(name2, 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;
-};
-var parseAdditionalProperties = (schema) => {
-  let items;
-  if (schema === true) {
-    items = { type: "undefined" };
-  } else {
-    items = parseSchema(void 0, schema);
-  }
-  return {
-    type: "record",
-    items
-  };
-};
-var 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)
-  };
-};
-var parseProperty = (name, schema, required) => {
-  const property = {
-    name,
-    optional: !required.includes(name),
-    type: parsePropertyType(schema),
-    ...parseDocumentation(schema)
-  };
-  return property;
-};
-var parsePropertyType = (property, generateDocs2 = true) => {
-  const ref = property.$ref;
-  if (ref) {
-    return [{ type: parseRef(ref) }];
-  }
-  const schemaObject = property;
-  const docs = generateDocs2 ? parseDocumentation(schemaObject) : {};
-  if (schemaObject.enum) {
-    const enumType = {
-      type: "enum",
-      values: schemaObject.enum,
-      ...docs
-    };
-    return [enumType];
-  }
-  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 [];
-};
-
-// src/parser/headers.ts
-var parseHeaders = (schemas = {}) => Object.entries(schemas || {}).map(
-  ([name, schema]) => parseHeader(name, schema)
-);
-var parseHeader = (name, schema) => {
-  const header = {
-    name,
-    optional: !schema.required,
-    // biome-ignore lint/style/noNonNullAssertion: here it is always defined
-    type: parseSchema(void 0, schema.schema),
-    ...parseDocumentation(schema)
-  };
-  return header;
-};
-
-// src/parser/parameters.ts
-var parseParameters = (schemas = {}) => Object.entries(schemas || {}).map(
-  ([name, schema]) => parseParameter(name, schema)
-);
-var parseParameter = (name, schema) => {
-  const param2 = {
-    name,
-    in: schema.in,
-    parameterName: schema.name,
-    optional: !schema.required,
-    // biome-ignore lint/style/noNonNullAssertion: schema is always defined here
-    type: parseSchema(void 0, schema.schema),
-    ...parseDocumentation(schema)
-  };
-  return param2;
-};
-
-// src/parser/args.ts
-var parseArgs = (path, components) => {
-  if (!path.parameters?.length && !path.security?.length && !path.requestBody)
-    return void 0;
-  const args = joinArgs([
-    parseParameters2(path.parameters, components),
-    parseSecurity(path.security, components),
-    parseRequestBody(path.requestBody, components)
-  ]);
-  return args;
-};
-var createArgs = (initializer = {}) => ({
-  type: "object",
-  properties: [],
-  optional: true,
-  ...initializer
-});
-var 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;
-};
-var 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;
-};
-var parseSecurity = (security = [], components = {}) => {
-  const args = {};
-  for (const secReq of security) {
-    for (const [name] of Object.entries(secReq)) {
-      const param2 = findRef(
-        components,
-        `#/components/securitySchemes/${name}`
-      );
-      const arg = args.header || createArgs({ ...parseDocumentation(param2) });
-      arg.optional = false;
-      if (!arg.allOf) arg.allOf = [];
-      arg.allOf.push({ type: parseRef(name) });
-      args.header = arg;
-    }
-  }
-  return args;
-};
-var parseParameters2 = (parameters = [], components = {}) => {
-  const args = {};
-  for (const p of parameters) {
-    const ref = p.$ref;
-    if (ref) {
-      const part = ref.split("/")[2];
-      switch (part) {
-        case "parameters": {
-          const param2 = findRef(components, ref);
-          const arg = args[param2.in] || createArgs({ ...parseDocumentation(param2) });
-          arg.optional = arg.optional && !param2.required;
-          if (!arg.allOf) arg.allOf = [];
-          arg.allOf.push({ type: parseRef(ref) });
-          args[param2.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,
-            // biome-ignore lint/style/noNonNullAssertion: schema is never null here
-            type: [{ type: parseSchema(void 0, header.schema).type }],
-            ...parseDocumentation(header.schema || {})
-          });
-          args.header = arg;
-          break;
-        }
-      }
-    } else {
-      const param2 = p;
-      const arg = args[param2.in] || createArgs({ ...parseDocumentation(param2) });
-      arg.properties.push({
-        name: param2.name,
-        optional: !param2.required,
-        type: [parseSchema(void 0, param2.schema)]
-      });
-      arg.optional = arg.optional && !param2.required;
-      args[param2.in] = arg;
-    }
-  }
-  return args;
-};
-var parseRequestBody = (requestBody, components = {}) => {
-  const args = {};
-  if (!requestBody) return args;
-  const ref = requestBody.$ref;
-  if (ref) {
-    const refBody = findRef(components, ref);
-    args.body = createArgs({
-      optional: !refBody.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;
-};
-
-// src/parser/responseBodies.ts
-var parseResponseBodies = (responses = {}) => {
-  const bodies = [];
-  for (const [name, b] of Object.entries(responses)) {
-    const body = parseResponseBody(name, b);
-    bodies.push(body);
-  }
-  return bodies;
-};
-var 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 ref2 = header.$ref;
-      if (ref2)
-        body.headers.push({
-          name: headerName,
-          optional: false,
-          type: { type: parseRef(ref2) },
-          ...parseDocumentation(header)
-        });
-      else body.headers.push(parseHeader(headerName, header));
-    }
-  }
-  return body;
-};
-
-// src/parser/paths.ts
-var parsePaths = (doc) => Object.entries(doc.paths || {}).flatMap(
-  ([name, path]) => parsePath(name, path, doc.components)
-);
-var parsePath = (url, path, components) => {
-  const paths = [];
-  const methods = ["delete", "get", "patch", "post", "put"];
-  for (const method of methods) {
-    if (path[method]) {
-      paths.push(
-        parseMethod(url, method, path[method], components)
-      );
-    }
-  }
-  return paths;
-};
-var parseMethod = (url, method, operation, components) => {
-  return {
-    method,
-    url: parseUrl(url),
-    responses: parseResponses(operation.responses),
-    args: parseArgs(operation, components),
-    ...parseDocumentation(operation)
-  };
-};
-var parseUrl = (url) => url.replace(/{([^}]+)}/g, ":$1");
-var parseResponses = (responses) => {
-  return Object.assign(
-    {},
-    ...Object.entries(responses).map(([code, response]) => {
-      return {
-        [Number.parseInt(code, 10)]: parseResponseBody(void 0, response)
-      };
-    })
-  );
-};
-
-// src/parser/requestBodies.ts
-var 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;
-};
-
-// src/parser/securitySchemes.ts
-var parseSecuritySchemes = (schemes = {}) => {
-  const parameters = [];
-  for (const [name, scheme] of Object.entries(schemes)) {
-    parameters.push(parseSecurityScheme(name, scheme));
-  }
-  return parameters;
-};
-var 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}'`);
-};
-var parseApiKey = (name, scheme) => {
-  const _in = scheme.in || "header";
-  const parameterName = scheme.name;
-  return {
-    name,
-    parameterName,
-    in: _in,
-    optional: false,
-    type: { type: "string" }
-  };
-};
-var parseHttpSecurity = (name, _scheme) => ({
-  name,
-  in: "header",
-  parameterName: "Authorization",
-  optional: false,
-  type: { type: "string" }
-});
-var parseOAuth = (name, _scheme) => ({
-  name,
-  in: "header",
-  parameterName: "Authorization",
-  optional: false,
-  type: { type: "string" }
-});
-var parseOpenIdConnect = (name, _scheme) => ({
-  name,
-  in: "header",
-  parameterName: "Authorization",
-  optional: false,
-  type: { type: "string" }
-});
-
-// src/parser/index.ts
-var parseDocument = (schema) => ({
-  paths: parsePaths(schema),
-  components: parseComponents(schema.components)
-});
-var 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)
-});
-
-// src/index.ts
-var generateTypescript = async (name, doc) => {
-  const parsed = parseDocument(doc);
-  const generated = generate(name, parsed);
-  const formatted = await format(generated);
-  return formatted;
-};
-var generate2 = async (input, output) => {
-  const docs = await readDocs(input);
-  const generated = await generateDocs(docs);
-  if (!output) return generated.map((d) => d.ts).join("\n\n");
-  await saveDocs(output, generated);
-};
-var 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;
-};
-var 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;
-};
-var saveDocs = async (output, docs) => {
-  const stats = await stat(output);
-  const dir = stats.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");
-  }
-};
-var classname = (name) => {
-  return pascalCase2(name.replace(/\d+/g, ""));
-};
-var filename = (name) => {
-  return name.replace(/\./g, "_");
-};
-export {
-  classname,
-  filename,
-  generate2 as generate,
-  generateTypescript
-};
-//# sourceMappingURL=index.js.map