@sdk-it/cli 0.12.6 → 0.12.8

package/dist/index.js

@@ -4,1145 +4,10 @@ import { Command as Command2, program } from "commander";
 // packages/cli/src/lib/generate.ts
 import { Command, Option } from "commander";
 import { execFile } from "node:child_process";
-import { readFile as readFile2 } from "node:fs/promises";
+import { readFile } from "node:fs/promises";
 import { extname } from "node:path";
 import { parse } from "yaml";
-
-// packages/typescript/dist/index.js
-import { join as join2 } from "node:path";
-import { npmRunPathEnv } from "npm-run-path";
-import ts, { TypeFlags, symbolName } from "typescript";
-import { mkdir, readFile, readdir, stat, writeFile } from "node:fs/promises";
-import { dirname, isAbsolute, join } from "node:path";
-import debug from "debug";
-import ts2 from "typescript";
-import { get as get2, merge } from "lodash-es";
-import { camelcase as camelcase2, pascalcase as pascalcase2, spinalcase as spinalcase2 } from "stringcase";
-import { get } from "lodash-es";
-import { camelcase, pascalcase, spinalcase } from "stringcase";
-import { debounceTime, from } from "rxjs";
-var deriveSymbol = Symbol.for("serialize");
-var $types = Symbol.for("types");
-async function exist(file) {
-  return stat(file).then(() => true).catch(() => false);
-}
-async function writeFiles(dir, contents) {
-  return Promise.all(
-    Object.entries(contents).map(async ([file, content]) => {
-      const filePath = isAbsolute(file) ? file : join(dir, file);
-      await mkdir(dirname(filePath), { recursive: true });
-      if (typeof content === "string") {
-        await writeFile(filePath, content, "utf-8");
-      } else {
-        if (content.ignoreIfExists) {
-          if (!await exist(filePath)) {
-            await writeFile(filePath, content.content, "utf-8");
-          }
-        }
-      }
-    })
-  );
-}
-async function getFolderExports(folder, extensions = ["ts"]) {
-  const files = await readdir(folder, { withFileTypes: true });
-  const exports = [];
-  for (const file of files) {
-    if (file.isDirectory()) {
-      exports.push(`export * from './${file.name}/index.ts';`);
-    } else if (file.name !== "index.ts" && extensions.includes(getExt(file.name))) {
-      exports.push(`export * from './${file.name}';`);
-    }
-  }
-  return exports.join("\n");
-}
-var getExt = (fileName) => {
-  if (!fileName) {
-    return "";
-  }
-  const lastDot = fileName.lastIndexOf(".");
-  if (lastDot === -1) {
-    return "";
-  }
-  const ext = fileName.slice(lastDot + 1).split("/").filter(Boolean).join("");
-  if (ext === fileName) {
-    return "";
-  }
-  return ext || "txt";
-};
-var methods = [
-  "get",
-  "post",
-  "put",
-  "patch",
-  "delete",
-  "trace",
-  "head"
-];
-var logger = debug("january:client");
-function removeDuplicates(data, accessor) {
-  return [...new Map(data.map((x) => [accessor(x), x])).values()];
-}
-function toLitObject(obj, accessor = (value) => value) {
-  return `{${Object.keys(obj).map((key) => `${key}: ${accessor(obj[key])}`).join(", ")}}`;
-}
-var client_default = (spec) => {
-  const optionsEntries = Object.entries(spec.options).map(
-    ([key, value]) => [`'${key}'`, value]
-  );
-  const defaultHeaders = `{${optionsEntries.filter(([, value]) => value.in === "header").map(
-    ([key, value]) => `${key}: this.options[${value.optionName ? `'${value.optionName}'` : key}]`
-  ).join(",\n")}}`;
-  const defaultInputs = `{${optionsEntries.filter(([, value]) => value.in === "input").map(
-    ([key, value]) => `${key}: this.options[${value.optionName ? `'${value.optionName}'` : key}]`
-  ).join(",\n")}}`;
-  const specOptions = {
-    ...Object.fromEntries(
-      optionsEntries.map(([key, value]) => [value.optionName ?? key, value])
-    ),
-    fetch: {
-      schema: "fetchType"
-    },
-    baseUrl: {
-      schema: spec.servers.length ? `z.enum(servers).default(servers[0])` : "z.string()"
-    }
-  };
-  return `
-import { fetchType, sendRequest } from './http/send-request.ts';
-import z from 'zod';
-import type { Endpoints } from './endpoints.ts';
-import schemas from './schemas.ts';
-import {
-  createBaseUrlInterceptor,
-  createDefaultHeadersInterceptor,
-} from './http/interceptors.ts';
-
-${spec.servers.length ? `export const servers = ${JSON.stringify(spec.servers, null, 2)} as const` : ""}
-const optionsSchema = z.object(${toLitObject(specOptions, (x) => x.schema)});
-${spec.servers.length ? `export type Servers = typeof servers[number];` : ""}
-
-type ${spec.name}Options = z.infer<typeof optionsSchema>;
-
-export class ${spec.name} {
-
-  constructor(public options: ${spec.name}Options) {}
-
-  async request<E extends keyof Endpoints>(
-    endpoint: E,
-    input: Endpoints[E]['input'],
-  ): Promise<readonly [Endpoints[E]['output'], Endpoints[E]['error'] | null]> {
-    const route = schemas[endpoint];
-    return sendRequest(Object.assign(this.#defaultInputs, input), route, {
-      fetch: this.options.fetch,
-      interceptors: [
-        createDefaultHeadersInterceptor(() => this.defaultHeaders),
-        createBaseUrlInterceptor(() => this.options.baseUrl),
-      ],
-    });
-  }
-
-  get defaultHeaders() {
-    return ${defaultHeaders}
-  }
-
-  get #defaultInputs() {
-    return ${defaultInputs}
-  }
-
-  setOptions(options: Partial<${spec.name}Options>) {
-    const validated = optionsSchema.partial().parse(options);
-
-    for (const key of Object.keys(validated) as (keyof ${spec.name}Options)[]) {
-      if (validated[key] !== undefined) {
-        (this.options[key] as typeof validated[typeof key]) = validated[key]!;
-      }
-    }
-  }
-}`;
-};
-var SchemaEndpoint = class {
-  #imports = [
-    `import z from 'zod';`,
-    'import type { Endpoints } from "./endpoints.ts";',
-    `import { toRequest, json, urlencoded, nobody, formdata, createUrl } from './http/request.ts';`,
-    `import type { ParseError } from './http/parser.ts';`
-  ];
-  #endpoints = [];
-  addEndpoint(endpoint, operation) {
-    this.#endpoints.push(`  "${endpoint}": ${operation},`);
-  }
-  addImport(value) {
-    this.#imports.push(value);
-  }
-  complete() {
-    return `${this.#imports.join("\n")}
-export default {
-${this.#endpoints.join("\n")}
-}`;
-  }
-};
-var Emitter = class {
-  imports = [
-    `import z from 'zod';`,
-    `import type { ParseError } from './http/parser.ts';`
-  ];
-  endpoints = [];
-  addEndpoint(endpoint, operation) {
-    this.endpoints.push(`  "${endpoint}": ${operation};`);
-  }
-  addImport(value) {
-    this.imports.push(value);
-  }
-  complete() {
-    return `${this.imports.join("\n")}
-export interface Endpoints {
-${this.endpoints.join("\n")}
-}`;
-  }
-};
-var StreamEmitter = class extends Emitter {
-  complete() {
-    return `${this.imports.join("\n")}
-export interface StreamEndpoints {
-${this.endpoints.join("\n")}
-}`;
-  }
-};
-function generateClientSdk(spec) {
-  const emitter = new Emitter();
-  const streamEmitter = new StreamEmitter();
-  const schemas = {};
-  const schemaEndpoint = new SchemaEndpoint();
-  const errors = [];
-  for (const [name, operations] of Object.entries(spec.operations)) {
-    const featureSchemaFileName = camelcase(name);
-    schemas[featureSchemaFileName] = [`import z from 'zod';`];
-    emitter.addImport(
-      `import * as ${featureSchemaFileName} from './inputs/${featureSchemaFileName}.ts';`
-    );
-    streamEmitter.addImport(
-      `import * as ${featureSchemaFileName} from './inputs/${featureSchemaFileName}.ts';`
-    );
-    schemaEndpoint.addImport(
-      `import * as ${featureSchemaFileName} from './inputs/${featureSchemaFileName}.ts';`
-    );
-    for (const operation of operations) {
-      const schemaName = camelcase(`${operation.name} schema`);
-      const schema = `export const ${schemaName} = ${Object.keys(operation.schemas).length === 1 ? Object.values(operation.schemas)[0] : toLitObject(operation.schemas)};`;
-      schemas[featureSchemaFileName].push(schema);
-      const schemaRef = `${featureSchemaFileName}.${schemaName}`;
-      const output = operation.formatOutput();
-      const inputHeaders = [];
-      const inputQuery = [];
-      const inputBody = [];
-      const inputParams = [];
-      for (const [name2, prop] of Object.entries(operation.inputs)) {
-        if (prop.in === "headers" || prop.in === "header") {
-          inputHeaders.push(`"${name2}"`);
-        } else if (prop.in === "query") {
-          inputQuery.push(`"${name2}"`);
-        } else if (prop.in === "body") {
-          inputBody.push(`"${name2}"`);
-        } else if (prop.in === "path") {
-          inputParams.push(`"${name2}"`);
-        } else if (prop.in === "internal") {
-          continue;
-        } else {
-          throw new Error(
-            `Unknown source ${prop.in} in ${name2} ${JSON.stringify(
-              prop
-            )} in ${operation.name}`
-          );
-        }
-      }
-      if (operation.type === "sse") {
-        const input = `z.infer<typeof ${schemaRef}>`;
-        const endpoint = `${operation.trigger.method.toUpperCase()} ${operation.trigger.path}`;
-        streamEmitter.addImport(
-          `import type {${pascalcase(operation.name)}} from './outputs/${spinalcase(operation.name)}.ts';`
-        );
-        streamEmitter.addEndpoint(
-          endpoint,
-          `{input: ${input}, output: ${output.use}}`
-        );
-        schemaEndpoint.addEndpoint(
-          endpoint,
-          `{
-        schema: ${schemaRef},
-        toRequest(input: StreamEndpoints['${endpoint}']['input']) {
-          const endpoint = '${endpoint}';
-            return toRequest(endpoint, json(input, {
-            inputHeaders: [${inputHeaders}],
-            inputQuery: [${inputQuery}],
-            inputBody: [${inputBody}],
-            inputParams: [${inputParams}],
-          }));
-          },
-        }`
-        );
-      } else {
-        emitter.addImport(
-          `import type {${output.import}} from './outputs/${spinalcase(operation.name)}.ts';`
-        );
-        errors.push(...operation.errors ?? []);
-        const addTypeParser = Object.keys(operation.schemas).length > 1;
-        for (const type in operation.schemas ?? {}) {
-          let typePrefix = "";
-          if (addTypeParser && type !== "json") {
-            typePrefix = `${type} `;
-          }
-          const input = `typeof ${schemaRef}${addTypeParser ? `.${type}` : ""}`;
-          const endpoint = `${typePrefix}${operation.trigger.method.toUpperCase()} ${operation.trigger.path}`;
-          emitter.addEndpoint(
-            endpoint,
-            `{input: z.infer<${input}>; output: ${output.use}; error: ${(operation.errors ?? ["ServerError"]).concat(`ParseError<${input}>`).join("|")}}`
-          );
-          schemaEndpoint.addEndpoint(
-            endpoint,
-            `{
-          schema: ${schemaRef}${addTypeParser ? `.${type}` : ""},
-          toRequest(input: Endpoints['${endpoint}']['input']) {
-            const endpoint = '${endpoint}';
-                return toRequest(endpoint, ${operation.contentType || "nobody"}(input, {
-                inputHeaders: [${inputHeaders}],
-                inputQuery: [${inputQuery}],
-                inputBody: [${inputBody}],
-                inputParams: [${inputParams}],
-              }));
-            },
-          }`
-          );
-        }
-      }
-    }
-  }
-  emitter.addImport(
-    `import type { ${removeDuplicates(errors, (it) => it).join(", ")} } from './http/response.ts';`
-  );
-  return {
-    ...Object.fromEntries(
-      Object.entries(schemas).map(([key, value]) => [
-        `inputs/${key}.ts`,
-        [
-          // schemasImports.length
-          //   ? `import {${removeDuplicates(schemasImports, (it) => it)}} from '../zod';`
-          //   : '',
-          spec.commonZod ? 'import * as commonZod from "../zod.ts";' : "",
-          ...value
-        ].map((it) => it.trim()).filter(Boolean).join("\n") + "\n"
-        // add a newline at the end
-      ])
-    ),
-    "client.ts": client_default(spec),
-    "schemas.ts": schemaEndpoint.complete(),
-    "endpoints.ts": emitter.complete()
-  };
-}
-function isRef(obj) {
-  return "$ref" in obj;
-}
-function cleanRef(ref) {
-  return ref.replace(/^#\//, "");
-}
-function parseRef(ref) {
-  const parts = ref.split("/");
-  const [model] = parts.splice(-1);
-  return { model, path: parts.join("/") };
-}
-function followRef(spec, ref) {
-  const pathParts = cleanRef(ref).split("/");
-  const entry = get(spec, pathParts);
-  if (entry && "$ref" in entry) {
-    return followRef(spec, entry.$ref);
-  }
-  return entry;
-}
-function securityToOptions(security2, securitySchemas, staticIn) {
-  securitySchemas ??= {};
-  const options = {};
-  for (const it of security2) {
-    const [name] = Object.keys(it);
-    const schema = securitySchemas[name];
-    if (isRef(schema)) {
-      throw new Error(`Ref security schemas are not supported`);
-    }
-    if (schema.type === "http") {
-      options["authorization"] = {
-        in: staticIn ?? "header",
-        schema: "z.string().optional().transform((val) => (val ? `Bearer ${val}` : undefined))",
-        optionName: "token"
-      };
-      continue;
-    }
-    if (schema.type === "apiKey") {
-      if (!schema.in) {
-        throw new Error(`apiKey security schema must have an "in" field`);
-      }
-      if (!schema.name) {
-        throw new Error(`apiKey security schema must have a "name" field`);
-      }
-      options[schema.name] = {
-        in: staticIn ?? schema.in,
-        schema: "z.string().optional()"
-      };
-      continue;
-    }
-  }
-  return options;
-}
-function mergeImports(imports) {
-  const merged = {};
-  for (const i of imports) {
-    merged[i.moduleSpecifier] = merged[i.moduleSpecifier] ?? {
-      moduleSpecifier: i.moduleSpecifier,
-      defaultImport: i.defaultImport,
-      namespaceImport: i.namespaceImport,
-      namedImports: []
-    };
-    if (i.namedImports) {
-      merged[i.moduleSpecifier].namedImports.push(...i.namedImports);
-    }
-  }
-  return Object.values(merged);
-}
-function importsToString(...imports) {
-  return imports.map((it) => {
-    if (it.defaultImport) {
-      return `import ${it.defaultImport} from '${it.moduleSpecifier}'`;
-    }
-    if (it.namespaceImport) {
-      return `import * as ${it.namespaceImport} from '${it.moduleSpecifier}'`;
-    }
-    if (it.namedImports) {
-      return `import {${removeDuplicates(it.namedImports, (it2) => it2.name).map((n) => `${n.isTypeOnly ? "type" : ""} ${n.name}`).join(", ")}} from '${it.moduleSpecifier}'`;
-    }
-    throw new Error(`Invalid import ${JSON.stringify(it)}`);
-  });
-}
-var TypeScriptDeserialzer = class {
-  circularRefTracker = /* @__PURE__ */ new Set();
-  #spec;
-  #onRef;
-  constructor(spec, onRef) {
-    this.#spec = spec;
-    this.#onRef = onRef;
-  }
-  /**
-   * Handle objects (properties)
-   */
-  object(schema, required = false) {
-    const properties = schema.properties || {};
-    const propEntries = Object.entries(properties).map(([key, propSchema]) => {
-      const isRequired = (schema.required ?? []).includes(key);
-      const tsType = this.handle(propSchema, isRequired);
-      return `${key}: ${tsType}`;
-    });
-    if (schema.additionalProperties) {
-      if (typeof schema.additionalProperties === "object") {
-        const indexType = this.handle(schema.additionalProperties, true);
-        propEntries.push(`[key: string]: ${indexType}`);
-      } else if (schema.additionalProperties === true) {
-        propEntries.push("[key: string]: any");
-      }
-    }
-    return `{ ${propEntries.join("; ")} }`;
-  }
-  /**
-   * Handle arrays (items could be a single schema or a tuple)
-   */
-  array(schema, required = false) {
-    const { items } = schema;
-    if (!items) {
-      return "any[]";
-    }
-    if (Array.isArray(items)) {
-      const tupleItems = items.map((sub) => this.handle(sub, true));
-      return `[${tupleItems.join(", ")}]`;
-    }
-    const itemsType = this.handle(items, true);
-    return `${itemsType}[]`;
-  }
-  /**
-   * Convert a basic type (string | number | boolean | object | array, etc.) to TypeScript
-   */
-  normal(type, schema, required = false) {
-    switch (type) {
-      case "string":
-        return this.string(schema, required);
-      case "number":
-      case "integer":
-        return this.number(schema, required);
-      case "boolean":
-        return appendOptional("boolean", required);
-      case "object":
-        return this.object(schema, required);
-      case "array":
-        return this.array(schema, required);
-      case "null":
-        return "null";
-      default:
-        return appendOptional("any", required);
-    }
-  }
-  ref($ref, required) {
-    const schemaName = cleanRef($ref).split("/").pop();
-    if (this.circularRefTracker.has(schemaName)) {
-      return schemaName;
-    }
-    this.circularRefTracker.add(schemaName);
-    this.#onRef(schemaName, this.handle(followRef(this.#spec, $ref), true));
-    this.circularRefTracker.delete(schemaName);
-    return appendOptional(schemaName, required);
-  }
-  allOf(schemas) {
-    const allOfTypes = schemas.map((sub) => this.handle(sub, true));
-    return allOfTypes.length > 1 ? `${allOfTypes.join(" & ")}` : allOfTypes[0];
-  }
-  anyOf(schemas, required) {
-    const anyOfTypes = schemas.map((sub) => this.handle(sub, true));
-    return appendOptional(
-      anyOfTypes.length > 1 ? `${anyOfTypes.join(" | ")}` : anyOfTypes[0],
-      required
-    );
-  }
-  oneOf(schemas, required) {
-    const oneOfTypes = schemas.map((sub) => {
-      if (isRef(sub)) {
-        const { model } = parseRef(sub.$ref);
-        if (this.circularRefTracker.has(model)) {
-          return model;
-        }
-      }
-      return this.handle(sub, false);
-    });
-    return appendOptional(
-      oneOfTypes.length > 1 ? `${oneOfTypes.join(" | ")}` : oneOfTypes[0],
-      required
-    );
-  }
-  enum(values, required) {
-    const enumValues = values.map((val) => typeof val === "string" ? `'${val}'` : `${val}`).join(" | ");
-    return appendOptional(enumValues, required);
-  }
-  /**
-   * Handle string type with formats
-   */
-  string(schema, required) {
-    let type;
-    switch (schema.format) {
-      case "date-time":
-      case "datetime":
-      case "date":
-        type = "Date";
-        break;
-      case "binary":
-      case "byte":
-        type = "Blob";
-        break;
-      case "int64":
-        type = "bigint";
-        break;
-      default:
-        type = "string";
-    }
-    return appendOptional(type, required);
-  }
-  /**
-   * Handle number/integer types with formats
-   */
-  number(schema, required) {
-    const type = schema.format === "int64" ? "bigint" : "number";
-    return appendOptional(type, required);
-  }
-  handle(schema, required) {
-    if (isRef(schema)) {
-      return this.ref(schema.$ref, required);
-    }
-    if (schema.allOf && Array.isArray(schema.allOf)) {
-      return this.allOf(schema.allOf);
-    }
-    if (schema.anyOf && Array.isArray(schema.anyOf)) {
-      return this.anyOf(schema.anyOf, required);
-    }
-    if (schema.oneOf && Array.isArray(schema.oneOf)) {
-      return this.oneOf(schema.oneOf, required);
-    }
-    if (schema.enum && Array.isArray(schema.enum)) {
-      return this.enum(schema.enum, required);
-    }
-    const types = Array.isArray(schema.type) ? schema.type : schema.type ? [schema.type] : [];
-    if (!types.length) {
-      return appendOptional("any", required);
-    }
-    if (types.length > 1) {
-      const realTypes = types.filter((t) => t !== "null");
-      if (realTypes.length === 1 && types.includes("null")) {
-        const tsType = this.normal(realTypes[0], schema, false);
-        return appendOptional(`${tsType} | null`, required);
-      }
-      const typeResults = types.map((t) => this.normal(t, schema, false));
-      return appendOptional(typeResults.join(" | "), required);
-    }
-    return this.normal(types[0], schema, required);
-  }
-  /**
-   * Generate an interface declaration
-   */
-  generateInterface(name, schema) {
-    const content = this.handle(schema, true);
-    return `interface ${name} ${content}`;
-  }
-};
-function appendOptional(type, isRequired) {
-  return isRequired ? type : `${type} | undefined`;
-}
-var ZodDeserialzer = class {
-  circularRefTracker = /* @__PURE__ */ new Set();
-  #spec;
-  #onRef;
-  constructor(spec, onRef) {
-    this.#spec = spec;
-    this.#onRef = onRef;
-  }
-  /**
-   * Handle objects (properties, additionalProperties).
-   */
-  object(schema, required = false) {
-    const properties = schema.properties || {};
-    const propEntries = Object.entries(properties).map(([key, propSchema]) => {
-      const isRequired = (schema.required ?? []).includes(key);
-      const zodPart = this.handle(propSchema, isRequired);
-      return `'${key}': ${zodPart}`;
-    });
-    let additionalProps = "";
-    if (schema.additionalProperties) {
-      if (typeof schema.additionalProperties === "object") {
-        const addPropZod = this.handle(schema.additionalProperties, true);
-        additionalProps = `.catchall(${addPropZod})`;
-      } else if (schema.additionalProperties === true) {
-        additionalProps = `.catchall(z.unknown())`;
-      }
-    }
-    const objectSchema = `z.object({${propEntries.join(", ")}})${additionalProps}`;
-    return `${objectSchema}${appendOptional2(required)}`;
-  }
-  /**
-   * Handle arrays (items could be a single schema or a tuple (array of schemas)).
-   * In JSON Schema 2020-12, `items` can be an array → tuple style.
-   */
-  array(schema, required = false) {
-    const { items } = schema;
-    if (!items) {
-      return `z.array(z.unknown())${appendOptional2(required)}`;
-    }
-    if (Array.isArray(items)) {
-      const tupleItems = items.map((sub) => this.handle(sub, true));
-      const base = `z.tuple([${tupleItems.join(", ")}])`;
-      return `${base}${appendOptional2(required)}`;
-    }
-    const itemsSchema = this.handle(items, true);
-    return `z.array(${itemsSchema})${appendOptional2(required)}`;
-  }
-  // oneOf() {}
-  // enum() {}
-  /**
-   * Convert a basic type (string | number | boolean | object | array, etc.) to Zod.
-   * We'll also handle .optional() if needed.
-   */
-  normal(type, schema, required = false) {
-    switch (type) {
-      case "string":
-        return this.string(schema, required);
-      case "number":
-      case "integer":
-        return this.number(schema, required);
-      case "boolean":
-        return `z.boolean()${appendDefault(schema.default)}${appendOptional2(required)}`;
-      case "object":
-        return this.object(schema, required);
-      case "array":
-        return this.array(schema, required);
-      case "null":
-        return `z.null()${appendOptional2(required)}`;
-      default:
-        return `z.unknown()${appendOptional2(required)}`;
-    }
-  }
-  ref($ref, required) {
-    const schemaName = cleanRef($ref).split("/").pop();
-    if (this.circularRefTracker.has(schemaName)) {
-      return schemaName;
-    }
-    this.circularRefTracker.add(schemaName);
-    this.#onRef?.(
-      schemaName,
-      this.handle(followRef(this.#spec, $ref), required)
-    );
-    this.circularRefTracker.delete(schemaName);
-    return schemaName;
-  }
-  allOf(schemas) {
-    const allOfSchemas = schemas.map((sub) => this.handle(sub, true));
-    return allOfSchemas.length ? `z.intersection(${allOfSchemas.join(", ")})` : allOfSchemas[0];
-  }
-  anyOf(schemas, required) {
-    const anyOfSchemas = schemas.map((sub) => this.handle(sub, false));
-    return anyOfSchemas.length > 1 ? `z.union([${anyOfSchemas.join(", ")}])${appendOptional2(required)}` : (
-      // Handle an invalid anyOf with one schema
-      anyOfSchemas[0]
-    );
-  }
-  oneOf(schemas, required) {
-    const oneOfSchemas = schemas.map((sub) => {
-      if ("$ref" in sub) {
-        const { model } = parseRef(sub.$ref);
-        if (this.circularRefTracker.has(model)) {
-          return model;
-        }
-      }
-      return this.handle(sub, false);
-    });
-    return oneOfSchemas.length > 1 ? `z.union([${oneOfSchemas.join(", ")}])${appendOptional2(required)}` : (
-      // Handle an invalid oneOf with one schema
-      oneOfSchemas[0]
-    );
-  }
-  enum(values, required) {
-    const enumVals = values.map((val) => JSON.stringify(val)).join(", ");
-    return `z.enum([${enumVals}])${appendOptional2(required)}`;
-  }
-  /**
-   * Handle a `string` schema with possible format keywords (JSON Schema).
-   */
-  string(schema, required) {
-    let base = "z.string()";
-    switch (schema.format) {
-      case "date-time":
-      case "datetime":
-        base = "z.coerce.date()";
-        break;
-      case "date":
-        base = "z.coerce.date() /* or z.string() if you want raw date strings */";
-        break;
-      case "time":
-        base = "z.string() /* optionally add .regex(...) for HH:MM:SS format */";
-        break;
-      case "email":
-        base = "z.string().email()";
-        break;
-      case "uuid":
-        base = "z.string().uuid()";
-        break;
-      case "url":
-      case "uri":
-        base = "z.string().url()";
-        break;
-      case "ipv4":
-        base = 'z.string().ip({version: "v4"})';
-        break;
-      case "ipv6":
-        base = 'z.string().ip({version: "v6"})';
-        break;
-      case "phone":
-        base = "z.string() /* or add .regex(...) for phone formats */";
-        break;
-      case "byte":
-      case "binary":
-        base = "z.instanceof(Blob) /* consider base64 check if needed */";
-        break;
-      case "int64":
-        base = "z.string() /* or z.bigint() if your app can handle it */";
-        break;
-      default:
-        break;
-    }
-    return `${base}${appendDefault(schema.default)}${appendOptional2(required)}`;
-  }
-  /**
-   * Handle number/integer constraints from OpenAPI/JSON Schema.
-   * In 3.1, exclusiveMinimum/Maximum hold the actual numeric threshold,
-   * rather than a boolean toggling `minimum`/`maximum`.
-   */
-  number(schema, required) {
-    let defaultValue = schema.default !== void 0 ? `.default(${schema.default})` : ``;
-    let base = "z.number()";
-    if (schema.format === "int64") {
-      base = "z.bigint()";
-      if (schema.default !== void 0) {
-        defaultValue = `.default(BigInt(${schema.default}))`;
-      }
-    }
-    if (schema.format === "int32") {
-      base += ".int()";
-    }
-    if (typeof schema.exclusiveMinimum === "number") {
-      base += `.gt(${schema.exclusiveMinimum})`;
-    }
-    if (typeof schema.exclusiveMaximum === "number") {
-      base += `.lt(${schema.exclusiveMaximum})`;
-    }
-    if (typeof schema.minimum === "number") {
-      base += schema.format === "int64" ? `.min(BigInt(${schema.minimum}))` : `.min(${schema.minimum})`;
-    }
-    if (typeof schema.maximum === "number") {
-      base += schema.format === "int64" ? `.max(BigInt(${schema.maximum}))` : `.max(${schema.maximum})`;
-    }
-    if (typeof schema.multipleOf === "number") {
-      base += `.refine((val) => Number.isInteger(val / ${schema.multipleOf}), "Must be a multiple of ${schema.multipleOf}")`;
-    }
-    return `${base}${defaultValue}${appendOptional2(required)}`;
-  }
-  handle(schema, required) {
-    if (isRef(schema)) {
-      return this.ref(schema.$ref, required);
-    }
-    if (schema.allOf && Array.isArray(schema.allOf)) {
-      return this.allOf(schema.allOf ?? []);
-    }
-    if (schema.anyOf && Array.isArray(schema.anyOf)) {
-      return this.anyOf(schema.anyOf ?? [], required);
-    }
-    if (schema.oneOf && Array.isArray(schema.oneOf)) {
-      return this.oneOf(schema.oneOf ?? [], required);
-    }
-    if (schema.enum && Array.isArray(schema.enum)) {
-      return this.enum(schema.enum, required);
-    }
-    const types = Array.isArray(schema.type) ? schema.type : schema.type ? [schema.type] : [];
-    if (!types.length) {
-      return `z.unknown()${appendOptional2(required)}`;
-    }
-    if (types.length > 1) {
-      const realTypes = types.filter((t) => t !== "null");
-      if (realTypes.length === 1 && types.includes("null")) {
-        const typeZod = this.normal(realTypes[0], schema, false);
-        return `${typeZod}.nullable()${appendOptional2(required)}`;
-      }
-      const subSchemas = types.map((t) => this.normal(t, schema, false));
-      return `z.union([${subSchemas.join(", ")}])${appendOptional2(required)}`;
-    }
-    return this.normal(types[0], schema, required);
-  }
-};
-function appendOptional2(isRequired) {
-  return isRequired ? "" : ".optional()";
-}
-function appendDefault(defaultValue) {
-  return defaultValue !== void 0 ? `.default(${JSON.stringify(defaultValue)})` : "";
-}
-var responses = {
-  "400": "BadRequest",
-  "401": "Unauthorized",
-  "402": "PaymentRequired",
-  "403": "Forbidden",
-  "404": "NotFound",
-  "405": "MethodNotAllowed",
-  "406": "NotAcceptable",
-  "409": "Conflict",
-  "413": "PayloadTooLarge",
-  "410": "Gone",
-  "422": "UnprocessableEntity",
-  "429": "TooManyRequests",
-  "500": "InternalServerError",
-  "501": "NotImplemented",
-  "502": "BadGateway",
-  "503": "ServiceUnavailable",
-  "504": "GatewayTimeout"
-};
-var defaults = {
-  target: "javascript",
-  style: "github",
-  operationId: (operation, path, method) => {
-    if (operation.operationId) {
-      return spinalcase2(operation.operationId);
-    }
-    return camelcase2(`${method} ${path.replace(/[\\/\\{\\}]/g, " ").trim()}`);
-  }
-};
-function generateCode(config) {
-  const commonSchemas = {};
-  const zodDeserialzer = new ZodDeserialzer(config.spec);
-  const groups = {};
-  const outputs = {};
-  for (const [path, methods2] of Object.entries(config.spec.paths ?? {})) {
-    for (const [method, operation] of Object.entries(methods2)) {
-      const formatOperationId = config.operationId ?? defaults.operationId;
-      const operationName = formatOperationId(operation, path, method);
-      console.log(`Processing ${method} ${path}`);
-      const groupName = (operation.tags ?? ["unknown"])[0];
-      groups[groupName] ??= [];
-      const inputs = {};
-      const additionalProperties = [];
-      for (const param of operation.parameters ?? []) {
-        if (isRef(param)) {
-          throw new Error(`Found reference in parameter ${param.$ref}`);
-        }
-        if (!param.schema) {
-          throw new Error(`Schema not found for parameter ${param.name}`);
-        }
-        inputs[param.name] = {
-          in: param.in,
-          schema: ""
-        };
-        additionalProperties.push(param);
-      }
-      const security2 = operation.security ?? [];
-      const securitySchemas = config.spec.components?.securitySchemes ?? {};
-      const securityOptions = securityToOptions(security2, securitySchemas);
-      Object.assign(inputs, securityOptions);
-      additionalProperties.push(
-        ...Object.entries(securityOptions).map(
-          ([name, value]) => ({
-            name,
-            required: false,
-            schema: {
-              type: "string"
-            },
-            in: value.in
-          })
-        )
-      );
-      const types = {};
-      const shortContenTypeMap = {
-        "application/json": "json",
-        "application/x-www-form-urlencoded": "urlencoded",
-        "multipart/form-data": "formdata",
-        "application/xml": "xml",
-        "text/plain": "text"
-      };
-      let contentType;
-      if (operation.requestBody && Object.keys(operation.requestBody).length) {
-        const content = isRef(operation.requestBody) ? get2(followRef(config.spec, operation.requestBody.$ref), ["content"]) : operation.requestBody.content;
-        for (const type in content) {
-          const ctSchema = isRef(content[type].schema) ? followRef(config.spec, content[type].schema.$ref) : content[type].schema;
-          if (!ctSchema) {
-            console.warn(`Schema not found for ${type}`);
-            continue;
-          }
-          const schema = merge({}, ctSchema, {
-            required: additionalProperties.filter((p) => p.required).map((p) => p.name),
-            properties: additionalProperties.reduce(
-              (acc, p) => ({
-                ...acc,
-                [p.name]: p.schema
-              }),
-              {}
-            )
-          });
-          for (const [name] of Object.entries(ctSchema.properties ?? {})) {
-            inputs[name] = {
-              in: "body",
-              schema: ""
-            };
-          }
-          types[shortContenTypeMap[type]] = zodDeserialzer.handle(schema, true);
-        }
-        if (content["application/json"]) {
-          contentType = "json";
-        } else if (content["application/x-www-form-urlencoded"]) {
-          contentType = "urlencoded";
-        } else if (content["multipart/form-data"]) {
-          contentType = "formdata";
-        } else {
-          contentType = "json";
-        }
-      } else {
-        const properties = additionalProperties.reduce(
-          (acc, p) => ({
-            ...acc,
-            [p.name]: p.schema
-          }),
-          {}
-        );
-        types[shortContenTypeMap["application/json"]] = zodDeserialzer.handle(
-          {
-            type: "object",
-            required: additionalProperties.filter((p) => p.required).map((p) => p.name),
-            properties
-          },
-          true
-        );
-      }
-      const errors = [];
-      operation.responses ??= {};
-      let foundResponse = false;
-      const output = [`import z from 'zod';`];
-      for (const status in operation.responses) {
-        const response = operation.responses[status];
-        const statusCode = +status;
-        if (statusCode >= 400) {
-          errors.push(responses[status] ?? "ProblematicResponse");
-        }
-        if (statusCode >= 200 && statusCode < 300) {
-          foundResponse = true;
-          const responseContent = get2(response, ["content"]);
-          const isJson = responseContent && responseContent["application/json"];
-          const imports = [];
-          const typeScriptDeserialzer = new TypeScriptDeserialzer(
-            config.spec,
-            (schemaName, zod) => {
-              commonSchemas[schemaName] = zod;
-              imports.push({
-                defaultImport: void 0,
-                isTypeOnly: true,
-                moduleSpecifier: `../models/${schemaName}.ts`,
-                namedImports: [{ isTypeOnly: true, name: schemaName }],
-                namespaceImport: void 0
-              });
-            }
-          );
-          const responseSchema = isJson ? typeScriptDeserialzer.handle(
-            responseContent["application/json"].schema,
-            true
-          ) : "ReadableStream";
-          for (const it of mergeImports(imports)) {
-            const singleImport = it.defaultImport ?? it.namespaceImport;
-            if (singleImport && responseSchema.includes(singleImport)) {
-              output.push(importsToString(it).join("\n"));
-            } else if (it.namedImports.length) {
-              for (const namedImport of it.namedImports) {
-                if (responseSchema.includes(namedImport.name)) {
-                  output.push(importsToString(it).join("\n"));
-                }
-              }
-            }
-          }
-          output.push(
-            `export type ${pascalcase2(operationName + " output")} = ${responseSchema}`
-          );
-        }
-      }
-      if (!foundResponse) {
-        output.push(
-          `export type ${pascalcase2(operationName + " output")} = void`
-        );
-      }
-      outputs[`${spinalcase2(operationName)}.ts`] = output.join("\n");
-      groups[groupName].push({
-        name: operationName,
-        type: "http",
-        inputs,
-        errors: errors.length ? errors : ["ServerError"],
-        contentType,
-        schemas: types,
-        formatOutput: () => ({
-          import: pascalcase2(operationName + " output"),
-          use: pascalcase2(operationName + " output")
-        }),
-        trigger: {
-          path,
-          method
-        }
-      });
-    }
-  }
-  return { groups, commonSchemas, outputs };
-}
-var interceptors_default = "export interface Interceptor {\n  before?: (request: Request) => Promise<Request> | Request;\n  after?: (response: Response) => Promise<Response> | Response;\n}\n\nexport const createDefaultHeadersInterceptor = (\n  getHeaders: () => Record<string, string | undefined>,\n) => {\n  return {\n    before(request: Request) {\n      const headers = getHeaders();\n\n      for (const [key, value] of Object.entries(headers)) {\n        // Only set the header if it doesn't already exist and has a value\n        if (value !== undefined && !request.headers.has(key)) {\n          request.headers.set(key, value);\n        }\n      }\n\n      return request;\n    },\n  };\n};\n\nexport const createBaseUrlInterceptor = (getBaseUrl: () => string) => {\n  return {\n    before(request: Request) {\n      const baseUrl = getBaseUrl();\n      if (request.url.startsWith('local://')) {\n        return new Request(request.url.replace('local://', baseUrl), request);\n      }\n      return request;\n    },\n  };\n};\n\nexport const logInterceptor = {\n  before(request: Request) {\n    console.log('Request', request);\n    return request;\n  },\n  after(response: Response) {\n    console.log('Response', response);\n    return response;\n  },\n};\n";
-var parse_response_default = "import { parse } from 'fast-content-type-parse';\n\nexport async function handleError(response: Response) {\n  try {\n    if (response.status >= 400 && response.status < 500) {\n      const body = (await response.json()) as Record<string, any>;\n      return {\n        status: response.status,\n        body: body,\n      };\n    }\n    return new Error(\n      `An error occurred while fetching the data. Status: ${response.status}`,\n    );\n  } catch (error) {\n    return error as any;\n  }\n}\n\nasync function handleChunkedResponse(response: Response, contentType: string) {\n  const { type } = parse(contentType);\n\n  switch (type) {\n    case 'application/json': {\n      let buffer = '';\n      const reader = response.body!.getReader();\n      const decoder = new TextDecoder();\n      while (true) {\n        const { value, done } = await reader.read();\n        if (done) break;\n        buffer += decoder.decode(value);\n      }\n      return JSON.parse(buffer);\n    }\n    case 'text/html':\n    case 'text/plain': {\n      let buffer = '';\n      const reader = response.body!.getReader();\n      const decoder = new TextDecoder();\n      while (true) {\n        const { value, done } = await reader.read();\n        if (done) break;\n        buffer += decoder.decode(value);\n      }\n      return buffer;\n    }\n    default:\n      return response.body;\n  }\n}\n\nexport async function parseResponse(response: Response) {\n  const contentType = response.headers.get('Content-Type');\n  if (!contentType) {\n    throw new Error('Content-Type header is missing');\n  }\n\n  if (response.status === 204) {\n    return null;\n  }\n  const isChunked = response.headers.get('Transfer-Encoding') === 'chunked';\n  if (isChunked) {\n    return response.body!;\n    // return handleChunkedResponse(response, contentType);\n  }\n\n  const { type } = parse(contentType);\n  switch (type) {\n    case 'application/json':\n      return response.json();\n    case 'text/plain':\n      return response.text();\n    case 'text/html':\n      return response.text();\n    case 'text/xml':\n    case 'application/xml':\n      return response.text();\n    case 'application/x-www-form-urlencoded': {\n      const text = await response.text();\n      return Object.fromEntries(new URLSearchParams(text));\n    }\n    case 'multipart/form-data':\n      return response.formData();\n    default:\n      throw new Error(`Unsupported content type: ${contentType}`);\n  }\n}\n";
-var parser_default = "import { z } from 'zod';\n\nexport type ParseError<T extends z.ZodType<any, any, any>> = {\n  kind: 'parse';\n} & z.inferFlattenedErrors<T>;\n\nexport function parse<T extends z.ZodType>(\n  schema: T,\n  input: unknown,\n) {\n  const result = schema.safeParse(input);\n  if (!result.success) {\n    const errors = result.error.flatten((issue) => issue);\n    return [null, errors];\n  }\n  return [result.data as z.infer<T>, null];\n}\n";
-var request_default = "export type Method = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';\nexport type ContentType = 'xml' | 'json' | 'urlencoded' | 'multipart';\nexport type Endpoint =\n  | `${ContentType} ${Method} ${string}`\n  | `${Method} ${string}`;\n\nexport type BodyInit =\n  | ArrayBuffer\n  | Blob\n  | FormData\n  | URLSearchParams\n  | null\n  | string;\n\nexport function createUrl(path: string, query: URLSearchParams) {\n  const url = new URL(path, `local://`);\n  url.search = query.toString();\n  return url;\n}\n\nfunction template(\n  templateString: string,\n  templateVariables: Record<string, any>,\n): string {\n  const nargs = /{([0-9a-zA-Z_]+)}/g;\n  return templateString.replace(nargs, (match, key: string, index: number) => {\n    // Handle escaped double braces\n    if (\n      templateString[index - 1] === '{' &&\n      templateString[index + match.length] === '}'\n    ) {\n      return key;\n    }\n\n    const result = key in templateVariables ? templateVariables[key] : null;\n    return result === null || result === undefined ? '' : String(result);\n  });\n}\n\ntype Input = Record<string, any>;\ntype Props = {\n  inputHeaders: string[];\n  inputQuery: string[];\n  inputBody: string[];\n  inputParams: string[];\n};\n\nabstract class Serializer {\n  constructor(\n    protected input: Input,\n    protected props: Props,\n  ) {}\n  abstract getBody(): BodyInit | null;\n  abstract getHeaders(): Record<string, string>;\n  serialize(): Serialized {\n    const headers = new Headers({});\n    for (const header of this.props.inputHeaders) {\n      headers.set(header, this.input[header]);\n    }\n\n    const query = new URLSearchParams();\n    for (const key of this.props.inputQuery) {\n      const value = this.input[key];\n      if (value !== undefined) {\n        query.set(key, String(value));\n      }\n    }\n\n    const params = this.props.inputParams.reduce<Record<string, any>>(\n      (acc, key) => {\n        acc[key] = this.input[key];\n        return acc;\n      },\n      {},\n    );\n\n    return {\n      body: this.getBody(),\n      query,\n      params,\n      headers: this.getHeaders(),\n    };\n  }\n}\n\ninterface Serialized {\n  body: BodyInit | null;\n  query: URLSearchParams;\n  params: Record<string, any>;\n  headers: Record<string, string>;\n}\n\nclass JsonSerializer extends Serializer {\n  getBody(): BodyInit | null {\n    const body: Record<string, any> = {};\n    for (const prop of this.props.inputBody) {\n      body[prop] = this.input[prop];\n    }\n    return JSON.stringify(body);\n  }\n  getHeaders(): Record<string, string> {\n    return {\n      'Content-Type': 'application/json',\n      Accept: 'application/json',\n    };\n  }\n}\n\nclass UrlencodedSerializer extends Serializer {\n  getBody(): BodyInit | null {\n    const body = new URLSearchParams();\n    for (const prop of this.props.inputBody) {\n      body.set(prop, this.input[prop]);\n    }\n    return body;\n  }\n  getHeaders(): Record<string, string> {\n    return {};\n  }\n}\n\nclass NoBodySerializer extends Serializer {\n  getBody(): BodyInit | null {\n    return null;\n  }\n  getHeaders(): Record<string, string> {\n    return {};\n  }\n}\n\nclass FormDataSerializer extends Serializer {\n  getBody(): BodyInit | null {\n    const body = new FormData();\n    for (const prop of this.props.inputBody) {\n      body.append(prop, this.input[prop]);\n    }\n    return body;\n  }\n  getHeaders(): Record<string, string> {\n    return {};\n  }\n}\n\nexport function json(input: Input, props: Props) {\n  return new JsonSerializer(input, props).serialize();\n}\nexport function urlencoded(input: Input, props: Props) {\n  return new UrlencodedSerializer(input, props).serialize();\n}\nexport function nobody(input: Input, props: Props) {\n  return new NoBodySerializer(input, props).serialize();\n}\nexport function formdata(input: Input, props: Props) {\n  return new FormDataSerializer(input, props).serialize();\n}\n\nexport function toRequest<T extends Endpoint>(\n  endpoint: T,\n  input: Serialized,\n): Request {\n  const [method, path] = endpoint.split(' ');\n  const pathVariable = template(path, input.params);\n\n  const url = createUrl(pathVariable, input.query);\n  return new Request(url, {\n    method: method,\n    headers: input.headers,\n    body: method === 'GET' ? undefined : input.body,\n  });\n}\n";
-var response_default = "export interface ApiResponse<Status extends number, Body extends unknown> {\n  kind: 'response';\n  status: Status;\n  body: Body;\n}\n\n// 4xx Client Errors\nexport type BadRequest = ApiResponse<400, { message: string }>;\nexport type Unauthorized = ApiResponse<401, { message: string }>;\nexport type PaymentRequired = ApiResponse<402, { message: string }>;\nexport type Forbidden = ApiResponse<403, { message: string }>;\nexport type NotFound = ApiResponse<404, { message: string }>;\nexport type MethodNotAllowed = ApiResponse<405, { message: string }>;\nexport type NotAcceptable = ApiResponse<406, { message: string }>;\nexport type Conflict = ApiResponse<409, { message: string }>;\nexport type Gone = ApiResponse<410, { message: string }>;\nexport type UnprocessableEntity = ApiResponse<422, { message: string; errors?: Record<string, string[]> }>;\nexport type TooManyRequests = ApiResponse<429, { message: string; retryAfter?: string }>;\nexport type PayloadTooLarge = ApiResponse<413, { message: string; }>;\nexport type UnsupportedMediaType = ApiResponse<415, { message: string; }>;\n\n// 5xx Server Errors\nexport type InternalServerError = ApiResponse<500, { message: string }>;\nexport type NotImplemented = ApiResponse<501, { message: string }>;\nexport type BadGateway = ApiResponse<502, { message: string }>;\nexport type ServiceUnavailable = ApiResponse<503, { message: string; retryAfter?: string }>;\nexport type GatewayTimeout = ApiResponse<504, { message: string }>;\n\nexport type ClientError =\n  | BadRequest\n  | Unauthorized\n  | PaymentRequired\n  | Forbidden\n  | NotFound\n  | MethodNotAllowed\n  | NotAcceptable\n  | Conflict\n  | Gone\n  | UnprocessableEntity\n  | TooManyRequests;\n\nexport type ServerError =\n  | InternalServerError\n  | NotImplemented\n  | BadGateway\n  | ServiceUnavailable\n  | GatewayTimeout;\n\nexport type ProblematicResponse = ClientError | ServerError;\n";
-var send_request_default = "import z from 'zod';\n\nimport type { Interceptor } from './interceptors.ts';\nimport { handleError, parseResponse } from './parse-response.ts';\nimport { parse } from './parser.ts';\n\nexport interface RequestSchema {\n  schema: z.ZodType;\n  toRequest: (input: any) => Request;\n}\n\nexport const fetchType = z\n  .function()\n  .args(z.instanceof(Request))\n  .returns(z.promise(z.instanceof(Response)))\n  .optional();\n\nexport async function sendRequest(\n  input: any,\n  route: RequestSchema,\n  options: {\n    fetch?: z.infer<typeof fetchType>;\n    interceptors?: Interceptor[];\n  },\n) {\n  const { interceptors = [] } = options;\n  const [parsedInput, parseError] = parse(route.schema, input);\n  if (parseError) {\n    return [null as never, { ...parseError, kind: 'parse' } as never] as const;\n  }\n\n  let request = route.toRequest(parsedInput as never);\n  for (const interceptor of interceptors) {\n    if (interceptor.before) {\n      request = await interceptor.before(request);\n    }\n  }\n\n  let response = await (options.fetch ?? fetch)(request);\n\n  for (let i = interceptors.length - 1; i >= 0; i--) {\n    const interceptor = interceptors[i];\n    if (interceptor.after) {\n      response = await interceptor.after(response.clone());\n    }\n  }\n\n  if (response.ok) {\n    const data = await parseResponse(response);\n    return [data as never, null] as const;\n  }\n  const error = await handleError(response);\n  return [null as never, { ...error, kind: 'response' }] as const;\n}\n";
-function security(spec) {
-  const security2 = spec.security || [];
-  const components = spec.components || {};
-  const securitySchemas = components.securitySchemes || {};
-  const paths = Object.values(spec.paths ?? {});
-  const options = securityToOptions(security2, securitySchemas);
-  for (const it of paths) {
-    for (const method of methods) {
-      const operation = it[method];
-      if (!operation) {
-        continue;
-      }
-      Object.assign(
-        options,
-        securityToOptions(operation.security || [], securitySchemas, "input")
-      );
-    }
-  }
-  return options;
-}
-async function generate(spec, settings) {
-  const { commonSchemas, groups, outputs } = generateCode({
-    spec,
-    style: "github",
-    target: "javascript"
-  });
-  const output = settings.mode === "full" ? join2(settings.output, "src") : settings.output;
-  const options = security(spec);
-  const clientFiles = generateClientSdk({
-    name: settings.name || "Client",
-    operations: groups,
-    servers: spec.servers?.map((server) => server.url) || [],
-    options
-  });
-  await writeFiles(output, {
-    "outputs/index.ts": "",
-    "inputs/index.ts": ""
-    // 'models/index.ts': '',
-    // 'README.md': readme,
-  });
-  await writeFiles(join2(output, "http"), {
-    "interceptors.ts": interceptors_default,
-    "parse-response.ts": parse_response_default,
-    "send-request.ts": send_request_default,
-    "response.ts": response_default,
-    "parser.ts": parser_default,
-    "request.ts": request_default
-  });
-  await writeFiles(join2(output, "outputs"), outputs);
-  const imports = Object.entries(commonSchemas).map(([name]) => name);
-  await writeFiles(output, {
-    ...clientFiles,
-    ...Object.fromEntries(
-      Object.entries(commonSchemas).map(([name, schema]) => [
-        `models/${name}.ts`,
-        [
-          `import { z } from 'zod';`,
-          ...exclude(imports, [name]).map(
-            (it) => `import type { ${it} } from './${it}.ts';`
-          ),
-          `export type ${name} = ${schema};`
-        ].join("\n")
-      ])
-    )
-  });
-  const folders = [
-    getFolderExports(output),
-    getFolderExports(join2(output, "outputs")),
-    getFolderExports(join2(output, "inputs")),
-    getFolderExports(join2(output, "http"))
-  ];
-  if (imports.length) {
-    folders.push(getFolderExports(join2(output, "models")));
-  }
-  const [index, outputIndex, inputsIndex, httpIndex, modelsIndex] = await Promise.all(folders);
-  await writeFiles(output, {
-    "index.ts": index,
-    "outputs/index.ts": outputIndex,
-    "inputs/index.ts": inputsIndex,
-    "http/index.ts": httpIndex,
-    ...imports.length ? { "models/index.ts": modelsIndex } : {}
-  });
-  if (settings.mode === "full") {
-    await writeFiles(settings.output, {
-      "package.json": {
-        ignoreIfExists: true,
-        content: `{"type":"module","main":"./src/index.ts","dependencies":{"fast-content-type-parse":"^3.0.0"}}`
-      }
-    });
-  }
-  await settings.formatCode?.({
-    output,
-    env: npmRunPathEnv()
-  });
-}
-function exclude(list, exclude2) {
-  return list.filter((it) => !exclude2.includes(it));
-}
-
-// packages/cli/src/lib/generate.ts
+import { generate } from "@sdk-it/typescript";
 var specOption = new Option(
   "-s, --spec <spec>",
   "Path to OpenAPI specification file"
@@ -1173,7 +38,7 @@ async function loadLocal(location) {
       return import(location);
     case ".yaml":
     case ".yml": {
-      const text = await await readFile2(location, "utf-8");
+      const text = await await readFile(location, "utf-8");
       return parse(text);
     }
     default: