typed-openapi 0.1.2 → 0.1.4

package/dist/cli.js

@@ -1,825 +1,25 @@
+import {
+  allowedRuntimes,
+  generateFile,
+  mapOpenApiEndpoints
+} from "./chunk-TUNDL3P7.js";
+
 // src/cli.ts
 import SwaggerParser from "@apidevtools/swagger-parser";
 import { cac } from "cac";
 import { join } from "pathe";
-import { type as type2 } from "arktype";
+import { type } from "arktype";
 import { writeFile } from "fs/promises";
 
 // package.json
 var name = "typed-openapi";
-var version = "0.1.1";
-
-// src/generator.ts
-import { capitalize as capitalize2, groupBy } from "pastable/server";
-
-// src/asserts.ts
-var isPrimitiveType = (type3) => primitiveTypeList.includes(type3);
-var primitiveTypeList = ["string", "number", "integer", "boolean", "null"];
-
-// src/box-factory.ts
-var unwrap = (param) => typeof param === "string" ? param : param.value;
-var createFactory = (f) => f;
-var createBoxFactory = (schema, ctx) => {
-  const f = typeof ctx.factory === "function" ? ctx.factory(schema, ctx) : ctx.factory;
-  const callback = (box2) => {
-    if (f.callback) {
-      box2 = f.callback(box2);
-    }
-    if (ctx?.onBox) {
-      box2 = ctx.onBox?.(box2);
-    }
-    return box2;
-  };
-  const box = {
-    union: (types) => callback(new Box({ ctx, schema, type: "union", params: { types }, value: f.union(types) })),
-    intersection: (types) => callback(new Box({ ctx, schema, type: "intersection", params: { types }, value: f.intersection(types) })),
-    array: (type3) => callback(new Box({ ctx, schema, type: "array", params: { type: type3 }, value: f.array(type3) })),
-    optional: (type3) => callback(new Box({ ctx, schema, type: "optional", params: { type: type3 }, value: f.optional(type3) })),
-    reference: (name2, generics) => callback(
-      new Box({
-        ctx,
-        schema,
-        type: "ref",
-        params: generics ? { name: name2, generics } : { name: name2 },
-        value: f.reference(name2, generics)
-      })
-    ),
-    literal: (value) => callback(new Box({ ctx, schema, type: "literal", params: {}, value: f.literal(value) })),
-    string: () => callback(new Box({ ctx, schema, type: "keyword", params: { name: "string" }, value: f.string() })),
-    number: () => callback(new Box({ ctx, schema, type: "keyword", params: { name: "number" }, value: f.number() })),
-    boolean: () => callback(new Box({ ctx, schema, type: "keyword", params: { name: "boolean" }, value: f.boolean() })),
-    unknown: () => callback(new Box({ ctx, schema, type: "keyword", params: { name: "unknown" }, value: f.unknown() })),
-    any: () => callback(new Box({ ctx, schema, type: "keyword", params: { name: "any" }, value: f.any() })),
-    never: () => callback(new Box({ ctx, schema, type: "keyword", params: { name: "never" }, value: f.never() })),
-    object: (props) => callback(new Box({ ctx, schema, type: "object", params: { props }, value: f.object(props) }))
-  };
-  return box;
-};
-
-// src/is-reference-object.ts
-function isReferenceObject(obj) {
-  return obj != null && Object.prototype.hasOwnProperty.call(obj, "$ref");
-}
-
-// src/string-utils.ts
-import { capitalize, kebabToCamel } from "pastable/server";
-function normalizeString(text) {
-  const prefixed = prefixStringStartingWithNumberIfNeeded(text);
-  return prefixed.normalize("NFKD").trim().replace(/\s+/g, "_").replace(/-+/g, "_").replace(/[^\w\-]+/g, "_").replace(/--+/g, "-");
-}
-var onlyWordRegex = /^\w+$/;
-var wrapWithQuotesIfNeeded = (str) => {
-  if (str[0] === '"' && str[str.length - 1] === '"')
-    return str;
-  if (onlyWordRegex.test(str)) {
-    return str;
-  }
-  return `"${str}"`;
-};
-var prefixStringStartingWithNumberIfNeeded = (str) => {
-  const firstAsNumber = Number(str[0]);
-  if (typeof firstAsNumber === "number" && !Number.isNaN(firstAsNumber)) {
-    return "_" + str;
-  }
-  return str;
-};
-var pathParamWithBracketsRegex = /({\w+})/g;
-var wordPrecededByNonWordCharacter = /[^\w\-]+/g;
-var pathToVariableName = (path) => capitalize(kebabToCamel(path).replaceAll("/", "")).replace(pathParamWithBracketsRegex, (group) => capitalize(group.slice(1, -1))).replace(wordPrecededByNonWordCharacter, "_");
-
-// src/openapi-schema-to-ts.ts
-var openApiSchemaToTs = ({ schema, meta: _inheritedMeta, ctx }) => {
-  const meta = {};
-  if (!schema) {
-    throw new Error("Schema is required");
-  }
-  const t = createBoxFactory(schema, ctx);
-  const getTs = () => {
-    if (isReferenceObject(schema)) {
-      const refInfo = ctx.refs.getInfosByRef(schema.$ref);
-      return t.reference(refInfo.normalized);
-    }
-    if (Array.isArray(schema.type)) {
-      if (schema.type.length === 1) {
-        return openApiSchemaToTs({ schema: { ...schema, type: schema.type[0] }, ctx, meta });
-      }
-      return t.union(schema.type.map((prop) => openApiSchemaToTs({ schema: { ...schema, type: prop }, ctx, meta })));
-    }
-    if (schema.type === "null") {
-      return t.reference("null");
-    }
-    if (schema.oneOf) {
-      if (schema.oneOf.length === 1) {
-        return openApiSchemaToTs({ schema: schema.oneOf[0], ctx, meta });
-      }
-      return t.union(schema.oneOf.map((prop) => openApiSchemaToTs({ schema: prop, ctx, meta })));
-    }
-    if (schema.anyOf) {
-      if (schema.anyOf.length === 1) {
-        return openApiSchemaToTs({ schema: schema.anyOf[0], ctx, meta });
-      }
-      const oneOf = t.union(schema.anyOf.map((prop) => openApiSchemaToTs({ schema: prop, ctx, meta })));
-      return t.union([oneOf, t.array(oneOf)]);
-    }
-    if (schema.allOf) {
-      if (schema.allOf.length === 1) {
-        return openApiSchemaToTs({ schema: schema.allOf[0], ctx, meta });
-      }
-      const types = schema.allOf.map((prop) => openApiSchemaToTs({ schema: prop, ctx, meta }));
-      return t.intersection(types);
-    }
-    const schemaType = schema.type ? schema.type.toLowerCase() : void 0;
-    if (schemaType && isPrimitiveType(schemaType)) {
-      if (schema.enum) {
-        if (schema.enum.length === 1) {
-          const value = schema.enum[0];
-          return t.literal(value === null ? "null" : `"${value}"`);
-        }
-        if (schemaType === "string") {
-          return t.union(schema.enum.map((value) => t.literal(`"${value}"`)));
-        }
-        if (schema.enum.some((e) => typeof e === "string")) {
-          return t.never();
-        }
-        return t.union(schema.enum.map((value) => t.literal(value === null ? "null" : value)));
-      }
-      if (schemaType === "string")
-        return t.string();
-      if (schemaType === "boolean")
-        return t.boolean();
-      if (schemaType === "number" || schemaType === "integer")
-        return t.number();
-      if (schemaType === "null")
-        return t.reference("null");
-    }
-    if (schemaType === "array") {
-      if (schema.items) {
-        let arrayOfType = openApiSchemaToTs({ schema: schema.items, ctx, meta });
-        if (typeof arrayOfType === "string") {
-          arrayOfType = t.reference(arrayOfType);
-        }
-        return t.array(arrayOfType);
-      }
-      return t.array(t.any());
-    }
-    if (schemaType === "object" || schema.properties || schema.additionalProperties) {
-      if (!schema.properties) {
-        return t.unknown();
-      }
-      let additionalProperties;
-      if (schema.additionalProperties) {
-        let additionalPropertiesType;
-        if (typeof schema.additionalProperties === "boolean" && schema.additionalProperties || typeof schema.additionalProperties === "object" && Object.keys(schema.additionalProperties).length === 0) {
-          additionalPropertiesType = t.any();
-        } else if (typeof schema.additionalProperties === "object") {
-          additionalPropertiesType = openApiSchemaToTs({
-            schema: schema.additionalProperties,
-            ctx,
-            meta
-          });
-        }
-        additionalProperties = t.object({ [t.string().value]: additionalPropertiesType });
-      }
-      const hasRequiredArray = schema.required && schema.required.length > 0;
-      const isPartial = !schema.required?.length;
-      const props = Object.fromEntries(
-        Object.entries(schema.properties).map(([prop, propSchema]) => {
-          let propType = openApiSchemaToTs({ schema: propSchema, ctx, meta });
-          if (typeof propType === "string") {
-            propType = t.reference(propType);
-          }
-          const isRequired = Boolean(isPartial ? true : hasRequiredArray ? schema.required?.includes(prop) : false);
-          const isOptional = !isPartial && !isRequired;
-          return [
-            `${wrapWithQuotesIfNeeded(prop)}${isOptional ? "?" : ""}`,
-            isOptional ? t.optional(propType) : propType
-          ];
-        })
-      );
-      const objectType = additionalProperties ? t.intersection([t.object(props), additionalProperties]) : t.object(props);
-      return isPartial ? t.reference("Partial", [objectType]) : objectType;
-    }
-    if (!schemaType)
-      return t.unknown();
-    throw new Error(`Unsupported schema type: ${schemaType}`);
-  };
-  return getTs();
-};
-
-// src/box.ts
-var Box = class _Box {
-  constructor(definition) {
-    this.definition = definition;
-    this.definition = definition;
-    this.type = definition.type;
-    this.value = definition.value;
-    this.params = definition.params;
-    this.schema = definition.schema;
-    this.ctx = definition.ctx;
-  }
-  type;
-  value;
-  params;
-  schema;
-  ctx;
-  toJSON() {
-    return { type: this.type, value: this.value };
-  }
-  toString() {
-    return JSON.stringify(this.toJSON(), null, 2);
-  }
-  recompute(callback) {
-    return openApiSchemaToTs({ schema: this.schema, ctx: { ...this.ctx, onBox: callback } });
-  }
-  static fromJSON(json) {
-    return new _Box(JSON.parse(json));
-  }
-  static isBox(box) {
-    return box instanceof _Box;
-  }
-  static isUnion(box) {
-    return box.type === "union";
-  }
-  static isIntersection(box) {
-    return box.type === "intersection";
-  }
-  static isArray(box) {
-    return box.type === "array";
-  }
-  static isOptional(box) {
-    return box.type === "optional";
-  }
-  static isReference(box) {
-    return box.type === "ref";
-  }
-  static isKeyword(box) {
-    return box.type === "keyword";
-  }
-  static isObject(box) {
-    return box.type === "object";
-  }
-  static isLiteral(box) {
-    return box.type === "literal";
-  }
-};
-
-// src/format.ts
-import prettier from "prettier";
-import parserTypescript from "prettier/parser-typescript";
-function maybePretty(input, options) {
-  try {
-    return prettier.format(input, {
-      parser: "typescript",
-      plugins: [parserTypescript],
-      ...options
-    });
-  } catch (err) {
-    console.warn("Failed to format code");
-    console.warn(err);
-    return input;
-  }
-}
-var prettify = (str, options) => maybePretty(str, { printWidth: 120, trailingComma: "all", ...options });
-
-// src/generator.ts
-import * as Codegen from "@sinclair/typebox-codegen";
-import { match } from "ts-pattern";
-import { type } from "arktype";
-var allowedRuntimes = type("'none' | 'arktype' | 'io-ts' | 'typebox' | 'valibot' | 'yup' | 'zod'");
-var runtimeValidationGenerator = {
-  arktype: Codegen.ModelToArkType.Generate,
-  "io-ts": Codegen.ModelToIoTs.Generate,
-  typebox: Codegen.ModelToTypeBox.Generate,
-  valibot: Codegen.ModelToValibot.Generate,
-  yup: Codegen.ModelToYup.Generate,
-  zod: Codegen.ModelToZod.Generate
-};
-var inferByRuntime = {
-  none: (input) => input,
-  arktype: (input) => `${input}["infer"]`,
-  "io-ts": (input) => `t.TypeOf<${input}>`,
-  typebox: (input) => `Static<${input}>`,
-  valibot: (input) => `v.Output<${input}>`,
-  yup: (input) => `y.InferType<${input}>`,
-  zod: (input) => `z.infer<${input}>`
-};
-var methods = ["get", "put", "post", "delete", "options", "head", "patch", "trace"];
-var methodsRegex = new RegExp(`(?:${methods.join("|")})_`);
-var endpointExport = new RegExp(`export (?:type|const) (?:${methodsRegex.source})`);
-var replacerByRuntime = {
-  yup: (line) => line.replace(/y\.InferType<\s*?typeof (.*?)\s*?>/g, "typeof $1").replace(new RegExp(`(${endpointExport.source})` + new RegExp(/(.*? )(y\.object)(\()/).source, "g"), "$1$2("),
-  zod: (line) => line.replace(/z\.infer<\s*?typeof (.*?)\s*?>/g, "typeof $1").replace(new RegExp(`(${endpointExport.source})` + new RegExp(/(.*? )(z\.object)(\()/).source, "g"), "$1$2(")
-};
-var generateFile = (options) => {
-  const ctx = { ...options, runtime: options.runtime ?? "none" };
-  const schemaList = generateSchemaList(ctx);
-  const endpointSchemaList = generateEndpointSchemaList(ctx);
-  const apiClient = generateApiClient(ctx);
-  const transform = ctx.runtime === "none" ? (file2) => file2 : (file2) => {
-    const model = Codegen.TypeScriptToModel.Generate(file2);
-    const transformer = runtimeValidationGenerator[ctx.runtime];
-    const generated = ctx.runtime === "typebox" ? Codegen.TypeScriptToTypeBox.Generate(file2) : transformer(model);
-    let converted = "";
-    const match2 = generated.match(/(const __ENDPOINTS_START__ =)([\s\S]*?)(export type __ENDPOINTS_END__)/);
-    const content = match2?.[2];
-    if (content && ctx.runtime in replacerByRuntime) {
-      const before = generated.slice(0, generated.indexOf("export type __ENDPOINTS_START"));
-      converted = before + replacerByRuntime[ctx.runtime](
-        content.slice(content.indexOf("export"))
-      );
-    } else {
-      converted = generated;
-    }
-    return converted;
-  };
-  const file = `
-  ${transform(schemaList + endpointSchemaList)}
-  ${apiClient}
-  `;
-  return prettify(file);
-};
-var generateSchemaList = ({ refs, runtime }) => {
-  let file = `
-  ${runtime === "none" ? "export namespace Schemas {" : ""}
-    // <Schemas>
-  `;
-  refs.getOrderedSchemas().forEach(([schema, infos]) => {
-    if (!infos?.name)
-      return;
-    if (infos.kind !== "schemas")
-      return;
-    file += `export type ${infos.normalized} = ${schema.value}
-`;
-  });
-  return file + `
-    // </Schemas>
-    ${runtime === "none" ? "}" : ""}
-  `;
-};
-var parameterObjectToString = (parameters) => {
-  if (parameters instanceof Box)
-    return parameters.value;
-  let str = "{";
-  for (const [key, box] of Object.entries(parameters)) {
-    str += `${wrapWithQuotesIfNeeded(key)}: ${box.value},
-`;
-  }
-  return str + "}";
-};
-var generateEndpointSchemaList = (ctx) => {
-  let file = `
-  ${ctx.runtime === "none" ? "export namespace Endpoints {" : ""}
-  // <Endpoints>
-  ${ctx.runtime === "none" ? "" : "type __ENDPOINTS_START__ = {}"}
-  `;
-  ctx.endpointList.map((endpoint) => {
-    const parameters = endpoint.parameters ?? {};
-    file += `export type ${endpoint.meta.alias} = {
-      method: "${endpoint.method.toUpperCase()}",
-      path: "${endpoint.path}",
-      ${endpoint.meta.hasParameters ? `parameters: {
-            ${parameters.query ? `query:  ${parameterObjectToString(parameters.query)},` : ""}
-        ${parameters.path ? `path:  ${parameterObjectToString(parameters.path)},` : ""}
-        ${parameters.header ? `header:  ${parameterObjectToString(parameters.header)},` : ""}
-          }` : "parameters: never,"}
-      response: ${ctx.runtime === "none" ? endpoint.response.recompute((box) => {
-      if (Box.isReference(box) && !box.params.generics) {
-        box.value = `Schemas.${box.value}`;
-      }
-      return box;
-    }).value : endpoint.response.value},
-    }
-`;
-  });
-  return file + `
-  // </Endpoints>
-  ${ctx.runtime === "none" ? "}" : ""}
-  ${ctx.runtime === "none" ? "" : "type __ENDPOINTS_END__ = {}"}
-  `;
-};
-var generateEndpointByMethod = (ctx) => {
-  const { endpointList } = ctx;
-  const byMethods = groupBy(endpointList, "method");
-  const endpointByMethod = `
-     // <EndpointByMethod>
-     export ${ctx.runtime === "none" ? "type" : "const"} EndpointByMethod = {
-     ${Object.entries(byMethods).map(([method, list]) => {
-    return `${method}: {
-           ${list.map(
-      (endpoint) => `"${endpoint.path}": ${ctx.runtime === "none" ? "Endpoints." : ""}${endpoint.meta.alias}`
-    )}
-         }`;
-  }).join(",\n")}
-     }
-     ${ctx.runtime === "none" ? "" : "export type EndpointByMethod = typeof EndpointByMethod;"}
-     // </EndpointByMethod>
-     `;
-  const shorthands = `
-
-    // <EndpointByMethod.Shorthands>
-    ${Object.keys(byMethods).map((method) => `export type ${capitalize2(method)}Endpoints = EndpointByMethod["${method}"]`).join("\n")}
-    ${endpointList.length ? `export type AllEndpoints = EndpointByMethod[keyof EndpointByMethod];` : ""}
-    // </EndpointByMethod.Shorthands>
-    `;
-  return endpointByMethod + shorthands;
-};
-var generateApiClient = (ctx) => {
-  const { endpointList } = ctx;
-  const byMethods = groupBy(endpointList, "method");
-  const endpointSchemaList = generateEndpointByMethod(ctx);
-  const apiClientTypes = `
-// <ApiClientTypes>
-export type EndpointParameters = {
-  body?: unknown;
-  query?: Record<string, unknown>;
-  header?: Record<string, unknown>;
-  path?: Record<string, unknown>;
-};
-
-export type MutationMethod = "post" | "put" | "patch" | "delete";
-export type Method = "get" | "head" | MutationMethod;
-
-export type DefaultEndpoint = {
-  parameters?: EndpointParameters | undefined;
-  response: unknown;
-};
-
-export type Endpoint<TConfig extends DefaultEndpoint = DefaultEndpoint> = {
-  operationId: string;
-  method: Method;
-  path: string;
-  parameters?: TConfig["parameters"];
-  meta: {
-    alias: string;
-    hasParameters: boolean;
-    areParametersRequired: boolean;
-  };
-  response: TConfig["response"];
-};
-
-type Fetcher = (method: Method, url: string, parameters?: EndpointParameters | undefined) => Promise<Endpoint["response"]>;
-
-type RequiredKeys<T> = {
-  [P in keyof T]-?: undefined extends T[P] ? never : P;
-}[keyof T];
-
-type MaybeOptionalArg<T> = RequiredKeys<T> extends never ? [config?: T] : [config: T];
-
-// </ApiClientTypes>
-`;
-  const apiClient = `
-// <ApiClient>
-export class ApiClient {
-  baseUrl: string = "";
-
-  constructor(public fetcher: Fetcher) {}
-
-  setBaseUrl(baseUrl: string) {
-    this.baseUrl = baseUrl;
-    return this;
-  }
-
-  ${Object.entries(byMethods).map(([method, endpointByMethod]) => {
-    const capitalizedMethod = capitalize2(method);
-    const infer = inferByRuntime[ctx.runtime];
-    return endpointByMethod.length ? `// <ApiClient.${method}>
-    ${method}<Path extends keyof ${capitalizedMethod}Endpoints, TEndpoint extends ${capitalizedMethod}Endpoints[Path]>(
-      path: Path,
-      ...params: MaybeOptionalArg<${match(ctx.runtime).with("zod", "yup", () => infer(`TEndpoint["parameters"]`)).with("arktype", "io-ts", "typebox", "valibot", () => infer(`TEndpoint`) + `["parameters"]`).otherwise(() => `TEndpoint["parameters"]`)}>
-    ): Promise<${match(ctx.runtime).with("zod", "yup", () => infer(`TEndpoint["response"]`)).with("arktype", "io-ts", "typebox", "valibot", () => infer(`TEndpoint`) + `["response"]`).otherwise(() => `TEndpoint["response"]`)}> {
-      return this.fetcher("${method}", this.baseUrl + path, params[0]);
-    }
-    // </ApiClient.${method}>
-    ` : "";
-  }).join("\n")}
-}
-
-export function createApiClient(fetcher: Fetcher, baseUrl?: string) {
-  return new ApiClient(fetcher).setBaseUrl(baseUrl ?? "");
-}
-
-
-/**
- Example usage:
- const api = createApiClient((method, url, params) =>
-   fetch(url, { method, body: JSON.stringify(params) }).then((res) => res.json()),
- );
- api.get("/users").then((users) => console.log(users));
- api.post("/users", { body: { name: "John" } }).then((user) => console.log(user));
- api.put("/users/:id", { path: { id: 1 }, body: { name: "John" } }).then((user) => console.log(user));
-*/
-
-// </ApiClient
-`;
-  return endpointSchemaList + apiClientTypes + apiClient;
-};
-
-// src/map-openapi-endpoints.ts
-import { capitalize as capitalize3, pick } from "pastable/server";
-
-// src/ref-resolver.ts
-import { get } from "pastable/server";
-
-// src/topological-sort.ts
-function topologicalSort(graph) {
-  const sorted = [], visited = {};
-  function visit(name2, ancestors) {
-    if (!Array.isArray(ancestors))
-      ancestors = [];
-    ancestors.push(name2);
-    visited[name2] = true;
-    const deps = graph.get(name2);
-    if (deps) {
-      deps.forEach((dep) => {
-        if (ancestors.includes(dep)) {
-          return;
-        }
-        if (visited[dep])
-          return;
-        visit(dep, ancestors.slice(0));
-      });
-    }
-    if (!sorted.includes(name2))
-      sorted.push(name2);
-  }
-  graph.forEach((_, name2) => visit(name2, []));
-  return sorted;
-}
-
-// src/ref-resolver.ts
-var autocorrectRef = (ref) => ref[1] === "/" ? ref : "#/" + ref.slice(1);
-var componentsWithSchemas = ["schemas", "responses", "parameters", "requestBodies", "headers"];
-var createRefResolver = (doc, factory2) => {
-  const nameByRef = /* @__PURE__ */ new Map();
-  const refByName = /* @__PURE__ */ new Map();
-  const byRef = /* @__PURE__ */ new Map();
-  const byNormalized = /* @__PURE__ */ new Map();
-  const boxByRef = /* @__PURE__ */ new Map();
-  const getSchemaByRef = (ref) => {
-    const correctRef = autocorrectRef(ref);
-    const split = correctRef.split("/");
-    const path = split.slice(1, -1).join("/");
-    const normalizedPath = path.replace("#/", "").replace("#", "").replaceAll("/", ".");
-    const map = get(doc, normalizedPath) ?? {};
-    const name2 = split[split.length - 1];
-    const normalized = normalizeString(name2);
-    nameByRef.set(correctRef, normalized);
-    refByName.set(normalized, correctRef);
-    const infos = { ref: correctRef, name: name2, normalized, kind: normalizedPath.split(".")[1] };
-    byRef.set(infos.ref, infos);
-    byNormalized.set(infos.normalized, infos);
-    const schema = map[name2];
-    if (!schema) {
-      throw new Error(`Unresolved ref "${name2}" not found in "${path}"`);
-    }
-    return schema;
-  };
-  const getInfosByRef = (ref) => byRef.get(autocorrectRef(ref));
-  const schemaEntries = Object.entries(doc.components ?? {}).filter(([key]) => componentsWithSchemas.includes(key));
-  schemaEntries.forEach(([key, component]) => {
-    Object.keys(component).map((name2) => {
-      const ref = `#/components/${key}/${name2}`;
-      getSchemaByRef(ref);
-    });
-  });
-  const directDependencies = /* @__PURE__ */ new Map();
-  schemaEntries.forEach(([key, component]) => {
-    Object.keys(component).map((name2) => {
-      const ref = `#/components/${key}/${name2}`;
-      const schema = getSchemaByRef(ref);
-      boxByRef.set(ref, openApiSchemaToTs({ schema, ctx: { factory: factory2, refs: { getInfosByRef } } }));
-      if (!directDependencies.has(ref)) {
-        directDependencies.set(ref, /* @__PURE__ */ new Set());
-      }
-      setSchemaDependencies(schema, directDependencies.get(ref));
-    });
-  });
-  const transitiveDependencies = getTransitiveDependencies(directDependencies);
-  return {
-    get: getSchemaByRef,
-    unwrap: (component) => {
-      return isReferenceObject(component) ? getSchemaByRef(component.$ref) : component;
-    },
-    getInfosByRef,
-    infos: byRef,
-    /**
-     * Get the schemas in the order they should be generated, depending on their dependencies
-     * so that a schema is generated before the ones that depend on it
-     */
-    getOrderedSchemas: () => {
-      const schemaOrderedByDependencies = topologicalSort(transitiveDependencies).map((ref) => {
-        const infos = getInfosByRef(ref);
-        return [boxByRef.get(infos.ref), infos];
-      });
-      return schemaOrderedByDependencies;
-    },
-    directDependencies,
-    transitiveDependencies
-  };
-};
-var setSchemaDependencies = (schema, deps) => {
-  const visit = (schema2) => {
-    if (!schema2)
-      return;
-    if (isReferenceObject(schema2)) {
-      deps.add(schema2.$ref);
-      return;
-    }
-    if (schema2.allOf) {
-      for (const allOf of schema2.allOf) {
-        visit(allOf);
-      }
-      return;
-    }
-    if (schema2.oneOf) {
-      for (const oneOf of schema2.oneOf) {
-        visit(oneOf);
-      }
-      return;
-    }
-    if (schema2.anyOf) {
-      for (const anyOf of schema2.anyOf) {
-        visit(anyOf);
-      }
-      return;
-    }
-    if (schema2.type === "array") {
-      if (!schema2.items)
-        return;
-      return void visit(schema2.items);
-    }
-    if (schema2.type === "object" || schema2.properties || schema2.additionalProperties) {
-      if (schema2.properties) {
-        for (const property in schema2.properties) {
-          visit(schema2.properties[property]);
-        }
-      }
-      if (schema2.additionalProperties && typeof schema2.additionalProperties === "object") {
-        visit(schema2.additionalProperties);
-      }
-    }
-  };
-  visit(schema);
-};
-var getTransitiveDependencies = (directDependencies) => {
-  const transitiveDependencies = /* @__PURE__ */ new Map();
-  const visitedsDeepRefs = /* @__PURE__ */ new Set();
-  directDependencies.forEach((deps, ref) => {
-    if (!transitiveDependencies.has(ref)) {
-      transitiveDependencies.set(ref, /* @__PURE__ */ new Set());
-    }
-    const visit = (depRef) => {
-      transitiveDependencies.get(ref).add(depRef);
-      const deps2 = directDependencies.get(depRef);
-      if (deps2 && ref !== depRef) {
-        deps2.forEach((transitive) => {
-          const key = ref + "__" + transitive;
-          if (visitedsDeepRefs.has(key))
-            return;
-          visitedsDeepRefs.add(key);
-          visit(transitive);
-        });
-      }
-    };
-    deps.forEach((dep) => visit(dep));
-  });
-  return transitiveDependencies;
-};
-
-// src/ts-factory.ts
-var tsFactory = createFactory({
-  union: (types) => types.map(unwrap).join(" | "),
-  intersection: (types) => types.map(unwrap).join(" & "),
-  array: (type3) => `Array<${unwrap(type3)}>`,
-  optional: (type3) => `${unwrap(type3)} | undefined`,
-  reference: (name2, typeArgs) => `${name2}${typeArgs ? `<${typeArgs.map(unwrap).join(", ")}>` : ""}`,
-  literal: (value) => value.toString(),
-  string: () => "string",
-  number: () => "number",
-  boolean: () => "boolean",
-  unknown: () => "unknown",
-  any: () => "any",
-  never: () => "never",
-  object: (props) => {
-    const propsString = Object.entries(props).map(([prop, type3]) => `${wrapWithQuotesIfNeeded(prop)}: ${unwrap(type3)}`).join(", ");
-    return `{ ${propsString} }`;
-  }
-});
-
-// src/map-openapi-endpoints.ts
-var factory = tsFactory;
-var mapOpenApiEndpoints = (doc) => {
-  const refs = createRefResolver(doc, factory);
-  const ctx = { refs, factory };
-  const endpointList = [];
-  Object.entries(doc.paths ?? {}).forEach(([path, pathItemObj]) => {
-    const pathItem = pick(pathItemObj, ["get", "put", "post", "delete", "options", "head", "patch", "trace"]);
-    Object.entries(pathItem).forEach(([method, operation]) => {
-      if (operation.deprecated)
-        return;
-      const endpoint = {
-        operation,
-        method,
-        path,
-        response: openApiSchemaToTs({ schema: {}, ctx }),
-        meta: {
-          alias: getAlias({ path, method, operation }),
-          areParametersRequired: false,
-          hasParameters: false
-        }
-      };
-      const lists = { query: [], path: [], header: [] };
-      const paramObjects = (operation.parameters ?? []).reduce(
-        (acc, paramOrRef) => {
-          const param = refs.unwrap(paramOrRef);
-          const schema = openApiSchemaToTs({ schema: refs.unwrap(param.schema ?? {}), ctx });
-          lists.query.push(param);
-          if (param.required)
-            endpoint.meta.areParametersRequired = true;
-          endpoint.meta.hasParameters = true;
-          if (param.in === "query")
-            acc.query[param.name] = schema;
-          if (param.in === "path")
-            acc.path[param.name] = schema;
-          if (param.in === "header")
-            acc.header[param.name] = schema;
-          return acc;
-        },
-        { query: {}, path: {}, header: {} }
-      );
-      const params = Object.entries(paramObjects).reduce((acc, [key, value]) => {
-        if (Object.keys(value).length) {
-          acc[key] = value;
-        }
-        return acc;
-      }, {});
-      if (operation.requestBody) {
-        const requestBody = refs.unwrap(operation.requestBody ?? {});
-        const content2 = requestBody.content;
-        const matchingMediaType = Object.keys(content2).find(isAllowedParamMediaTypes);
-        if (matchingMediaType && content2[matchingMediaType]) {
-          params.body = openApiSchemaToTs({
-            schema: content2[matchingMediaType]?.schema ?? {} ?? {},
-            ctx
-          });
-        }
-      }
-      if (params) {
-        const t = createBoxFactory({}, ctx);
-        if (params.query && lists.query.length && lists.query.every((param) => !param.required)) {
-          if (!params.query)
-            params.query = {};
-          params.query = t.reference("Partial", [t.object(params.query)]);
-        }
-        if (params.path && lists.path.length && lists.path.every((param) => !param.required)) {
-          params.path = t.reference("Partial", [t.object(params.path)]);
-        }
-        if (params.header && lists.header.length && lists.header.every((param) => !param.required)) {
-          params.header = t.reference("Partial", [t.object(params.header)]);
-        }
-        endpoint.parameters = Object.keys(params).length ? params : void 0;
-      }
-      let responseObject;
-      if (operation.responses.default) {
-        responseObject = refs.unwrap(operation.responses.default);
-      } else {
-        Object.entries(operation.responses).map(([status, responseOrRef]) => {
-          const statusCode = Number(status);
-          if (statusCode >= 200 && statusCode < 300) {
-            responseObject = refs.unwrap(responseOrRef);
-          }
-        });
-      }
-      const content = responseObject?.content;
-      if (content) {
-        const matchingMediaType = Object.keys(content).find(isResponseMediaType);
-        if (matchingMediaType && content[matchingMediaType]) {
-          endpoint.response = openApiSchemaToTs({
-            schema: content[matchingMediaType]?.schema ?? {} ?? {},
-            ctx
-          });
-        }
-      }
-      endpointList.push(endpoint);
-    });
-  });
-  return { doc, refs, endpointList, factory };
-};
-var allowedParamMediaTypes = [
-  "application/octet-stream",
-  "multipart/form-data",
-  "application/x-www-form-urlencoded",
-  "*/*"
-];
-var isAllowedParamMediaTypes = (mediaType) => mediaType.includes("application/") && mediaType.includes("json") || allowedParamMediaTypes.includes(mediaType) || mediaType.includes("text/");
-var isResponseMediaType = (mediaType) => mediaType === "application/json";
-var getAlias = ({ path, method, operation }) => method + "_" + capitalize3(operation.operationId ?? pathToVariableName(path));
+var version = "0.1.4";
 
 // src/cli.ts
 var cwd = process.cwd();
 var cli = cac(name);
 var now = /* @__PURE__ */ new Date();
-var optionsSchema = type2({ "output?": "string", runtime: allowedRuntimes });
+var optionsSchema = type({ "output?": "string", runtime: allowedRuntimes });
 cli.command("<input>", "Generate").option("-o, --output <path>", "Output path for the api client ts file (defaults to `<input>.<runtime>.ts`)").option(
   "-r, --runtime <name>",
   `Runtime to use for validation; defaults to \`none\`; available: ${allowedRuntimes.definition}`,