@sdk-it/typescript 0.12.10 → 0.13.0

package/dist/index 4.js

@@ -1,1228 +0,0 @@
-// packages/typescript/src/lib/generate.ts
-import { join } from "node:path";
-import { npmRunPathEnv } from "npm-run-path";
-import { getFolderExports, methods, writeFiles } from "@sdk-it/core";
-
-// packages/typescript/src/lib/generator.ts
-import { get as get2, merge } from "lodash-es";
-import { camelcase as camelcase2, pascalcase, spinalcase as spinalcase2 } from "stringcase";
-
-// packages/typescript/src/lib/utils.ts
-import { get } from "lodash-es";
-import { removeDuplicates as removeDuplicates2 } from "@sdk-it/core";
-
-// packages/typescript/src/lib/sdk.ts
-import { camelcase, spinalcase } from "stringcase";
-import { removeDuplicates, toLitObject as toLitObject2 } from "@sdk-it/core";
-
-// packages/typescript/src/lib/client.ts
-import { toLitObject } from "@sdk-it/core";
-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} {
-  public options: ${spec.name}Options
-  constructor(options: ${spec.name}Options) {
-    this.options = 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]!;
-      }
-    }
-  }
-}`;
-};
-
-// packages/typescript/src/lib/sdk.ts
-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")}
-}`;
-  }
-};
-function generateInputs(operationsSet, commonZod) {
-  const commonImports = commonZod.keys().toArray();
-  const inputs = {};
-  for (const [name, operations] of Object.entries(operationsSet)) {
-    const output = [];
-    const imports = /* @__PURE__ */ new Set(['import { z } from "zod";']);
-    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] : toLitObject2(operation.schemas)};`;
-      const inputContent = schema;
-      for (const schema2 of commonImports) {
-        if (inputContent.includes(schema2)) {
-          imports.add(
-            `import { ${schema2} } from './schemas/${spinalcase(schema2)}.ts';`
-          );
-        }
-      }
-      output.push(inputContent);
-    }
-    inputs[`inputs/${spinalcase(name)}.ts`] = [...imports, ...output].join("\n") + "\n";
-  }
-  const schemas = commonZod.entries().reduce((acc, [name, schema]) => {
-    const output = [`import { z } from 'zod';`];
-    const content = `export const ${name} = ${schema};`;
-    for (const schema2 of commonImports) {
-      const preciseMatch = new RegExp(`\\b${schema2}\\b`);
-      if (preciseMatch.test(content) && schema2 !== name) {
-        output.push(
-          `import { ${schema2} } from './${spinalcase(schema2)}.ts';`
-        );
-      }
-    }
-    output.push(content);
-    return [
-      [`inputs/schemas/${spinalcase(name)}.ts`, output.join("\n")],
-      ...acc
-    ];
-  }, []);
-  return {
-    ...Object.fromEntries(schemas),
-    ...inputs
-  };
-}
-function generateSDK(spec) {
-  const emitter = new Emitter();
-  const schemaEndpoint = new SchemaEndpoint();
-  const errors = [];
-  for (const [name, operations] of Object.entries(spec.operations)) {
-    emitter.addImport(
-      `import * as ${camelcase(name)} from './inputs/${spinalcase(name)}.ts';`
-    );
-    schemaEndpoint.addImport(
-      `import * as ${camelcase(name)} from './inputs/${spinalcase(name)}.ts';`
-    );
-    for (const operation of operations) {
-      const schemaName = camelcase(`${operation.name} schema`);
-      const schemaRef = `${camelcase(name)}.${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}`
-          );
-        }
-      }
-      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 {
-    "client.ts": client_default(spec),
-    "schemas.ts": schemaEndpoint.complete(),
-    "endpoints.ts": emitter.complete()
-  };
-}
-
-// packages/typescript/src/lib/utils.ts
-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 {${removeDuplicates2(it.namedImports, (it2) => it2.name).map((n) => `${n.isTypeOnly ? "type" : ""} ${n.name}`).join(", ")}} from '${it.moduleSpecifier}'`;
-    }
-    throw new Error(`Invalid import ${JSON.stringify(it)}`);
-  });
-}
-function exclude2(list, exclude3) {
-  return list.filter((it) => !exclude3.includes(it));
-}
-function useImports(content, imports) {
-  const output = [];
-  for (const it of mergeImports(imports)) {
-    const singleImport = it.defaultImport ?? it.namespaceImport;
-    if (singleImport && content.includes(singleImport)) {
-      output.push(importsToString(it).join("\n"));
-    } else if (it.namedImports.length) {
-      for (const namedImport of it.namedImports) {
-        if (content.includes(namedImport.name)) {
-          output.push(importsToString(it).join("\n"));
-        }
-      }
-    }
-  }
-  return output;
-}
-
-// packages/typescript/src/lib/emitters/interface.ts
-var TypeScriptDeserialzer = class {
-  circularRefTracker = /* @__PURE__ */ new Set();
-  #spec;
-  #onRef;
-  constructor(spec, onRef) {
-    this.#spec = spec;
-    this.#onRef = onRef;
-  }
-  #stringifyKey = (key) => {
-    const reservedWords = [
-      "constructor",
-      "prototype",
-      "break",
-      "case",
-      "catch",
-      "class",
-      "const",
-      "continue",
-      "debugger",
-      "default",
-      "delete",
-      "do",
-      "else",
-      "export",
-      "extends",
-      "false",
-      "finally",
-      "for",
-      "function",
-      "if",
-      "import",
-      "in",
-      "instanceof",
-      "new",
-      "null",
-      "return",
-      "super",
-      "switch",
-      "this",
-      "throw",
-      "true",
-      "try",
-      "typeof",
-      "var",
-      "void",
-      "while",
-      "with",
-      "yield"
-    ];
-    if (reservedWords.includes(key)) {
-      return `'${key}'`;
-    }
-    if (key.trim() === "") {
-      return `'${key}'`;
-    }
-    const firstChar = key.charAt(0);
-    const validFirstChar = firstChar >= "a" && firstChar <= "z" || firstChar >= "A" && firstChar <= "Z" || firstChar === "_" || firstChar === "$";
-    if (!validFirstChar) {
-      return `'${key.replace(/'/g, "\\'")}'`;
-    }
-    for (let i = 1; i < key.length; i++) {
-      const char = key.charAt(i);
-      const validChar = char >= "a" && char <= "z" || char >= "A" && char <= "Z" || char >= "0" && char <= "9" || char === "_" || char === "$";
-      if (!validChar) {
-        return `'${key.replace(/'/g, "\\'")}'`;
-      }
-    }
-    return key;
-  };
-  #stringifyKeyV2 = (value) => {
-    return `'${value}'`;
-  };
-  /**
-   * 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 `${this.#stringifyKeyV2(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`;
-}
-
-// packages/typescript/src/lib/emitters/zod.ts
-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));
-    if (allOfSchemas.length === 1) {
-      return allOfSchemas[0];
-    }
-    return allOfSchemas.length ? `z.intersection(${allOfSchemas.join(", ")})` : allOfSchemas[0];
-  }
-  anyOf(schemas, required) {
-    const anyOfSchemas = schemas.map((sub) => this.handle(sub, false));
-    if (anyOfSchemas.length === 1) {
-      return anyOfSchemas[0];
-    }
-    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);
-    });
-    if (oneOfSchemas.length === 1) {
-      return oneOfSchemas[0];
-    }
-    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)})` : "";
-}
-
-// packages/typescript/src/lib/generator.ts
-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 commonZod = /* @__PURE__ */ new Map();
-  const commonZodImports = [];
-  const zodDeserialzer = new ZodDeserialzer(config.spec, (model, schema) => {
-    commonZod.set(model, schema);
-    commonZodImports.push({
-      defaultImport: void 0,
-      isTypeOnly: true,
-      moduleSpecifier: `./${model}.ts`,
-      namedImports: [{ isTypeOnly: true, name: model }],
-      namespaceImport: void 0
-    });
-  });
-  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";
-          output.push(...useImports(responseSchema, imports));
-          output.push(
-            `export type ${pascalcase(operationName + " output")} = ${responseSchema}`
-          );
-        }
-      }
-      if (!foundResponse) {
-        output.push(
-          `export type ${pascalcase(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: pascalcase(operationName + " output"),
-          use: pascalcase(operationName + " output")
-        }),
-        trigger: {
-          path,
-          method
-        }
-      });
-    }
-  }
-  return { groups, commonSchemas, commonZod, outputs };
-}
-
-// packages/typescript/src/lib/http/interceptors.txt
-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";
-
-// packages/typescript/src/lib/http/parse-response.txt
-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";
-
-// packages/typescript/src/lib/http/parser.txt
-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";
-
-// packages/typescript/src/lib/http/request.txt
-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  protected input: Input;\n  protected props: Props;\n\n  constructor(\n    input: Input,\n    props: Props,\n  ) {\n    this.input = input;\n    this.props = props;\n  }\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";
-
-// packages/typescript/src/lib/http/response.txt
-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";
-
-// packages/typescript/src/lib/http/send-request.txt
-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";
-
-// packages/typescript/src/lib/generate.ts
-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, commonZod } = generateCode({
-    spec,
-    style: "github",
-    target: "javascript"
-  });
-  const output = settings.mode === "full" ? join(settings.output, "src") : settings.output;
-  const options = security(spec);
-  const clientFiles = generateSDK({
-    name: settings.name || "Client",
-    operations: groups,
-    servers: spec.servers?.map((server) => server.url) || [],
-    options
-  });
-  const inputFiles = generateInputs(groups, commonZod);
-  await writeFiles(output, {
-    "outputs/.gitkeep": "",
-    "inputs/.gitkeep": "",
-    "models/.getkeep": ""
-    // 'README.md': readme,
-  });
-  await writeFiles(join(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(join(output, "outputs"), outputs);
-  const modelsImports = Object.entries(commonSchemas).map(([name]) => name);
-  await writeFiles(output, {
-    ...clientFiles,
-    ...inputFiles,
-    ...Object.fromEntries(
-      Object.entries(commonSchemas).map(([name, schema]) => [
-        `models/${name}.ts`,
-        [
-          `import { z } from 'zod';`,
-          ...exclude2(modelsImports, [name]).map(
-            (it) => `import type { ${it} } from './${it}.ts';`
-          ),
-          `export type ${name} = ${schema};`
-        ].join("\n")
-      ])
-    )
-  });
-  const folders = [
-    getFolderExports(output),
-    getFolderExports(join(output, "outputs")),
-    getFolderExports(
-      join(output, "inputs"),
-      ["ts"],
-      (dirent) => dirent.isDirectory() && dirent.name === "schemas"
-    ),
-    getFolderExports(join(output, "http"))
-  ];
-  if (modelsImports.length) {
-    folders.push(getFolderExports(join(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 || null,
-    "http/index.ts": httpIndex,
-    ...modelsImports.length ? { "models/index.ts": modelsIndex } : {}
-  });
-  if (settings.mode === "full") {
-    await writeFiles(settings.output, {
-      "package.json": {
-        ignoreIfExists: true,
-        content: JSON.stringify(
-          {
-            type: "module",
-            main: "./src/index.ts",
-            dependencies: { "fast-content-type-parse": "^3.0.0" }
-          },
-          null,
-          2
-        )
-      },
-      "tsconfig.json": {
-        ignoreIfExists: false,
-        content: JSON.stringify(
-          {
-            compilerOptions: {
-              skipLibCheck: true,
-              skipDefaultLibCheck: true,
-              target: "ESNext",
-              module: "ESNext",
-              noEmit: true,
-              allowImportingTsExtensions: true,
-              verbatimModuleSyntax: true,
-              baseUrl: ".",
-              moduleResolution: "bundler"
-            },
-            include: ["**/*.ts"]
-          },
-          null,
-          2
-        )
-      }
-    });
-  }
-  await settings.formatCode?.({
-    output,
-    env: npmRunPathEnv()
-  });
-}
-
-// packages/typescript/src/lib/watcher.ts
-import { watch as nodeWatch } from "node:fs/promises";
-import { debounceTime, from } from "rxjs";
-function watch(path) {
-  return from(
-    nodeWatch(path, {
-      persistent: true,
-      recursive: true
-    })
-  ).pipe(debounceTime(400));
-}
-export {
-  generate,
-  watch
-};
-//# sourceMappingURL=index.js.map