@sdk-it/cli 0.44.0 → 0.46.0

package/dist/index.js

@@ -1,2765 +1,406 @@
-#!/usr/bin/env node
-
-// packages/cli/src/lib/cli.ts
-import { Command as Command7, program } from "commander";
-import { readJson as readJson2 } from "@sdk-it/core/file-system.js";
-
-// packages/cli/src/lib/commands/init.ts
-import { checkbox, confirm, input, select } from "@inquirer/prompts";
-import { Command } from "commander";
-import { writeFile } from "node:fs/promises";
+// packages/cli/src/lib/project.ts
 import { resolve as resolve3 } from "node:path";
 
-// packages/cli/src/lib/commands/find-framework.ts
-import { resolve } from "node:path";
-import { exist } from "@sdk-it/core/file-system.js";
-var monorepoIndicators = {
-  lerna: () => exist(resolve(process.cwd(), "lerna.json")),
-  nx: () => exist(resolve(process.cwd(), "nx.json")),
-  pnpm: () => exist(resolve(process.cwd(), "pnpm-workspace.yaml")),
-  rush: () => exist(resolve(process.cwd(), "rush.json"))
-};
-async function detectMonorepo() {
-  for (const [indicator, check] of Object.entries(monorepoIndicators)) {
-    if (await check()) {
-      return indicator;
-    }
-  }
-  return void 0;
-}
-
-// packages/cli/src/lib/commands/find-spec-file.ts
-import { resolve as resolve2 } from "node:path";
-import { exist as exist2 } from "@sdk-it/core/file-system.js";
-async function findSpecFile() {
-  const commonNames = [
-    "openapi.json",
-    "openapi.yaml",
-    "openapi.yml",
-    "swagger.json",
-    "swagger.yaml",
-    "swagger.yml",
-    "api.json",
-    "api.yaml",
-    "api.yml",
-    "spec.json",
-    "spec.yaml",
-    "spec.yml",
-    "schema.json",
-    "schema.yaml",
-    "schema.yml"
-  ];
-  for (const name of commonNames) {
-    if (await exist2(resolve2(process.cwd(), name))) {
-      return `./${name}`;
-    }
+// packages/cli/src/lib/project/analysis.ts
+import { createRequire } from "node:module";
+import ts from "typescript";
+import { defaultTypesMap, getProgram } from "@sdk-it/core";
+import { analyze } from "@sdk-it/generic";
+import { responseAnalyzer as honoResponseAnalyzer } from "@sdk-it/hono";
+async function analyzeProject(tsconfig, config) {
+  const framework = resolveFramework(tsconfig, config.framework);
+  if (framework === "auto") {
+    throw new Error(
+      `Could not detect a supported framework from ${config.tsconfig}. Set framework to 'hono' to select it explicitly.`
+    );
   }
-  return void 0;
-}
-
-// packages/cli/src/lib/commands/guess-default-package-name.ts
-import { join } from "node:path";
-import { readJson } from "@sdk-it/core/file-system.js";
-async function guessTypescriptPackageName(consideringMultipleGenerator) {
-  try {
-    const packageJson = await readJson(
-      join(process.cwd(), "package.json")
+  const prisma = config.preset === "none" ? void 0 : detectPrisma(tsconfig);
+  if (config.preset === "prisma" && !prisma) {
+    throw new Error(
+      `Prisma preset was requested, but no Prisma client import was found in ${tsconfig}. Run prisma generate or set preset to 'none'.`
     );
-    if (packageJson.name) {
-      const match = packageJson.name.match(/^@([^/]+)/);
-      if (match) {
-        const scope = match[1];
-        return consideringMultipleGenerator ? `@${scope}/ts-sdk` : `@${scope}/sdk`;
-      }
-    }
-  } catch {
   }
-  return consideringMultipleGenerator ? "ts-sdk" : "sdk";
-}
-
-// packages/cli/src/lib/commands/init.ts
-var specInput = async (defaultValue) => {
-  return input({
-    message: "OpenAPI or Postman specification file path:",
-    default: defaultValue || "./openapi.json"
-  });
-};
-var generatorConfigs = {
-  typescript: {
-    name: async (isMultipleGenerators = false) => {
-      const defaultName = await guessTypescriptPackageName(isMultipleGenerators);
-      return input({
-        message: "SDK package name:",
-        default: defaultName
-      });
-    },
-    spec: specInput,
-    output: async () => {
-      let defaultValue = "./ts-sdk";
-      const monorepo = await detectMonorepo();
-      if (monorepo === "nx") {
-        defaultValue = "./packages/ts-sdk";
-      }
-      return await input({
-        message: "Output directory:",
-        default: defaultValue
-      });
-    },
-    mode: async () => {
-      const options = {
-        mode: "full",
-        install: false
-      };
-      options.mode = await select({
-        message: "Generation mode:",
-        choices: [
-          {
-            name: "Full (generates package.json and tsconfig.json)",
-            value: "full"
-          },
-          {
-            name: "Minimal (generates only the client TypeScript files)",
-            value: "minimal"
-          }
-        ],
-        default: options.mode
-      });
-      if (options.mode === "full") {
-        const installDeps = await confirm({
-          message: "Install dependencies automatically?",
-          default: true
-        });
-        options.install = installDeps;
-      }
-      return options;
-    },
-    pagination: async () => {
-      let pagination = {
-        guess: false
-      };
-      const result = await confirm({
-        message: "Enable pagination support?",
-        default: false
-      });
-      if (result) {
-        pagination.guess = await confirm({
-          message: "Would you like to guess pagination parameters?",
-          default: false
-        });
-      } else {
-        pagination = false;
+  const { paths, components } = await analyze(tsconfig, {
+    responseAnalyzer: honoResponseAnalyzer,
+    ...prisma ? {
+      imports: prisma.imports,
+      typesMap: {
+        ...defaultTypesMap,
+        Decimal: "string"
       }
-      return pagination;
-    },
-    readme: () => confirm({
-      message: "Generate README file?",
-      default: true
-    }),
-    defaultFormatter: () => confirm({
-      message: "Use default formatter (prettier)?",
-      default: true
-    }),
-    framework: () => input({
-      message: "Framework integrating with the SDK (optional):"
-    }),
-    formatter: () => input({
-      message: 'Custom formatter command (optional, e.g., "prettier $SDK_IT_OUTPUT --write"):'
-    })
-  },
-  python: {
-    name: () => input({
-      message: "SDK package name:",
-      default: "my-python-sdk"
-    }),
-    spec: specInput,
-    output: () => input({
-      message: "Output directory:",
-      default: "./python-sdk"
-    }),
-    mode: async () => {
-      const isMonorepo = await detectMonorepo();
-      return select({
-        message: "Generation mode:",
-        choices: [
-          {
-            name: "Full (generates complete project structure)",
-            value: "full"
-          },
-          {
-            name: "Minimal (generates only the client files)",
-            value: "minimal"
-          }
-        ],
-        default: isMonorepo ? "full" : "full"
-        // Default to full, especially for monorepos
-      }).then((value) => value);
-    },
-    formatter: () => input({
-      message: 'Custom formatter command (optional, e.g., "black $SDK_IT_OUTPUT" or "ruff format $SDK_IT_OUTPUT"):'
-    })
-  },
-  dart: {
-    name: () => input({
-      message: "SDK package name:",
-      default: "my-dart-sdk"
-    }),
-    spec: specInput,
-    output: () => input({
-      message: "Output directory:",
-      default: "./dart-sdk"
-    }),
-    mode: async () => {
-      const isMonorepo = await detectMonorepo();
-      return select({
-        message: "Generation mode:",
-        choices: [
-          {
-            name: "Full (generates complete project structure)",
-            value: "full"
-          },
-          {
-            name: "Minimal (generates only the client files)",
-            value: "minimal"
-          }
-        ],
-        default: isMonorepo ? "full" : "full"
-        // Default to full, especially for monorepos
-      }).then((value) => value);
+    } : {}
+  });
+  return {
+    openapi: "3.1.0",
+    info: {
+      title: "API",
+      version: "0.0.0"
     },
-    pagination: async () => {
-      let pagination = {
-        guess: false
-      };
-      const result = await confirm({
-        message: "Enable pagination support?",
-        default: false
-      });
-      if (result) {
-        pagination.guess = await confirm({
-          message: "Would you like to guess pagination parameters?",
-          default: false
-        });
-      } else {
-        pagination = false;
-      }
-      return pagination;
-    }
-  }
-};
-var init = new Command("init").description("Initialize SDK-IT configuration interactively").action(async () => {
-  console.log("Welcome to SDK-IT! Let's set up your configuration.\n");
-  const possibleSpecFile = await findSpecFile();
-  const monorepo = await detectMonorepo();
-  if (possibleSpecFile) {
-    console.log(`\u{1F50D} Auto-detected API specification: ${possibleSpecFile}`);
-  }
-  if (monorepo) {
-    console.log(`\u{1F4E6} Detected monorepo setup`);
-  }
-  if (possibleSpecFile || monorepo) {
-    console.log("");
-  }
-  const config = {
-    generators: {}
+    paths,
+    components
   };
-  const generators = await checkbox({
-    message: "Which SDK generators would you like to configure?",
-    loop: false,
-    instructions: false,
-    required: true,
-    choices: [
-      { name: "TypeScript", value: "typescript" },
-      { name: "Python", value: "python" },
-      { name: "Dart", value: "dart" }
-    ]
-  });
-  for (const generator of generators) {
-    console.log(`
-Configuring ${generator} generator:`);
-    if (generator === "typescript") {
-      const tsConfig = generatorConfigs.typescript;
-      const isMultipleGenerators = generators.length > 1;
-      const generatorConfig = {
-        spec: await tsConfig.spec(possibleSpecFile),
-        output: await tsConfig.output(),
-        name: await tsConfig.name(isMultipleGenerators),
-        defaultFormatter: await tsConfig.defaultFormatter(),
-        readme: await tsConfig.readme(),
-        pagination: await tsConfig.pagination(),
-        ...await tsConfig.mode()
-      };
-      const customFramework = await tsConfig.framework();
-      if (customFramework) {
-        generatorConfig.framework = customFramework;
-      }
-      const customFormatter = await tsConfig.formatter();
-      if (customFormatter) {
-        generatorConfig.formatter = customFormatter;
+}
+function resolveFramework(tsconfig, configured) {
+  return configured === void 0 || configured === "auto" ? detectFramework(tsconfig) : configured;
+}
+function detectFramework(tsconfig) {
+  const program = getProgram(tsconfig);
+  for (const sourceFile of program.getSourceFiles()) {
+    if (sourceFile.isDeclarationFile) continue;
+    for (const statement of sourceFile.statements) {
+      if (ts.isImportDeclaration(statement) && ts.isStringLiteral(statement.moduleSpecifier) && (statement.moduleSpecifier.text === "hono" || statement.moduleSpecifier.text.startsWith("@sdk-it/hono"))) {
+        return "hono";
       }
-      config.generators.typescript = generatorConfig;
-    } else if (generator === "python") {
-      config.generators.python = {
-        spec: await generatorConfigs.python.spec(),
-        output: await generatorConfigs.python.output(),
-        mode: await generatorConfigs.python.mode(),
-        name: await generatorConfigs.python.name()
-      };
-    } else if (generator === "dart") {
-      config.generators.dart = {
-        spec: await generatorConfigs.dart.spec(),
-        output: await generatorConfigs.dart.output(),
-        mode: await generatorConfigs.dart.mode(),
-        name: await generatorConfigs.dart.name(),
-        pagination: await generatorConfigs.dart.pagination()
-      };
-    }
-  }
-  const generateReadme = await confirm({
-    message: "\nGenerate README documentation?",
-    default: true
-  });
-  if (generateReadme) {
-    const readmeSpec = await input({
-      message: "OpenAPI specification for README:",
-      default: config.generators.typescript?.spec || possibleSpecFile || "./openapi.yaml"
-    });
-    const readmeOutput = await input({
-      message: "README output file:",
-      default: "./README.md"
-    });
-    config.readme = {
-      spec: readmeSpec,
-      output: readmeOutput
-    };
-  }
-  const generateApiRef = await confirm({
-    message: "\nGenerate API reference documentation?",
-    default: false
-  });
-  if (generateApiRef) {
-    const autoDetected = await findSpecFile();
-    const apirefSpec = await input({
-      message: "OpenAPI specification for API reference:",
-      default: config.generators.typescript?.spec || autoDetected || "./openapi.yaml"
-    });
-    const apirefOutput = await input({
-      message: "API reference output directory:",
-      default: "./docs"
-    });
-    config.apiref = {
-      spec: apirefSpec,
-      output: apirefOutput
-    };
-  }
-  const configPath = resolve3(process.cwd(), "sdk-it.json");
-  await writeFile(configPath, JSON.stringify(config, null, 2));
-  console.log(`
-\u2705 Configuration saved to ${configPath}`);
-  console.log("\n\u{1F680} Next Steps:\n");
-  console.log("1. Generate your SDK(s):");
-  console.log("   npx @sdk-it/cli");
-  if (config.generators.typescript) {
-    console.log("2. Integrate TypeScript SDK:");
-    const importName = config.generators.typescript.name.replace(
-      /[^a-zA-Z0-9]/g,
-      ""
-    );
-    const outputDir = config.generators.typescript.output.replace("./", "");
-    console.log(`   import { ${importName} } from './${outputDir}';`);
-    console.log(`   const client = new ${importName}();`);
-    console.log(`   const result = await client.request('GET /users');
-`);
-  }
-  if (config.generators.python) {
-    console.log("2. Integrate Python SDK:");
-    const outputDir = config.generators.python.output.replace("./", "");
-    console.log(`   # Add to your Python path or install locally`);
-    console.log(`   from ${outputDir} import Client`);
-    console.log(`   client = Client()`);
-    console.log(`   result = client.users.list_users()
-`);
-  }
-  if (config.generators.dart) {
-    console.log("2. Integrate Dart SDK:");
-    const outputDir = config.generators.dart.output.replace("./", "");
-    console.log(`   # Add dependency to pubspec.yaml`);
-    console.log(`   import 'package:${outputDir}/client.dart';`);
-    console.log(`   final client = Client();`);
-    console.log(`   final result = await client.users.listUsers();
-`);
-  }
-  console.log("3. Check generated documentation:");
-  const outputs = [];
-  if (config.generators.typescript)
-    outputs.push(config.generators.typescript.output);
-  if (config.generators.python) outputs.push(config.generators.python.output);
-  if (config.generators.dart) outputs.push(config.generators.dart.output);
-  outputs.forEach((output) => {
-    if (output) {
-      console.log(
-        `   \u{1F4D6} ${output}/README.md - Usage examples and API reference`
-      );
     }
-  });
-  if (config.readme) {
-    console.log(
-      `   \u{1F4D6} ${config.readme.output} - Generated API documentation`
-    );
   }
-  if (config.apiref) {
-    console.log(`   \u{1F310} ${config.apiref.output} - Interactive API reference`);
-  }
-  console.log("\n4. Useful commands:");
-  console.log(
-    "   npx @sdk-it/cli          # Regenerate SDKs after API changes"
-  );
-  console.log(
-    "   npx @sdk-it/cli typescript --help # See TypeScript-specific options"
-  );
-  console.log(
-    "   npx @sdk-it/cli python --help     # See Python-specific options"
-  );
-  console.log(
-    "   npx @sdk-it/cli dart --help       # See Dart-specific options"
-  );
-  console.log("\n\u{1F4A1} Tips:");
-  console.log(
-    "   \u2022 Update your API spec and re-run `npx @sdk-it/cli generate` to sync changes"
-  );
-  console.log(
-    "   \u2022 Generated SDKs include TypeScript definitions for excellent IDE support"
-  );
-  console.log(
-    "   \u2022 Check the README files for authentication and configuration options"
-  );
-  console.log("\n\u{1F4DA} Need help?");
-  console.log("   \u2022 Documentation: https://sdk-it.dev/docs");
-  console.log(
-    "   \u2022 Examples: https://github.com/JanuaryLabs/sdk-it/tree/main/docs/examples"
-  );
-  console.log("   \u2022 Issues: https://github.com/JanuaryLabs/sdk-it/issues");
-  console.log("\nHappy coding! \u{1F389}\n");
-});
-var init_default = init;
-
-// packages/cli/src/lib/generators/apiref.ts
-import { Command as Command2 } from "commander";
-import { execa } from "execa";
-import { dirname, join as join2 } from "node:path";
-
-// packages/cli/src/lib/options.ts
-import { Option } from "commander";
-var specOption = new Option(
-  "-s, --spec <spec>",
-  "Path to OpenAPI specification file"
-);
-var outputOption = new Option(
-  "-o, --output <output>",
-  "Output directory for the generated SDK"
-);
-function shellEnv(name) {
-  return process.platform === "win32" ? `%${name}%` : `$${name}`;
+  return "auto";
 }
-function parseDotConfig(incoming) {
-  if (incoming === "false") {
-    return false;
-  }
-  if (incoming === "true") {
-    return true;
-  }
-  if (!incoming) {
-    return void 0;
-  }
-  const config = {};
-  const pairs = incoming.split(",");
-  for (const pair of pairs) {
-    if (pair.includes("=")) {
-      const [key, val] = pair.split("=", 2);
-      if (val === "true") {
-        config[key] = true;
+function detectPrisma(tsconfig) {
+  const program = getProgram(tsconfig);
+  const imports = [];
+  const reportedModules = /* @__PURE__ */ new Set();
+  for (const sourceFile of program.getSourceFiles()) {
+    if (sourceFile.isDeclarationFile) continue;
+    for (const statement of sourceFile.statements) {
+      const prismaImport = getPrismaImport(statement);
+      if (!prismaImport) continue;
+      const resolvedModule = ts.resolveModuleName(
+        prismaImport.moduleSpecifier,
+        sourceFile.fileName,
+        program.getCompilerOptions(),
+        ts.sys
+      );
+      if (!resolvedModule.resolvedModule) continue;
+      let runtimeModule;
+      try {
+        runtimeModule = createRequire(sourceFile.fileName).resolve(
+          prismaImport.moduleSpecifier
+        );
+      } catch {
         continue;
       }
-      if (val === "false") {
-        config[key] = false;
-        continue;
+      if (!reportedModules.has(runtimeModule)) {
+        console.log(`SDKIT: detected Prisma from ${runtimeModule}`);
+        reportedModules.add(runtimeModule);
+      }
+      for (const { imported, local } of prismaImport.bindings) {
+        if (!imports.some(
+          (item) => item.import === local && item.from === runtimeModule
+        )) {
+          imports.push({
+            import: local,
+            from: runtimeModule,
+            property: imported
+          });
+        }
       }
-      config[key] = val;
     }
   }
-  return config;
+  return imports.length > 0 ? { imports } : void 0;
 }
-function parsePagination(config) {
-  if (config === true || config === void 0) {
+function getPrismaImport(statement) {
+  if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier) || !statement.importClause?.namedBindings || !ts.isNamedImports(statement.importClause.namedBindings)) {
     return void 0;
   }
-  if (config === false) {
-    return false;
-  }
-  return config;
+  const bindings = statement.importClause.namedBindings.elements.map((element) => ({
+    imported: element.propertyName?.text ?? element.name.text,
+    local: element.name.text
+  })).filter(({ imported }) => imported === "Prisma" || imported === "$Enums");
+  return bindings.length > 0 ? { moduleSpecifier: statement.moduleSpecifier.text, bindings } : void 0;
 }
 
-// packages/cli/src/lib/generators/apiref.ts
-var apiref_default = new Command2("apiref").description("Generate APIREF").addOption(specOption.makeOptionMandatory(true)).addOption(outputOption.makeOptionMandatory(true)).action(async (options) => {
-  await runApiRef(options.spec, options.output);
-});
-function runApiRef(spec, output) {
-  const packageDir = join2(dirname(import.meta.url), "..", "..", "apiref");
-  return execa("nx", ["run", "apiref:build", "--verbose"], {
-    stdio: "inherit",
-    extendEnv: true,
-    cwd: packageDir,
-    env: {
-      VITE_SPEC: spec,
-      VITE_SDK_IT_OUTPUT: output
-    }
-  });
+// packages/cli/src/lib/project/output.ts
+import { writeFile as writeFile2 } from "node:fs/promises";
+import { join as join3, resolve } from "node:path";
+import { generate } from "@sdk-it/typescript";
+
+// packages/cli/src/lib/project/cache.ts
+import { createHash } from "node:crypto";
+import { access, readFile, readdir } from "node:fs/promises";
+import { createRequire as createRequire2 } from "node:module";
+import { join, relative } from "node:path";
+import ts2 from "typescript";
+var require2 = createRequire2(import.meta.url);
+var projectGeneratorVersions = {
+  cli: require2("@sdk-it/cli/package.json").version,
+  compiler: ts2.version,
+  typescript: require2("@sdk-it/typescript/package.json").version
+};
+function hashProject(openapi, packageName) {
+  return createHash("sha256").update(JSON.stringify({ openapi, packageName, projectGeneratorVersions })).digest("hex");
 }
-
-// packages/cli/src/lib/generators/dart.ts
-import { Command as Command3 } from "commander";
-import { execFile, execSync } from "node:child_process";
-import { generate } from "@sdk-it/dart";
-import { loadSpec } from "@sdk-it/spec";
-var dart_default = new Command3("dart").description("Generate Dart SDK").addOption(specOption.makeOptionMandatory(true)).addOption(outputOption.makeOptionMandatory(true)).option("-n, --name <name>", "Name of the generated client", "Client").option(
-  "--pagination <pagination>",
-  'Configure pagination (e.g., "false", "true", "guess=false")',
-  "true"
-).option("-v, --verbose", "Verbose output", false).action(async (options) => {
-  await runDart(options);
-});
-async function runDart(options) {
-  await generate(await loadSpec(options.spec), {
-    output: options.output,
-    mode: options.mode || "full",
-    name: options.name,
-    pagination: typeof options.pagination === "string" ? parsePagination(parseDotConfig(options.pagination ?? "true")) : options.pagination,
-    formatCode: ({ output }) => {
-      if (options.formatter) {
-        const [command, ...args] = options.formatter.split(" ");
-        execFile(command, args, {
-          env: { ...process.env, SDK_IT_OUTPUT: output }
-        });
-      } else {
-        execSync(`dart format ${shellEnv("SDK_IT_OUTPUT")}`, {
-          env: { ...process.env, SDK_IT_OUTPUT: output },
-          stdio: options.verbose ? "inherit" : "pipe"
-        });
-      }
-    }
-  });
+async function isCurrentGeneratedPackage(output, hash) {
+  return await readOptionalFile(join(output, ".project-hash")) === hash && await generatedPackageExists(output);
 }
-
-// packages/cli/src/lib/generators/python.ts
-import { Command as Command4 } from "commander";
-import { execFile as execFile2, execSync as execSync2 } from "node:child_process";
-
-// packages/python/dist/index.js
-import { readdir } from "node:fs/promises";
-import { join as join3 } from "node:path";
-import { snakecase as snakecase2 } from "stringcase";
-import { isEmpty, isRef as isRef2, pascalcase as pascalcase2 } from "@sdk-it/core";
-import {
-  createWriterProxy,
-  writeFiles
-} from "@sdk-it/core/file-system.js";
-import {
-  cleanFiles,
-  forEachOperation,
-  isSuccessStatusCode,
-  parseJsonContentType,
-  readWriteMetadata,
-  toIR
-} from "@sdk-it/spec";
-import { snakecase } from "stringcase";
-import { isRef, notRef, parseRef, pascalcase } from "@sdk-it/core";
-import { isPrimitiveSchema } from "@sdk-it/spec";
-var dispatcher_default = `"""HTTP dispatcher for making API requests."""
-
-import asyncio
-import logging
-from typing import Any, Dict, List, Optional, Union
-from urllib.parse import urljoin, urlparse
-
-import httpx
-from pydantic import BaseModel
-
-from .interceptors import Interceptor
-from .responses import ApiResponse, ErrorResponse
-
-
-class RequestConfig(BaseModel):
-    """Configuration for an HTTP request."""
-
-    method: str
-    url: str
-    headers: Optional[Dict[str, str]] = None
-    params: Optional[Dict[str, Any]] = None
-    json_data: Optional[Dict[str, Any]] = None
-    form_data: Optional[Dict[str, Any]] = None
-    files: Optional[Dict[str, Any]] = None
-    timeout: Optional[Union[float, httpx.Timeout]] = None
-    
-    class Config:
-        """Pydantic configuration."""
-        arbitrary_types_allowed = True
-
-
-class Dispatcher:
-    """HTTP client dispatcher with interceptor support."""
-
-    def __init__(
-        self, 
-        interceptors: Optional[List[Interceptor]] = None,
-        client: Optional[httpx.AsyncClient] = None,
-        timeout: Optional[Union[float, httpx.Timeout]] = None
-    ):
-        """Initialize the dispatcher.
-        
-        Args:
-            interceptors: List of interceptors to apply to requests/responses
-            client: Custom httpx.AsyncClient instance (creates default if None)
-            timeout: Default timeout for requests
-        """
-        self.interceptors = interceptors or []
-        self.client = client or httpx.AsyncClient(timeout=timeout)
-        self.logger = logging.getLogger(__name__)
-
-    async def __aenter__(self):
-        """Async context manager entry."""
-        return self
-
-    async def __aexit__(self, exc_type, exc_val, exc_tb):
-        """Async context manager exit."""
-        await self.client.aclose()
-
-    async def request(self, config: RequestConfig) -> httpx.Response:
-        """Execute an HTTP request with interceptor processing.
-        
-        Args:
-            config: Request configuration
-            
-        Returns:
-            HTTP response after processing through interceptors
-            
-        Raises:
-            httpx.HTTPError: For HTTP-related errors
-            ValueError: For invalid request configuration
-        """
-        # Process request interceptors
-        processed_config = config
-        for interceptor in self.interceptors:
-            processed_config = await interceptor.process_request(processed_config)
-
-        # Prepare request arguments
-        request_kwargs = self._prepare_request_kwargs(processed_config)
-
-        try:
-            # Execute request
-            response = await self.client.request(**request_kwargs)
-            
-            # Process response interceptors (in reverse order)
-            for interceptor in reversed(self.interceptors):
-                response = await interceptor.process_response(response)
-
-            return response
-            
-        except httpx.RequestError as e:
-            self.logger.error(f"Request failed: {e}")
-            raise
-        except Exception as e:
-            self.logger.error(f"Unexpected error during request: {e}")
-            raise
-
-    def _prepare_request_kwargs(self, config: RequestConfig) -> Dict[str, Any]:
-        """Prepare keyword arguments for httpx request.
-        
-        Args:
-            config: Request configuration
-            
-        Returns:
-            Dictionary of kwargs for httpx.request
-            
-        Raises:
-            ValueError: If request configuration is invalid
-        """
-        if not config.method:
-            raise ValueError("Request method cannot be empty")
-        
-        if not config.url:
-            raise ValueError("Request URL cannot be empty")
-
-        request_kwargs = {
-            'method': config.method.upper(),
-            'url': config.url,
-            'headers': config.headers or {},
-            'params': config.params,
-            'timeout': config.timeout,
-        }
-
-        # Handle different content types
-        content_type_set = False
-        
-        if config.json_data is not None:
-            request_kwargs['json'] = config.json_data
-            if 'Content-Type' not in request_kwargs['headers']:
-                request_kwargs['headers']['Content-Type'] = 'application/json'
-            content_type_set = True
-            
-        elif config.form_data is not None:
-            request_kwargs['data'] = config.form_data
-            if 'Content-Type' not in request_kwargs['headers']:
-                request_kwargs['headers']['Content-Type'] = 'application/x-www-form-urlencoded'
-            content_type_set = True
-            
-        elif config.files is not None:
-            request_kwargs['files'] = config.files
-            # Don't set Content-Type for multipart/form-data - httpx will handle it automatically
-            content_type_set = True
-
-        # Validate that only one content type is set
-        content_fields = [config.json_data, config.form_data, config.files]
-        non_none_count = sum(1 for field in content_fields if field is not None)
-        
-        if non_none_count > 1:
-            raise ValueError(
-                "Only one of json_data, form_data, or files can be set in a single request"
-            )
-
-        return request_kwargs
-
-    async def json(self, config: RequestConfig) -> httpx.Response:
-        """Make a JSON request.
-        
-        Args:
-            config: Request configuration
-            
-        Returns:
-            HTTP response
-        """
-        return await self.request(config)
-
-    async def form(self, config: RequestConfig) -> httpx.Response:
-        """Make a form-encoded request.
-        
-        Args:
-            config: Request configuration
-            
-        Returns:
-            HTTP response
-        """
-        return await self.request(config)
-
-    async def multipart(self, config: RequestConfig) -> httpx.Response:
-        """Make a multipart/form-data request.
-        
-        Args:
-            config: Request configuration
-            
-        Returns:
-            HTTP response
-        """
-        return await self.request(config)
-
-    async def close(self):
-        """Close the HTTP client and clean up resources."""
-        await self.client.aclose()
-
-
-class Receiver:
-    """Response processor with interceptor support."""
-
-    def __init__(
-        self, 
-        interceptors: Optional[List[Interceptor]] = None,
-        logger: Optional[logging.Logger] = None
-    ):
-        """Initialize the receiver.
-        
-        Args:
-            interceptors: List of interceptors to apply to responses
-            logger: Custom logger instance
-        """
-        self.interceptors = interceptors or []
-        self.logger = logger or logging.getLogger(__name__)
-
-    async def json(
-        self, 
-        response: httpx.Response, 
-        success_model: Optional[type] = None, 
-        error_model: Optional[type] = None
-    ) -> Any:
-        """Process a JSON response.
-        
-        Args:
-            response: HTTP response to process
-            success_model: Pydantic model for successful responses
-            error_model: Pydantic model for error responses
-            
-        Returns:
-            Parsed response data, optionally as model instances
-            
-        Raises:
-            ErrorResponse: For HTTP error status codes
-            ValueError: For response parsing errors
-        """
-        # Process response interceptors
-        processed_response = response
-        for interceptor in self.interceptors:
-            processed_response = await interceptor.process_response(processed_response)
-
-        # Handle different status codes
-        if 200 <= processed_response.status_code < 300:
-            return await self._handle_success_response(
-                processed_response, success_model
-            )
-        else:
-            await self._handle_error_response(
-                processed_response, error_model
-            )
-
-    async def _handle_success_response(
-        self, 
-        response: httpx.Response, 
-        success_model: Optional[type] = None
-    ) -> Any:
-        """Handle successful response.
-        
-        Args:
-            response: HTTP response
-            success_model: Pydantic model for successful responses
-            
-        Returns:
-            Parsed response data
-            
-        Raises:
-            ValueError: For parsing errors
-        """
-        if not response.content:
-            return None
-
-        try:
-            data = response.json()
-            
-            if success_model:
-                if isinstance(data, list):
-                    return [success_model(**item) for item in data]
-                else:
-                    return success_model(**data)
-            
-            return data
-            
-        except Exception as e:
-            self.logger.error(f"Failed to parse success response: {e}")
-            raise ValueError(f"Failed to parse response: {e}")
-
-    async def _handle_error_response(
-        self, 
-        response: httpx.Response, 
-        error_model: Optional[type] = None
-    ) -> None:
-        """Handle error response.
-        
-        Args:
-            response: HTTP response
-            error_model: Pydantic model for error responses
-            
-        Raises:
-            ErrorResponse: Always raises with error details
-        """
-        error_data = {}
-        
-        if response.content:
-            try:
-                error_data = response.json()
-            except Exception:
-                # Fallback to text content if JSON parsing fails
-                error_data = {'message': response.text}
-
-        if error_model:
-            try:
-                error = error_model(**error_data)
-                raise ErrorResponse(error, response.status_code, dict(response.headers))
-            except Exception as e:
-                self.logger.warning(f"Failed to parse error with model {error_model}: {e}")
-
-        raise ErrorResponse(error_data, response.status_code, dict(response.headers))
-
-    async def stream(self, response: httpx.Response) -> httpx.Response:
-        """Return streaming response as-is.
-        
-        Args:
-            response: HTTP response
-            
-        Returns:
-            The unmodified streaming response
-        """
-        return response
-
-    async def text(self, response: httpx.Response) -> str:
-        """Get response as text.
-        
-        Args:
-            response: HTTP response
-            
-        Returns:
-            Response body as text
-            
-        Raises:
-            ErrorResponse: For HTTP error status codes
-        """
-        # Process response interceptors
-        processed_response = response
-        for interceptor in self.interceptors:
-            processed_response = await interceptor.process_response(processed_response)
-
-        if 200 <= processed_response.status_code < 300:
-            return processed_response.text
-        else:
-            error_data = {'message': processed_response.text}
-            raise ErrorResponse(error_data, processed_response.status_code, dict(processed_response.headers))
-
-    async def bytes(self, response: httpx.Response) -> bytes:
-        """Get response as bytes.
-        
-        Args:
-            response: HTTP response
-            
-        Returns:
-            Response body as bytes
-            
-        Raises:
-            ErrorResponse: For HTTP error status codes
-        """
-        # Process response interceptors
-        processed_response = response
-        for interceptor in self.interceptors:
-            processed_response = await interceptor.process_response(processed_response)
-
-        if 200 <= processed_response.status_code < 300:
-            return processed_response.content
-        else:
-            error_data = {'message': 'Binary response error'}
-            raise ErrorResponse(error_data, processed_response.status_code, dict(processed_response.headers))
-
-
-# Convenience functions for common use cases
-async def quick_request(
-    method: str,
-    url: str,
-    interceptors: Optional[List[Interceptor]] = None,
-    **kwargs
-) -> httpx.Response:
-    """Make a quick HTTP request with interceptors.
-    
-    Args:
-        method: HTTP method
-        url: Request URL
-        interceptors: List of interceptors to apply
-        **kwargs: Additional request configuration
-        
-    Returns:
-        HTTP response
-    """
-    config = RequestConfig(method=method, url=url, **kwargs)
-    
-    async with Dispatcher(interceptors=interceptors) as dispatcher:
-        return await dispatcher.request(config)
-
-
-async def quick_json_request(
-    method: str,
-    url: str,
-    json_data: Optional[Dict[str, Any]] = None,
-    interceptors: Optional[List[Interceptor]] = None,
-    success_model: Optional[type] = None,
-    error_model: Optional[type] = None,
-    **kwargs
-) -> Any:
-    """Make a quick JSON HTTP request with interceptors.
-    
-    Args:
-        method: HTTP method
-        url: Request URL
-        json_data: JSON data to send
-        interceptors: List of interceptors to apply
-        success_model: Pydantic model for successful responses
-        error_model: Pydantic model for error responses
-        **kwargs: Additional request configuration
-        
-    Returns:
-        Parsed JSON response
-    """
-    config = RequestConfig(method=method, url=url, json_data=json_data, **kwargs)
-    
-    async with Dispatcher(interceptors=interceptors) as dispatcher:
-        response = await dispatcher.request(config)
-        receiver = Receiver(interceptors=interceptors)
-        return await receiver.json(response, success_model, error_model)
-`;
-var interceptors_default = `"""HTTP interceptors for request/response processing."""
-
-import asyncio
-import logging
-import time
-from abc import ABC, abstractmethod
-from typing import Dict, Optional, List, Any, Union
-from urllib.parse import urljoin
-
-import httpx
-
-from .dispatcher import RequestConfig
-
-
-class Interceptor(ABC):
-    """Base class for HTTP interceptors."""
-
-    @abstractmethod
-    async def process_request(self, config: RequestConfig) -> RequestConfig:
-        """Process an outgoing request.
-
-        Args:
-            config: The request configuration to process
-
-        Returns:
-            The modified request configuration
-        """
-        pass
-
-    @abstractmethod
-    async def process_response(self, response: httpx.Response) -> httpx.Response:
-        """Process an incoming response.
-
-        Args:
-            response: The HTTP response to process
-
-        Returns:
-            The processed response
-        """
-        pass
-
-
-class BaseUrlInterceptor(Interceptor):
-    """Interceptor that prepends base URL to relative URLs."""
-
-    def __init__(self, base_url: str):
-        """Initialize the base URL interceptor.
-
-        Args:
-            base_url: The base URL to prepend to relative URLs
-        """
-        self.base_url = base_url.rstrip('/')
-
-    async def process_request(self, config: RequestConfig) -> RequestConfig:
-        """Prepend base URL if the request URL is relative.
-
-        Args:
-            config: The request configuration
-
-        Returns:
-            The modified request configuration with absolute URL
-        """
-        if not config.url.startswith(('http://', 'https://')):
-            # Use urljoin for proper URL joining, ensuring single slash
-            config.url = urljoin(self.base_url + '/', config.url.lstrip('/'))
-        return config
-
-    async def process_response(self, response: httpx.Response) -> httpx.Response:
-        """Pass through response unchanged.
-
-        Args:
-            response: The HTTP response
-
-        Returns:
-            The unmodified response
-        """
-        return response
-
-
-class LoggingInterceptor(Interceptor):
-    """Interceptor that logs requests and responses using Python's logging module."""
-
-    def __init__(
-        self,
-        enabled: bool = True,
-        logger: Optional[logging.Logger] = None,
-        log_level: int = logging.INFO,
-        include_headers: bool = True,
-        include_sensitive_headers: bool = False
-    ):
-        """Initialize the logging interceptor.
-
-        Args:
-            enabled: Whether logging is enabled
-            logger: Custom logger instance (creates default if None)
-            log_level: Logging level to use
-            include_headers: Whether to log request/response headers
-            include_sensitive_headers: Whether to log sensitive headers like Authorization
-        """
-        self.enabled = enabled
-        self.logger = logger or logging.getLogger(__name__)
-        self.log_level = log_level
-        self.include_headers = include_headers
-        self.include_sensitive_headers = include_sensitive_headers
-        self._sensitive_headers = {'authorization', 'x-api-key', 'cookie', 'set-cookie'}
-
-    async def process_request(self, config: RequestConfig) -> RequestConfig:
-        """Log outgoing request.
-
-        Args:
-            config: The request configuration
-
-        Returns:
-            The unmodified request configuration
-        """
-        if not self.enabled:
-            return config
-
-        self.logger.log(self.log_level, f"\u2192 {config.method.upper()} {config.url}")
-
-        if self.include_headers and config.headers:
-            for key, value in config.headers.items():
-                if (key.lower() in self._sensitive_headers and
-                    not self.include_sensitive_headers):
-                    self.logger.log(self.log_level, f"  {key}: [REDACTED]")
-                else:
-                    self.logger.log(self.log_level, f"  {key}: {value}")
-
-        return config
-
-    async def process_response(self, response: httpx.Response) -> httpx.Response:
-        """Log incoming response.
-
-        Args:
-            response: The HTTP response
-
-        Returns:
-            The unmodified response
-        """
-        if not self.enabled:
-            return response
-
-        status_icon = "\u2713" if 200 <= response.status_code < 300 else "\u2717"
-        self.logger.log(
-            self.log_level,
-            f"\u2190 {status_icon} {response.status_code} {response.reason_phrase or ''}"
-        )
-
-        if self.include_headers and response.headers:
-            for key, value in response.headers.items():
-                if (key.lower() in self._sensitive_headers and
-                    not self.include_sensitive_headers):
-                    self.logger.log(self.log_level, f"  {key}: [REDACTED]")
-                else:
-                    self.logger.log(self.log_level, f"  {key}: {value}")
-
-        return response
-
-
-class AuthInterceptor(Interceptor):
-    """Interceptor that adds authentication headers."""
-
-    def __init__(
-        self,
-        token: Optional[str] = None,
-        api_key: Optional[str] = None,
-        api_key_header: str = 'X-API-Key',
-        auth_type: str = 'Bearer'
-    ):
-        """Initialize the authentication interceptor.
-
-        Args:
-            token: Bearer token for Authorization header
-            api_key: API key value
-            api_key_header: Header name for API key
-            auth_type: Type of authentication (Bearer, Basic, etc.)
-        """
-        self.token = token
-        self.api_key = api_key
-        self.api_key_header = api_key_header
-        self.auth_type = auth_type
-
-    async def process_request(self, config: RequestConfig) -> RequestConfig:
-        """Add authentication headers.
-
-        Args:
-            config: The request configuration
-
-        Returns:
-            The modified request configuration with auth headers
-        """
-        if config.headers is None:
-            config.headers = {}
-
-        if self.token:
-            config.headers['Authorization'] = f'{self.auth_type} {self.token}'
-        elif self.api_key:
-            config.headers[self.api_key_header] = self.api_key
-
-        return config
-
-    async def process_response(self, response: httpx.Response) -> httpx.Response:
-        """Pass through response unchanged.
-
-        Args:
-            response: The HTTP response
-
-        Returns:
-            The unmodified response
-        """
-        return response
-
-
-class RetryInterceptor(Interceptor):
-    """Interceptor that retries failed requests with exponential backoff."""
-
-    def __init__(
-        self,
-        max_retries: int = 3,
-        retry_delay: float = 1.0,
-        backoff_factor: float = 2.0,
-        retry_on_status: Optional[List[int]] = None,
-        retry_on_exceptions: Optional[List[type]] = None
-    ):
-        """Initialize the retry interceptor.
-
-        Args:
-            max_retries: Maximum number of retry attempts
-            retry_delay: Initial delay between retries in seconds
-            backoff_factor: Exponential backoff multiplier
-            retry_on_status: HTTP status codes that should trigger retries
-            retry_on_exceptions: Exception types that should trigger retries
-        """
-        self.max_retries = max_retries
-        self.retry_delay = retry_delay
-        self.backoff_factor = backoff_factor
-        self.retry_on_status = retry_on_status or [500, 502, 503, 504, 408, 429]
-        self.retry_on_exceptions = retry_on_exceptions or [
-            httpx.TimeoutException,
-            httpx.ConnectError,
-            httpx.RemoteProtocolError
-        ]
-        self._original_request_func = None
-        self.logger = logging.getLogger(__name__)
-
-    async def process_request(self, config: RequestConfig) -> RequestConfig:
-        """Store original request for potential retries.
-
-        Args:
-            config: The request configuration
-
-        Returns:
-            The unmodified request configuration
-        """
-        # Store the original config for retries
-        self._original_config = config.model_copy() if hasattr(config, 'model_copy') else config
-        return config
-
-    async def process_response(self, response: httpx.Response) -> httpx.Response:
-        """Check if response needs retry and handle accordingly.
-
-        Args:
-            response: The HTTP response
-
-        Returns:
-            The response (possibly after retries)
-        """
-        # For retry logic to work properly, it needs to be integrated at the dispatcher level
-        # This is a simplified version that just passes through
-        # In a full implementation, the retry logic would need access to the original request method
-        return response
-
-    async def execute_with_retry(self, request_func, *args, **kwargs) -> httpx.Response:
-        """Execute a request function with retry logic.
-
-        Args:
-            request_func: Function that executes the HTTP request
-            *args: Arguments to pass to request_func
-            **kwargs: Keyword arguments to pass to request_func
-
-        Returns:
-            The HTTP response after potential retries
-
-        Raises:
-            The last exception encountered if all retries fail
-        """
-        last_exception = None
-
-        for attempt in range(self.max_retries + 1):
-            try:
-                response = await request_func(*args, **kwargs)
-
-                # Check if response status requires retry
-                if response.status_code not in self.retry_on_status:
-                    return response
-
-                if attempt == self.max_retries:
-                    self.logger.warning(
-                        f"Max retries ({self.max_retries}) reached for request. "
-                        f"Final status: {response.status_code}"
-                    )
-                    return response
-
-                # Wait before retry
-                delay = self.retry_delay * (self.backoff_factor ** attempt)
-                self.logger.info(
-                    f"Retrying request (attempt {attempt + 1}/{self.max_retries + 1}) "
-                    f"after {delay:.2f}s due to status {response.status_code}"
-                )
-                await asyncio.sleep(delay)
-
-            except Exception as e:
-                # Check if exception type requires retry
-                if not any(isinstance(e, exc_type) for exc_type in self.retry_on_exceptions):
-                    raise e
-
-                last_exception = e
-
-                if attempt == self.max_retries:
-                    self.logger.error(
-                        f"Max retries ({self.max_retries}) reached. "
-                        f"Final exception: {type(e).__name__}: {e}"
-                    )
-                    raise e
-
-                # Wait before retry
-                delay = self.retry_delay * (self.backoff_factor ** attempt)
-                self.logger.info(
-                    f"Retrying request (attempt {attempt + 1}/{self.max_retries + 1}) "
-                    f"after {delay:.2f}s due to {type(e).__name__}: {e}"
-                )
-                await asyncio.sleep(delay)
-
-
-class UserAgentInterceptor(Interceptor):
-    """Interceptor that adds a User-Agent header."""
-
-    def __init__(self, user_agent: str):
-        """Initialize the User-Agent interceptor.
-
-        Args:
-            user_agent: The User-Agent string to set
-        """
-        self.user_agent = user_agent
-
-    async def process_request(self, config: RequestConfig) -> RequestConfig:
-        """Add User-Agent header if not already present.
-
-        Args:
-            config: The request configuration
-
-        Returns:
-            The modified request configuration with User-Agent header
-        """
-        if config.headers is None:
-            config.headers = {}
-
-        # Only set User-Agent if not already present (case-insensitive check)
-        has_user_agent = any(
-            key.lower() == 'user-agent'
-            for key in config.headers.keys()
-        )
-
-        if not has_user_agent:
-            config.headers['User-Agent'] = self.user_agent
-
-        return config
-
-    async def process_response(self, response: httpx.Response) -> httpx.Response:
-        """Pass through response unchanged.
-
-        Args:
-            response: The HTTP response
-
-        Returns:
-            The unmodified response
-        """
-        return response
-
-
-class TimeoutInterceptor(Interceptor):
-    """Interceptor that sets request timeouts."""
-
-    def __init__(self, timeout: Union[float, httpx.Timeout]):
-        """Initialize the timeout interceptor.
-
-        Args:
-            timeout: Timeout value in seconds or httpx.Timeout object
-        """
-        self.timeout = timeout
-
-    async def process_request(self, config: RequestConfig) -> RequestConfig:
-        """Set timeout for the request.
-
-        Args:
-            config: The request configuration
-
-        Returns:
-            The modified request configuration with timeout
-        """
-        if config.timeout is None:
-            config.timeout = self.timeout
-        return config
-
-    async def process_response(self, response: httpx.Response) -> httpx.Response:
-        """Pass through response unchanged.
-
-        Args:
-            response: The HTTP response
-
-        Returns:
-            The unmodified response
-        """
-        return response
-
-
-class RateLimitInterceptor(Interceptor):
-    """Interceptor that implements client-side rate limiting."""
-
-    def __init__(self, max_requests: int, time_window: float = 60.0):
-        """Initialize the rate limit interceptor.
-
-        Args:
-            max_requests: Maximum number of requests allowed in the time window
-            time_window: Time window in seconds
-        """
-        self.max_requests = max_requests
-        self.time_window = time_window
-        self.requests = []
-        self._lock = asyncio.Lock()
-
-    async def process_request(self, config: RequestConfig) -> RequestConfig:
-        """Apply rate limiting before request.
-
-        Args:
-            config: The request configuration
-
-        Returns:
-            The unmodified request configuration
-        """
-        async with self._lock:
-            now = time.time()
-
-            # Remove requests outside the time window
-            self.requests = [req_time for req_time in self.requests
-                           if now - req_time < self.time_window]
-
-            # Check if we've exceeded the rate limit
-            if len(self.requests) >= self.max_requests:
-                # Calculate how long to wait
-                oldest_request = min(self.requests)
-                wait_time = self.time_window - (now - oldest_request)
-
-                if wait_time > 0:
-                    await asyncio.sleep(wait_time)
-
-            # Record this request
-            self.requests.append(now)
-
-        return config
-
-    async def process_response(self, response: httpx.Response) -> httpx.Response:
-        """Pass through response unchanged.
-
-        Args:
-            response: The HTTP response
-
-        Returns:
-            The unmodified response
-        """
-        return response
-
-
-# Factory functions for convenient interceptor creation
-def create_base_url_interceptor(base_url: str) -> BaseUrlInterceptor:
-    """Create a BaseUrlInterceptor instance.
-
-    Args:
-        base_url: The base URL to prepend to relative URLs
-
-    Returns:
-        Configured BaseUrlInterceptor instance
-    """
-    return BaseUrlInterceptor(base_url)
-
-
-def create_logging_interceptor(
-    enabled: bool = True,
-    log_level: int = logging.INFO,
-    include_headers: bool = True,
-    include_sensitive_headers: bool = False
-) -> LoggingInterceptor:
-    """Create a LoggingInterceptor instance.
-
-    Args:
-        enabled: Whether logging is enabled
-        log_level: Logging level to use
-        include_headers: Whether to log headers
-        include_sensitive_headers: Whether to log sensitive headers
-
-    Returns:
-        Configured LoggingInterceptor instance
-    """
-    return LoggingInterceptor(
-        enabled=enabled,
-        log_level=log_level,
-        include_headers=include_headers,
-        include_sensitive_headers=include_sensitive_headers
-    )
-
-
-def create_auth_interceptor(
-    token: Optional[str] = None,
-    api_key: Optional[str] = None,
-    api_key_header: str = 'X-API-Key',
-    auth_type: str = 'Bearer'
-) -> AuthInterceptor:
-    """Create an AuthInterceptor instance.
-
-    Args:
-        token: Bearer token for Authorization header
-        api_key: API key value
-        api_key_header: Header name for API key
-        auth_type: Type of authentication
-
-    Returns:
-        Configured AuthInterceptor instance
-    """
-    return AuthInterceptor(
-        token=token,
-        api_key=api_key,
-        api_key_header=api_key_header,
-        auth_type=auth_type
-    )
-
-
-def create_retry_interceptor(
-    max_retries: int = 3,
-    retry_delay: float = 1.0,
-    backoff_factor: float = 2.0,
-    retry_on_status: Optional[List[int]] = None
-) -> RetryInterceptor:
-    """Create a RetryInterceptor instance.
-
-    Args:
-        max_retries: Maximum number of retry attempts
-        retry_delay: Initial delay between retries in seconds
-        backoff_factor: Exponential backoff multiplier
-        retry_on_status: HTTP status codes that should trigger retries
-
-    Returns:
-        Configured RetryInterceptor instance
-    """
-    return RetryInterceptor(
-        max_retries=max_retries,
-        retry_delay=retry_delay,
-        backoff_factor=backoff_factor,
-        retry_on_status=retry_on_status
-    )
-
-
-def create_user_agent_interceptor(user_agent: str) -> UserAgentInterceptor:
-    """Create a UserAgentInterceptor instance.
-
-    Args:
-        user_agent: The User-Agent string to set
-
-    Returns:
-        Configured UserAgentInterceptor instance
-    """
-    return UserAgentInterceptor(user_agent)
-`;
-var responses_default = `"""HTTP response models and exceptions."""
-
-from typing import Any, Dict, Optional, Union
-
-import httpx
-from pydantic import BaseModel
-
-
-class ApiResponse(BaseModel):
-    """Base class for API responses."""
-
-    status_code: int
-    headers: Dict[str, str]
-    data: Any
-
-    class Config:
-        """Pydantic configuration."""
-        arbitrary_types_allowed = True
-
-
-class SuccessResponse(ApiResponse):
-    """Represents a successful API response."""
-
-    def __init__(self, data: Any, status_code: int = 200, headers: Optional[Dict[str, str]] = None):
-        """Initialize success response.
-
-        Args:
-            data: Response data
-            status_code: HTTP status code
-            headers: Response headers
-        """
-        super().__init__(
-            status_code=status_code,
-            headers=headers or {},
-            data=data
-        )
-
-
-class ErrorResponse(Exception):
-    """Exception raised for HTTP error responses."""
-
-    def __init__(
-        self,
-        data: Any,
-        status_code: int,
-        headers: Optional[Dict[str, str]] = None,
-        message: Optional[str] = None
-    ):
-        """Initialize error response.
-
-        Args:
-            data: Error response data
-            status_code: HTTP status code
-            headers: Response headers
-            message: Custom error message
-        """
-        self.data = data
-        self.status_code = status_code
-        self.headers = headers or {}
-        self.message = message or f"HTTP {status_code} Error"
-
-        super().__init__(self.message)
-
-    def __str__(self) -> str:
-        """String representation of the error."""
-        return f"ErrorResponse(status_code={self.status_code}, message='{self.message}')"
-
-    def __repr__(self) -> str:
-        """Detailed string representation of the error."""
-        return (
-            f"ErrorResponse(status_code={self.status_code}, "
-            f"message='{self.message}', data={self.data})"
-        )
-
-
-class TimeoutError(ErrorResponse):
-    """Exception raised for request timeouts."""
-
-    def __init__(self, message: str = "Request timed out"):
-        """Initialize timeout error.
-
-        Args:
-            message: Error message
-        """
-        super().__init__(
-            data={'error': 'timeout'},
-            status_code=408,
-            message=message
-        )
-
-
-class ConnectionError(ErrorResponse):
-    """Exception raised for connection errors."""
-
-    def __init__(self, message: str = "Connection failed"):
-        """Initialize connection error.
-
-        Args:
-            message: Error message
-        """
-        super().__init__(
-            data={'error': 'connection'},
-            status_code=503,
-            message=message
-        )
-
-
-class BadRequestError(ErrorResponse):
-    """Exception raised for 400 Bad Request errors."""
-
-    def __init__(self, data: Any = None, message: str = "Bad Request"):
-        """Initialize bad request error.
-
-        Args:
-            data: Error data
-            message: Error message
-        """
-        super().__init__(
-            data=data or {'error': 'bad_request'},
-            status_code=400,
-            message=message
-        )
-
-
-class UnauthorizedError(ErrorResponse):
-    """Exception raised for 401 Unauthorized errors."""
-
-    def __init__(self, data: Any = None, message: str = "Unauthorized"):
-        """Initialize unauthorized error.
-
-        Args:
-            data: Error data
-            message: Error message
-        """
-        super().__init__(
-            data=data or {'error': 'unauthorized'},
-            status_code=401,
-            message=message
-        )
-
-
-class ForbiddenError(ErrorResponse):
-    """Exception raised for 403 Forbidden errors."""
-
-    def __init__(self, data: Any = None, message: str = "Forbidden"):
-        """Initialize forbidden error.
-
-        Args:
-            data: Error data
-            message: Error message
-        """
-        super().__init__(
-            data=data or {'error': 'forbidden'},
-            status_code=403,
-            message=message
-        )
-
-
-class NotFoundError(ErrorResponse):
-    """Exception raised for 404 Not Found errors."""
-
-    def __init__(self, data: Any = None, message: str = "Not Found"):
-        """Initialize not found error.
-
-        Args:
-            data: Error data
-            message: Error message
-        """
-        super().__init__(
-            data=data or {'error': 'not_found'},
-            status_code=404,
-            message=message
-        )
-
-
-class InternalServerError(ErrorResponse):
-    """Exception raised for 500 Internal Server Error."""
-
-    def __init__(self, data: Any = None, message: str = "Internal Server Error"):
-        """Initialize internal server error.
-
-        Args:
-            data: Error data
-            message: Error message
-        """
-        super().__init__(
-            data=data or {'error': 'internal_server_error'},
-            status_code=500,
-            message=message
+async function generatedPackageExists(output) {
+  try {
+    const sourceRoot = join(output, "src");
+    const sources = await findSourceFiles(sourceRoot);
+    if (!sources.includes(join(sourceRoot, "index.ts"))) return false;
+    await Promise.all([
+      access(join(output, "package.json")),
+      ...sources.flatMap(
+        (source) => expectedCompiledFiles(output, sourceRoot, source).map(
+          (file) => access(file)
         )
-
-
-def create_error_from_response(response: httpx.Response) -> ErrorResponse:
-    """Create appropriate error exception from HTTP response.
-
-    Args:
-        response: HTTP response
-
-    Returns:
-        Appropriate error exception
-    """
-    status_code = response.status_code
-    headers = dict(response.headers)
-
-    # Try to parse error data
-    try:
-        data = response.json()
-    except Exception:
-        data = {'message': response.text}
-
-    # Create specific error types based on status code
-    error_classes = {
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalServerError,
-    }
-
-    error_class = error_classes.get(status_code, ErrorResponse)
-
-    if error_class == ErrorResponse:
-        return ErrorResponse(data, status_code, headers)
-    else:
-        return error_class(data)
-`;
-function coerceObject(schema) {
-  schema = structuredClone(schema);
-  if (schema["x-properties"]) {
-    schema.properties = {
-      ...schema.properties ?? {},
-      ...schema["x-properties"] ?? {}
-    };
-  }
-  if (schema["x-required"]) {
-    schema.required = Array.from(
-      /* @__PURE__ */ new Set([
-        ...Array.isArray(schema.required) ? schema.required : [],
-        ...schema["x-required"] || []
-      ])
-    );
+      )
+    ]);
+    return true;
+  } catch {
+    return false;
   }
-  return schema;
 }
-var PythonEmitter = class {
-  #spec;
-  #emitHandler;
-  #emitHistory = /* @__PURE__ */ new Set();
-  #typeCache = /* @__PURE__ */ new Map();
-  // Cache for resolved types
-  #emit(name, content, schema) {
-    if (this.#emitHistory.has(content)) {
-      return;
-    }
-    this.#emitHistory.add(content);
-    this.#emitHandler?.(name, content, schema);
-  }
-  constructor(spec) {
-    this.#spec = spec;
-  }
-  onEmit(emit) {
-    this.#emitHandler = emit;
-  }
-  #formatFieldName(name) {
-    let fieldName = snakecase(name);
-    const reservedKeywords = [
-      "class",
-      "def",
-      "if",
-      "else",
-      "elif",
-      "while",
-      "for",
-      "try",
-      "except",
-      "finally",
-      "with",
-      "as",
-      "import",
-      "from",
-      "global",
-      "nonlocal",
-      "lambda",
-      "yield",
-      "return",
-      "pass",
-      "break",
-      "continue",
-      "True",
-      "False",
-      "None",
-      "and",
-      "or",
-      "not",
-      "in",
-      "is"
-    ];
-    if (reservedKeywords.includes(fieldName)) {
-      fieldName = `${fieldName}_`;
-    }
-    return fieldName;
-  }
-  #ref(ref) {
-    const cacheKey = ref.$ref;
-    const cached = this.#typeCache.get(cacheKey);
-    if (cached) {
-      return cached;
-    }
-    const refInfo = parseRef(ref.$ref);
-    const refName = refInfo.model;
-    const className = pascalcase(refName);
-    const result = {
-      type: className,
-      content: "",
-      use: className,
-      fromJson: `${className}.parse_obj`,
-      simple: false
-    };
-    this.#typeCache.set(cacheKey, result);
-    return result;
-  }
-  #oneOf(variants, context) {
-    const variantTypes = variants.map((variant) => this.handle(variant, context)).map((result) => result.type || "Any").filter((type, index, arr) => arr.indexOf(type) === index);
-    if (variantTypes.length === 0) {
-      return {
-        type: "Any",
-        content: "",
-        use: "Any",
-        fromJson: "Any",
-        simple: true
-      };
-    }
-    if (variantTypes.length === 1) {
-      return {
-        type: variantTypes[0],
-        content: "",
-        use: variantTypes[0],
-        fromJson: variantTypes[0],
-        simple: true
-      };
+function expectedCompiledFiles(output, sourceRoot, source) {
+  const compiled = relative(sourceRoot, source).slice(0, -3);
+  return [
+    join(output, "dist", `${compiled}.js`),
+    join(output, "dist", `${compiled}.d.ts`)
+  ];
+}
+async function findSourceFiles(directory) {
+  const entries = await readdir(directory, { withFileTypes: true });
+  const files = await Promise.all(
+    entries.map(async (entry) => {
+      const path = join(directory, entry.name);
+      if (entry.isDirectory()) return findSourceFiles(path);
+      return entry.isFile() && path.endsWith(".ts") && !path.endsWith(".d.ts") ? [path] : [];
+    })
+  );
+  return files.flat();
+}
+async function readOptionalFile(path) {
+  try {
+    return await readFile(path, "utf8");
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return void 0;
     }
-    const unionType = `Union[${variantTypes.join(", ")}]`;
-    return {
-      type: unionType,
-      content: "",
-      use: unionType,
-      fromJson: unionType,
-      simple: true
-    };
+    throw error;
   }
-  #object(className, schema, context) {
-    const { properties = {}, required = [] } = coerceObject(schema);
-    const fields = [];
-    let baseClass = "BaseModel";
-    if (schema.allOf) {
-      const bases = schema.allOf.filter(notRef).map((s) => this.handle(s, context)).filter((result) => result.type).map((result) => result.type);
-      if (bases.length > 0 && bases[0]) {
-        baseClass = bases[0];
-      }
-    }
-    for (const [propName, propSchema] of Object.entries(properties)) {
-      if (isRef(propSchema)) {
-        this.#ref(propSchema);
-        const refInfo = parseRef(propSchema.$ref);
-        const refName = refInfo.model;
-        const pythonType = pascalcase(refName);
-        const fieldName = this.#formatFieldName(propName);
-        const isRequired = required.includes(propName);
-        const fieldType = isRequired ? pythonType : `Optional[${pythonType}]`;
-        const defaultValue = isRequired ? "" : " = None";
-        fields.push(`    ${fieldName}: ${fieldType}${defaultValue}`);
-      } else {
-        const result = this.handle(propSchema, { ...context, name: propName });
-        const fieldName = this.#formatFieldName(propName);
-        const isRequired = required.includes(propName);
-        let fieldType = result.type || "Any";
-        if (!isRequired) {
-          fieldType = `Optional[${fieldType}]`;
-        }
-        const defaultValue = isRequired ? "" : " = None";
-        let fieldDef = `    ${fieldName}: ${fieldType}${defaultValue}`;
-        if (fieldName !== propName) {
-          fieldDef = `    ${fieldName}: ${fieldType} = Field(alias='${propName}'${defaultValue ? ", default=None" : ""})`;
-        }
-        if (propSchema.description) {
-          fieldDef += `  # ${propSchema.description}`;
-        }
-        fields.push(fieldDef);
-      }
-    }
-    if (schema.oneOf || schema.anyOf) {
-      const unionResult = this.#oneOf(
-        schema.oneOf || schema.anyOf || [],
-        context
-      );
-      fields.push(`    value: ${unionResult.type}`);
-    }
-    if (schema.additionalProperties && typeof schema.additionalProperties === "object") {
-      const addlResult = this.handle(schema.additionalProperties, context);
-      fields.push(
-        `    additional_properties: Optional[Dict[str, ${addlResult.type || "Any"}]] = None`
-      );
-    }
-    const docstring = schema.description ? `    """${schema.description}"""
-` : "";
-    let requestConfigMethod = "";
-    if (schema["x-inputname"]) {
-      requestConfigMethod = `
-    def to_request_config(self, config: RequestConfig) -> RequestConfig:
-        """Convert this input model to request configuration."""
-        # Handle path parameters
-        path_params = {}
-        for key, value in self.dict(exclude_none=True).items():
-            if key in config.url:
-                path_params[key] = str(value)
-                config.url = config.url.replace(f'{{{key}}}', str(value))
-
-        # Handle query parameters
-        query_params = {k: v for k, v in self.dict(exclude_none=True).items()
-                       if k not in path_params}
-        if query_params:
-            config.params = query_params
+}
 
-        return config
-`;
-    }
-    const content = `class ${className}(${baseClass}):
-${docstring}${fields.length > 0 ? fields.join("\n") : "    pass"}${requestConfigMethod}
-`;
-    this.#emit(className, content, schema);
-    return {
-      type: className,
-      content,
-      use: className,
-      fromJson: `${className}.parse_obj`,
-      simple: false
-    };
-  }
-  #primitive(schema) {
-    const { type, format } = schema;
-    const nullable = schema.nullable;
-    let pythonType = "Any";
-    switch (type) {
-      case "string":
-        if (format === "date-time") {
-          pythonType = "datetime";
-        } else if (format === "date") {
-          pythonType = "date";
-        } else if (format === "uuid") {
-          pythonType = "UUID";
-        } else if (format === "binary" || format === "byte") {
-          pythonType = "bytes";
-        } else {
-          pythonType = "str";
-        }
-        break;
-      case "integer":
-        if (format === "int64") {
-          pythonType = "int";
-        } else {
-          pythonType = "int";
-        }
-        break;
-      case "number":
-        pythonType = "float";
-        break;
-      case "boolean":
-        pythonType = "bool";
-        break;
-      default:
-        pythonType = "Any";
-    }
-    if (nullable) {
-      pythonType = `Optional[${pythonType}]`;
-    }
-    return {
-      type: pythonType,
-      content: "",
-      use: pythonType,
-      fromJson: pythonType,
-      simple: true,
-      nullable
-    };
-  }
-  #array(schema, context) {
-    const itemsSchema = schema.items;
-    if (!itemsSchema) {
-      return {
-        type: "List[Any]",
-        content: "",
-        use: "List[Any]",
-        fromJson: "list",
-        simple: true
-      };
-    }
-    const itemsResult = this.handle(itemsSchema, context);
-    const listType = `List[${itemsResult.type || "Any"}]`;
-    return {
-      type: listType,
-      content: itemsResult.content,
-      use: listType,
-      fromJson: `List[${itemsResult.fromJson || itemsResult.type}]`,
-      simple: true
-    };
-  }
-  #enum(schema, _context) {
-    const { enum: enumValues } = schema;
-    if (!enumValues || enumValues.length === 0) {
-      return this.#primitive(schema);
-    }
-    if (!_context.name || typeof _context.name !== "string") {
-      throw new Error("Enum schemas must have a name in context");
-    }
-    const className = pascalcase(_context.name);
-    const enumItems = enumValues.map((value, index) => {
-      const name = typeof value === "string" ? value.toUpperCase().replace(/[^A-Z0-9]/g, "_") : `VALUE_${index}`;
-      const pythonValue = typeof value === "string" ? `'${value}'` : String(value);
-      return `    ${name} = ${pythonValue}`;
-    });
-    const content = `class ${className}(Enum):
-    """Enumeration for ${_context.name}."""
-${enumItems.join("\n")}
-`;
-    this.#emit(className, content, schema);
-    return {
-      type: className,
-      content,
-      use: className,
-      fromJson: className,
-      simple: false
-    };
-  }
-  #const(schema) {
-    const { const: constValue } = schema;
-    if (typeof constValue === "string") {
-      return {
-        type: `Literal['${constValue}']`,
-        content: "",
-        use: `Literal['${constValue}']`,
-        fromJson: `'${constValue}'`,
-        simple: true,
-        literal: constValue
-      };
-    }
-    return {
-      type: `Literal[${JSON.stringify(constValue)}]`,
-      content: "",
-      use: `Literal[${JSON.stringify(constValue)}]`,
-      fromJson: JSON.stringify(constValue),
-      simple: true,
-      literal: constValue
-    };
-  }
-  handle(schema, context = {}) {
-    if (isRef(schema)) {
-      return this.#ref(schema);
-    }
-    if ("const" in schema && schema.const !== void 0) {
-      return this.#const(schema);
+// packages/cli/src/lib/project/compiler.ts
+import { readFile as readFile2, writeFile } from "node:fs/promises";
+import { join as join2 } from "node:path";
+import ts3 from "typescript";
+async function compileGeneratedPackage(output, packageName) {
+  const source = join2(output, "src");
+  const program = ts3.createProgram({
+    rootNames: ts3.sys.readDirectory(source, [".ts"]),
+    options: {
+      allowSyntheticDefaultImports: true,
+      declaration: true,
+      module: ts3.ModuleKind.ESNext,
+      moduleResolution: ts3.ModuleResolutionKind.Bundler,
+      noEmitOnError: true,
+      outDir: join2(output, "dist"),
+      rewriteRelativeImportExtensions: true,
+      rootDir: source,
+      skipLibCheck: true,
+      target: ts3.ScriptTarget.ESNext,
+      verbatimModuleSyntax: true
     }
-    if (schema.enum) {
-      return this.#enum(schema, context);
-    }
-    if (schema.type === "array") {
-      return this.#array(schema, context);
-    }
-    if (schema.oneOf || schema.anyOf) {
-      return this.#oneOf(schema.oneOf || schema.anyOf || [], context);
-    }
-    if (schema.type === "object" || schema.properties || schema.allOf || schema.oneOf || schema.anyOf) {
-      if (!context.name || typeof context.name !== "string") {
-        throw new Error("Object schemas must have a name in context");
-      }
-      const className = pascalcase(context.name);
-      return this.#object(className, schema, context);
-    }
-    if (isPrimitiveSchema(schema)) {
-      return this.#primitive(schema);
-    }
-    return {
-      type: "Any",
-      content: "",
-      use: "Any",
-      fromJson: "Any",
-      simple: true
-    };
-  }
-};
-async function generate2(openapi, settings) {
-  const spec = toIR({ spec: openapi }, true);
-  const clientName = settings.name || "Client";
-  const output = settings.output;
-  const { writer, files: writtenFiles } = createWriterProxy(
-    settings.writer ?? writeFiles,
-    settings.output
-  );
-  settings.writer = writer;
-  settings.readFolder ??= async (folder) => {
-    const files = await readdir(folder, { withFileTypes: true });
-    return files.map((file) => ({
-      fileName: file.name,
-      filePath: join3(file.parentPath, file.name),
-      isFolder: file.isDirectory()
-    }));
-  };
-  const groups = {};
-  forEachOperation(spec, (entry, operation) => {
-    console.log(`Processing ${entry.method} ${entry.path}`);
-    const group = groups[entry.tag] ??= {
-      className: `${pascalcase2(entry.tag)}Api`,
-      methods: []
-    };
-    const input2 = toInputs(spec, { entry, operation });
-    const response = toOutput(spec, operation);
-    const methodName = snakecase2(
-      operation.operationId || `${entry.method}_${entry.path.replace(/[^a-zA-Z0-9]/g, "_")}`
-    );
-    const returnType = response ? response.returnType : "httpx.Response";
-    const docstring = operation.summary || operation.description ? `        """${operation.summary || operation.description}"""` : "";
-    group.methods.push(`
-    async def ${methodName}(self${input2.haveInput ? `, input_data: ${input2.inputName}` : ""}) -> ${returnType}:
-${docstring}
-        config = RequestConfig(
-            method='${entry.method.toUpperCase()}',
-            url='${entry.path}',
-        )
-
-        ${input2.haveInput ? "config = input_data.to_request_config(config)" : ""}
-
-        response = await self.dispatcher.${input2.contentType}(config)
-        ${response ? `return await self.receiver.json(response, ${response.successModel || "None"}, ${response.errorModel || "None"})` : "return response"}
-    `);
   });
-  const emitter = new PythonEmitter(spec);
-  const models = await serializeModels(spec, emitter);
-  const apiClasses = Object.entries(groups).reduce(
-    (acc, [name, { className, methods }]) => {
-      const fileName = `api/${snakecase2(name)}_api.py`;
-      const imports = [
-        "from typing import Optional",
-        "import httpx",
-        "",
-        "from ..http.dispatcher import Dispatcher, RequestConfig",
-        "from ..http.responses import Receiver",
-        "from ..inputs import *",
-        "from ..outputs import *",
-        "from ..models import *",
-        ""
-      ].join("\n");
-      acc[fileName] = `${imports}
-class ${className}:
-    """API client for ${name} operations."""
-
-    def __init__(self, dispatcher: Dispatcher, receiver: Receiver):
-        self.dispatcher = dispatcher
-        self.receiver = receiver
-${methods.join("\n")}
-`;
-      return acc;
-    },
-    {}
+  const result = program.emit();
+  const diagnostics = [
+    ...ts3.getPreEmitDiagnostics(program),
+    ...result.diagnostics
+  ].filter((diagnostic) => diagnostic.category === ts3.DiagnosticCategory.Error);
+  if (result.emitSkipped || diagnostics.length > 0) {
+    throw new Error(formatCompilationError(output, diagnostics));
+  }
+  await synchronizeGeneratedManifest(output, packageName);
+}
+function formatCompilationError(output, diagnostics) {
+  return `Failed to compile generated client:
+${ts3.formatDiagnosticsWithColorAndContext(
+    diagnostics,
+    {
+      getCanonicalFileName: (fileName) => fileName,
+      getCurrentDirectory: () => output,
+      getNewLine: () => "\n"
+    }
+  )}`;
+}
+async function synchronizeGeneratedManifest(output, packageName) {
+  const manifestPath = join2(output, "package.json");
+  const manifest = JSON.parse(
+    await readFile2(manifestPath, "utf8")
   );
-  const apiImports = Object.keys(groups).map(
-    (name) => `from .api.${snakecase2(name)}_api import ${pascalcase2(name)}Api`
-  ).join("\n");
-  const apiProperties = Object.keys(groups).map(
-    (name) => `        self.${snakecase2(name)} = ${pascalcase2(name)}Api(dispatcher, receiver)`
-  ).join("\n");
-  const clientCode = `"""Main API client."""
-
-from typing import Optional, List
-import httpx
-
-${apiImports}
-from .http.dispatcher import Dispatcher, RequestConfig
-from .http.responses import Receiver
-from .http.interceptors import (
-    Interceptor,
-    BaseUrlInterceptor,
-    LoggingInterceptor,
-    AuthInterceptor,
-    UserAgentInterceptor,
-)
-
-
-class ${clientName}:
-    """Main API client for the SDK."""
-
-    def __init__(
-        self,
-        base_url: str,
-        token: Optional[str] = None,
-        api_key: Optional[str] = None,
-        api_key_header: str = 'X-API-Key',
-        enable_logging: bool = False,
-        user_agent: Optional[str] = None,
-        custom_interceptors: Optional[List[Interceptor]] = None,
-    ):
-        """
-        Initialize the API client.
-
-        Args:
-            base_url: Base URL for the API
-            token: Bearer token for authentication
-            api_key: API key for authentication
-            api_key_header: Header name for API key authentication
-            enable_logging: Enable request/response logging
-            user_agent: Custom User-Agent header
-            custom_interceptors: Additional custom interceptors
-        """
-        self.base_url = base_url
-
-        # Build interceptor chain
-        interceptors = []
-
-        # Base URL interceptor (always first)
-        interceptors.append(BaseUrlInterceptor(base_url))
-
-        # Authentication interceptor
-        if token or api_key:
-            interceptors.append(AuthInterceptor(token=token, api_key=api_key, api_key_header=api_key_header))
-
-        # User agent interceptor
-        if user_agent:
-            interceptors.append(UserAgentInterceptor(user_agent))
-
-        # Logging interceptor
-        if enable_logging:
-            interceptors.append(LoggingInterceptor())
-
-        # Custom interceptors
-        if custom_interceptors:
-            interceptors.extend(custom_interceptors)
-
-        # Initialize dispatcher and receiver
-        self.dispatcher = Dispatcher(interceptors)
-        self.receiver = Receiver(interceptors)
-
-        # Initialize API clients
-${apiProperties}
-
-    async def __aenter__(self):
-        return self
-
-    async def __aexit__(self, exc_type, exc_val, exc_tb):
-        await self.close()
-
-    async def close(self):
-        """Close the HTTP client."""
-        await self.dispatcher.close()
-`;
-  await settings.writer(output, {
-    ...models,
-    ...apiClasses,
-    "client.py": clientCode,
-    "http/dispatcher.py": dispatcher_default,
-    "http/interceptors.py": interceptors_default,
-    "http/responses.py": responses_default,
-    "__init__.py": `"""SDK package."""
-
-from .client import ${clientName}
-
-__all__ = ['${clientName}']
-`
+  Object.assign(manifest, {
+    name: packageName,
+    version: "0.0.1",
+    type: "module",
+    main: "./dist/index.js",
+    module: "./dist/index.js",
+    types: "./dist/index.d.ts"
   });
-  if (settings.mode === "full") {
-    const requirements = `# HTTP client
-httpx>=0.24.0,<1.0.0
-
-# Data validation and serialization
-pydantic>=2.0.0,<3.0.0
-
-# Enhanced type hints
-typing-extensions>=4.0.0
-
-# Optional: For better datetime handling
-python-dateutil>=2.8.0
-`;
-    await settings.writer(output, {
-      "requirements.txt": requirements
-    });
-  }
-  const metadata = await readWriteMetadata(
-    settings.output,
-    Array.from(writtenFiles)
-  );
-  if (settings.cleanup !== false && writtenFiles.size > 0) {
-    await cleanFiles(metadata.content, settings.output, [
-      "/__init__.py",
-      "requirements.txt",
-      "/metadata.json"
-    ]);
-  }
-  await settings.writer(output, {
-    "models/__init__.py": await generateModuleInit(
-      join3(output, "models"),
-      settings.readFolder
-    ),
-    "inputs/__init__.py": await generateModuleInit(
-      join3(output, "inputs"),
-      settings.readFolder
-    ),
-    "outputs/__init__.py": await generateModuleInit(
-      join3(output, "outputs"),
-      settings.readFolder
-    ),
-    "api/__init__.py": await generateModuleInit(
-      join3(output, "api"),
-      settings.readFolder
-    ),
-    "http/__init__.py": `"""HTTP utilities."""
-
-from .dispatcher import Dispatcher, RequestConfig
-from .interceptors import *
-from .responses import *
+  manifest.publishConfig = { ...manifest.publishConfig, access: "public" };
+  manifest.exports = {
+    ...manifest.exports,
+    "./package.json": "./package.json",
+    ".": {
+      types: "./dist/index.d.ts",
+      import: "./dist/index.js",
+      default: "./dist/index.js"
+    }
+  };
+  manifest.dependencies = {
+    ...manifest.dependencies,
+    "fast-content-type-parse": "^3.0.0",
+    zod: "^4.3.0"
+  };
+  await writeFile(manifestPath, `${JSON.stringify(manifest, null, 2)}
+`);
+}
 
-__all__ = [
-    'Dispatcher',
-    'RequestConfig',
-    'ApiResponse',
-    'ErrorResponse',
-    'Interceptor',
-    'BaseUrlInterceptor',
-    'LoggingInterceptor',
-    'AuthInterceptor',
-]
-`
+// packages/cli/src/lib/project/output.ts
+async function writeProjectClient(openapi, config) {
+  const output = resolve(config.output ?? ".sdk-it");
+  const packageName = config.packageName ?? "@sdk-it/client";
+  const hash = hashProject(openapi, packageName);
+  if (await isCurrentGeneratedPackage(output, hash)) return;
+  await generate(openapi, {
+    output,
+    mode: "full",
+    name: "Client",
+    packageName,
+    readme: false
   });
-  if (settings.formatCode) {
-    await settings.formatCode({ output: settings.output });
-  }
+  await compileGeneratedPackage(output, packageName);
+  await writeFile2(join3(output, ".project-hash"), hash);
 }
-async function generateModuleInit(folder, readFolder) {
-  try {
-    const files = await readFolder(folder);
-    const pyFiles = files.filter(
-      (file) => file.fileName.endsWith(".py") && file.fileName !== "__init__.py"
-    ).map((file) => file.fileName.replace(".py", ""));
-    if (pyFiles.length === 0) {
-      return '"""Package module."""\n';
-    }
-    const imports = pyFiles.map((name) => `from .${name} import *`).join("\n");
-    return `"""Package module."""
 
-${imports}
-`;
-  } catch {
-    return '"""Package module."""\n';
-  }
+// packages/cli/src/lib/project/config.ts
+import { access as access2, readFile as readFile3, stat, writeFile as writeFile3 } from "node:fs/promises";
+import { dirname, join as join4, relative as relative2, resolve as resolve2 } from "node:path";
+import { pathToFileURL } from "node:url";
+function defineConfig(config) {
+  return config;
 }
-function toInputs(spec, { entry, operation }) {
-  const inputName = entry.inputName || "Input";
-  const haveInput = !isEmpty(operation.parameters) || !isEmpty(operation.requestBody);
-  let contentType = "json";
-  if (operation.requestBody && !isRef2(operation.requestBody)) {
-    const content = operation.requestBody.content;
-    if (content) {
-      const contentTypes = Object.keys(content);
-      if (contentTypes.some((type) => type.includes("multipart"))) {
-        contentType = "multipart";
-      } else if (contentTypes.some((type) => type.includes("form"))) {
-        contentType = "form";
-      }
-    }
+async function loadProjectConfig(options = {}) {
+  const cwd = resolve2(options.cwd ?? process.cwd());
+  const configPath = options.config ? resolve2(cwd, options.config) : await findProjectConfig(cwd);
+  const loaded = await import(pathToFileURL(configPath).href);
+  const config = loaded.default;
+  if (!config || typeof config.tsconfig !== "string") {
+    throw new Error(
+      `Expected ${configPath} to default export an SDK-IT config with a tsconfig path.`
+    );
   }
+  const directory = dirname(configPath);
   return {
-    inputName,
-    haveInput,
-    contentType
+    ...config,
+    tsconfig: resolve2(directory, config.tsconfig),
+    output: resolve2(directory, config.output ?? ".sdk-it")
   };
 }
-function toOutput(spec, operation) {
-  if (!operation.responses) {
-    return null;
+async function initializeProject(options) {
+  const cwd = resolve2(options.cwd ?? process.cwd());
+  const configPath = join4(cwd, "sdk-it.config.ts");
+  const tsconfigPath = resolve2(cwd, options.tsconfig);
+  await validateTsconfig(tsconfigPath);
+  const tsconfig = relative2(cwd, tsconfigPath).replaceAll("\\", "/");
+  const relativeTsconfig = tsconfig.startsWith(".") ? tsconfig : `./${tsconfig}`;
+  const configSource = `import { defineConfig } from '@sdk-it/cli';
+
+export default defineConfig({
+  tsconfig: '${relativeTsconfig}',
+});
+`;
+  const existingConfig = await readOptionalFile2(configPath);
+  if (existingConfig !== void 0 && existingConfig !== configSource) {
+    throw new Error(
+      `${configPath} already exists with different settings. Review it before replacing the file.`
+    );
   }
-  const successResponse = Object.entries(operation.responses).find(
-    ([code]) => isSuccessStatusCode(Number(code))
+  const packagePath = join4(cwd, "package.json");
+  const manifest = JSON.parse(
+    await readFile3(packagePath, "utf8")
   );
-  if (!successResponse) {
-    return null;
+  const manifestChanged = addGeneratedWorkspace(manifest);
+  const gitignorePath = join4(cwd, ".gitignore");
+  const gitignore = await readOptionalFile2(gitignorePath) ?? "";
+  if (!ignoresGeneratedWorkspace(gitignore)) {
+    const prefix = gitignore.length > 0 && !gitignore.endsWith("\n") ? "\n" : "";
+    await writeFile3(gitignorePath, `${gitignore}${prefix}.sdk-it/
+`);
   }
-  const [, response] = successResponse;
-  if (isRef2(response)) {
-    return null;
+  if (manifestChanged) {
+    await writeFile3(packagePath, `${JSON.stringify(manifest, null, 2)}
+`);
   }
-  const content = response.content;
-  if (!content) {
-    return { returnType: "None", successModel: null, errorModel: null };
+  if (existingConfig === void 0) {
+    await writeFile3(configPath, configSource);
   }
-  const jsonContent = Object.entries(content).find(
-    ([type]) => parseJsonContentType(type)
-  );
-  if (!jsonContent) {
-    return {
-      returnType: "httpx.Response",
-      successModel: null,
-      errorModel: null
-    };
+}
+function addGeneratedWorkspace(manifest) {
+  const workspaces = manifest.workspaces;
+  if (Array.isArray(workspaces)) {
+    if (workspaces.includes(".sdk-it")) return false;
+    workspaces.push(".sdk-it");
+    return true;
   }
-  const [, mediaType] = jsonContent;
-  const schema = mediaType.schema;
-  if (!schema || isRef2(schema)) {
-    return { returnType: "Any", successModel: null, errorModel: null };
+  if (workspaces && Array.isArray(workspaces.packages)) {
+    if (workspaces.packages.includes(".sdk-it")) return false;
+    workspaces.packages.push(".sdk-it");
+    return true;
   }
-  const emitter = new PythonEmitter(spec);
-  const result = emitter.handle(schema, {});
-  return {
-    returnType: result.type || "Any",
-    successModel: result.type,
-    errorModel: null
-    // TODO: Handle error models
-  };
+  manifest.workspaces = [".sdk-it"];
+  return true;
 }
-async function serializeModels(spec, emitter) {
-  const models = {};
-  const standardImports = [
-    "from typing import Any, Dict, List, Optional, Union, Literal",
-    "from pydantic import BaseModel, Field",
-    "from datetime import datetime, date",
-    "from uuid import UUID",
-    "from enum import Enum"
-  ].join("\n");
-  emitter.onEmit((name, content, schema) => {
-    const fullContent = `${standardImports}
-${schema["x-inputname"] ? "from ..http.dispatcher import RequestConfig" : ""}
-
-
-${content}`;
-    if (schema["x-inputname"]) {
-      models[`inputs/${snakecase2(name)}.py`] = fullContent;
-    } else if (schema["x-response-name"]) {
-      models[`outputs/${snakecase2(name)}.py`] = fullContent;
-    } else {
-      models[`models/${snakecase2(name)}.py`] = fullContent;
-    }
-  });
-  if (spec.components?.schemas) {
-    for (const [name, schema] of Object.entries(spec.components.schemas)) {
-      if (!isRef2(schema)) {
-        emitter.handle(schema, { name });
-      }
-    }
-  }
-  return models;
+function ignoresGeneratedWorkspace(gitignore) {
+  return gitignore.split(/\r?\n/).some((line) => line.trim() === ".sdk-it/" || line.trim() === ".sdk-it");
 }
-
-// packages/cli/src/lib/generators/python.ts
-import { loadSpec as loadSpec2, toIR as toIR2 } from "@sdk-it/spec";
-var python_default = new Command4("python").description("Generate Python SDK").addOption(specOption.makeOptionMandatory(true)).addOption(outputOption.makeOptionMandatory(true)).option("-n, --name <n>", "Name of the generated client", "Client").option("-v, --verbose", "Verbose output", false).option("--formatter <formatter>", "Formatter to use for the generated code").action(async (options) => {
-  await runPython(options);
-});
-async function runPython(options) {
-  const spec = toIR2({ spec: await loadSpec2(options.spec) }, true);
-  await generate2(spec, {
-    output: options.output,
-    mode: options.mode || "full",
-    name: options.name,
-    formatCode: ({ output }) => {
-      if (options.formatter) {
-        const [command, ...args] = options.formatter.split(" ");
-        execFile2(command, args, {
-          env: { ...process.env, SDK_IT_OUTPUT: output }
-        });
-      } else {
-        try {
-          execSync2(`black ${shellEnv("SDK_IT_OUTPUT")}`, {
-            env: { ...process.env, SDK_IT_OUTPUT: output },
-            stdio: options.verbose ? "inherit" : "pipe"
-          });
-        } catch {
-          try {
-            execSync2(`ruff format ${shellEnv("SDK_IT_OUTPUT")}`, {
-              env: { ...process.env, SDK_IT_OUTPUT: output },
-              stdio: options.verbose ? "inherit" : "pipe"
-            });
-          } catch {
-            if (options.verbose) {
-              console.warn(
-                "No Python formatter found (black or ruff). Skipping formatting."
-              );
-            }
-          }
-        }
-      }
+async function validateTsconfig(path) {
+  try {
+    if ((await stat(path)).isFile()) return;
+  } catch (error) {
+    if (!(error instanceof Error && "code" in error && error.code === "ENOENT")) {
+      throw error;
     }
-  });
-}
-
-// packages/cli/src/lib/generators/readme.ts
-import { Command as Command5 } from "commander";
-import { writeFile as writeFile2 } from "node:fs/promises";
-import { toReadme } from "@sdk-it/readme";
-import { loadSpec as loadSpec3, toIR as toIR3 } from "@sdk-it/spec";
-var readme_default = new Command5("readme").description("Generate README").addOption(specOption.makeOptionMandatory(true)).addOption(outputOption.makeOptionMandatory(true)).action(async (options) => {
-  await runReadme(options.spec, options.output);
-});
-async function runReadme(specFile, output) {
-  const spec = toIR3({ spec: await loadSpec3(specFile) });
-  const content = toReadme(spec);
-  await writeFile2(output, content, "utf-8");
-}
-
-// packages/cli/src/lib/generators/typescript.ts
-import { Command as Command6, Option as Option2 } from "commander";
-import { publish } from "libnpmpublish";
-import { execFile as execFile3, execSync as execSync3, spawnSync } from "node:child_process";
-import { readFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join as join4 } from "node:path";
-import getAuthToken from "registry-auth-token";
-import { writeFiles as writeFiles2 } from "@sdk-it/core/file-system.js";
-import { loadSpec as loadSpec4 } from "@sdk-it/spec";
-import { generate as generate3 } from "@sdk-it/typescript";
-var typescript_default = new Command6("typescript").alias("ts").description("Generate TypeScript SDK").addOption(specOption.makeOptionMandatory(true)).addOption(outputOption.makeOptionMandatory(false)).option(
-  "--useTsExtension [value]",
-  "Use .ts extension for generated files",
-  (value) => value === "false" ? false : true,
-  true
-).option(
-  "-m, --mode <mode>",
-  "full: generate a full project including package.json and tsconfig.json. useful for monorepo/workspaces minimal: generate only the client sdk"
-).option("-n, --name <name>", "Name of the generated client", "Client").option(
-  "-f, --framework <framework>",
-  "Framework that is integrating with the SDK"
-).option("--formatter <formatter>", "Formatter to use for the generated code").option(
-  "--install",
-  "Install dependencies using npm (only in full mode)",
-  true
-).option(
-  "--readme <readme>",
-  "Generate a README file",
-  (value) => value === "false" ? false : true,
-  true
-).option("--no-default-formatter", "Do not use the default formatter").option("--no-install", "Do not install dependencies").option("-v, --verbose", "Verbose output", false).option(
-  "--pagination <pagination>",
-  'Configure pagination (e.g., "false", "true", "guess=false")',
-  "true"
-).addOption(
-  new Option2(
-    "--publish <publish>",
-    "Publish the SDK to a package registry (npm, github, or a custom registry)"
-  ).hideHelp(true).makeOptionMandatory(false)
-).action(async (options) => {
-  await runTypescript(options);
-});
-async function runTypescript(options) {
-  if (!options.publish && !options.output) {
-    throw new Error("Error: --publish or --output option is required.");
-  }
-  const spec = await loadSpec4(options.spec);
-  if (options.output) {
-    await emitLocal(spec, {
-      ...options,
-      output: options.output
-    });
-  }
-  if (options.publish) {
-    await emitRemote(spec, {
-      ...options,
-      publish: options.publish
-    });
   }
+  throw new Error(`Could not find a TypeScript project at ${path}.`);
 }
-async function emitLocal(spec, options) {
-  await generate3(spec, {
-    writer: writeFiles2,
-    output: options.output,
-    mode: options.mode || "minimal",
-    name: options.name,
-    pagination: typeof options.pagination === "string" ? parsePagination(parseDotConfig(options.pagination ?? "true")) : options.pagination,
-    style: {
-      name: "github"
-    },
-    readme: options.readme,
-    useTsExtension: options.useTsExtension,
-    formatCode: ({ env, output }) => {
-      if (options.formatter) {
-        const [command, ...args] = options.formatter.split(" ");
-        execFile3(command, args, {
-          env: { ...env, SDK_IT_OUTPUT: output }
-        });
-      } else if (options.defaultFormatter) {
-        spawnSync("npx", ["-y", "prettier", output, "--write"], {
-          env: {
-            ...env,
-            SDK_IT_OUTPUT: output
-          },
-          stdio: options.verbose ? "inherit" : "pipe"
-        });
+async function findProjectConfig(start) {
+  let directory = start;
+  while (true) {
+    const candidate = join4(directory, "sdk-it.config.ts");
+    try {
+      await access2(candidate);
+      return candidate;
+    } catch {
+      const parent = dirname(directory);
+      if (parent === directory) {
+        throw new Error(
+          `Could not find sdk-it.config.ts from ${start} or any parent directory.`
+        );
       }
+      directory = parent;
     }
-  });
-  if (options.install && options.mode === "full") {
-    console.log("Installing dependencies...");
-    execSync3("npm install", {
-      cwd: options.output,
-      stdio: options.verbose ? "inherit" : "pipe"
-    });
   }
 }
-async function emitRemote(spec, options) {
-  const registry = options.publish === "npm" ? "https://registry.npmjs.org/" : options.publish === "github" ? "https://npm.pkg.github.com/" : options.publish;
-  console.log("Publishing to registry:", registry);
-  const path = join4(tmpdir(), crypto.randomUUID());
-  await emitLocal(spec, {
-    ...options,
-    output: path,
-    install: false,
-    mode: "full"
-  });
-  const manifest = JSON.parse(
-    await readFile(join4(path, "package.json"), "utf-8")
-  );
-  const registryUrl = new URL(registry);
-  const npmrc = process.env.NPM_TOKEN ? {
-    npmrc: {
-      registry,
-      [`//${registryUrl.hostname}:_authToken`]: process.env.NPM_TOKEN
+async function readOptionalFile2(path) {
+  try {
+    return await readFile3(path, "utf8");
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return void 0;
     }
-  } : registry;
-  const auth = getAuthToken(npmrc);
-  if (!auth || !auth.token) {
-    throw new Error(
-      "No npm auth token found in .npmrc or environment. please provide NPM_TOKEN."
-    );
+    throw error;
   }
-  const packResult = execSync3("npm pack --pack-destination .", { cwd: path });
-  const [tgzName] = packResult.toString().trim().split("\n");
-  await publish(manifest, await readFile(join4(path, tgzName)), {
-    registry,
-    defaultTag: "latest",
-    forceAuth: {
-      token: auth.token
-    },
-    strictSSL: true,
-    preferOnline: true
-  });
 }
 
-// packages/cli/src/lib/cli.ts
-var generate4 = new Command7("generate").action(async (options) => {
-  options.config ??= "sdk-it.json";
-  const config = await readJson2(options.config);
-  const promises = [];
-  if (config.generators?.typescript) {
-    promises.push(
-      runTypescript({
-        spec: config.generators.typescript.spec,
-        output: config.generators.typescript.output,
-        mode: config.generators.typescript.mode,
-        name: config.generators.typescript.name,
-        useTsExtension: config.generators.typescript.useTsExtension ?? true,
-        install: config.generators.typescript.install ?? false,
-        verbose: false,
-        defaultFormatter: config.generators.typescript.defaultFormatter ?? true,
-        readme: config.generators.typescript.readme ?? true,
-        pagination: config.generators.typescript.pagination
-      })
-    );
-  }
-  if (config.generators?.python) {
-    promises.push(
-      runPython({
-        spec: config.generators.python.spec,
-        output: config.generators.python.output,
-        mode: config.generators.python.mode,
-        name: config.generators.python.name,
-        verbose: false
-      })
-    );
-  }
-  if (config.generators?.dart) {
-    promises.push(
-      runDart({
-        spec: config.generators.dart.spec,
-        output: config.generators.dart.output,
-        mode: config.generators.dart.mode,
-        name: config.generators.dart.name,
-        verbose: false,
-        pagination: config.generators.dart.pagination
-      })
-    );
-  }
-  if (config.readme) {
-    promises.push(runReadme(config.readme.spec, config.readme.output));
-  }
-  await Promise.all(promises);
-  console.log("All configured generators completed successfully!");
-}).addCommand(typescript_default).addCommand(python_default).addCommand(dart_default).addCommand(apiref_default).addCommand(readme_default);
-var cli = program.description(`CLI tool to interact with SDK-IT.`).addCommand(generate4, { isDefault: true }).addCommand(init_default).addCommand(
-  new Command7("_internal").action(() => {
-  }),
-  { hidden: true }
-).parse(process.argv);
+// packages/cli/src/lib/project.ts
+async function generateProject(config) {
+  const tsconfig = resolve3(config.tsconfig);
+  const openapi = await analyzeProject(tsconfig, config);
+  await writeProjectClient(openapi, config);
+}
+export {
+  defineConfig,
+  generateProject,
+  initializeProject,
+  loadProjectConfig
+};
 //# sourceMappingURL=index.js.map