@sdk-it/cli 0.44.0 → 0.46.0

package/dist/bin.js

@@ -0,0 +1,3179 @@
+#!/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 as writeFile4 } from "node:fs/promises";
+import { resolve as resolve6 } from "node:path";
+
+// packages/cli/src/lib/project.ts
+import { resolve as resolve3 } from "node:path";
+
+// 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.`
+    );
+  }
+  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'.`
+    );
+  }
+  const { paths, components } = await analyze(tsconfig, {
+    responseAnalyzer: honoResponseAnalyzer,
+    ...prisma ? {
+      imports: prisma.imports,
+      typesMap: {
+        ...defaultTypesMap,
+        Decimal: "string"
+      }
+    } : {}
+  });
+  return {
+    openapi: "3.1.0",
+    info: {
+      title: "API",
+      version: "0.0.0"
+    },
+    paths,
+    components
+  };
+}
+function resolveFramework(tsconfig, configured) {
+  return configured === void 0 || configured === "auto" ? detectFramework(tsconfig) : configured;
+}
+function detectFramework(tsconfig) {
+  const program2 = getProgram(tsconfig);
+  for (const sourceFile of program2.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";
+      }
+    }
+  }
+  return "auto";
+}
+function detectPrisma(tsconfig) {
+  const program2 = getProgram(tsconfig);
+  const imports = [];
+  const reportedModules = /* @__PURE__ */ new Set();
+  for (const sourceFile of program2.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,
+        program2.getCompilerOptions(),
+        ts.sys
+      );
+      if (!resolvedModule.resolvedModule) continue;
+      let runtimeModule;
+      try {
+        runtimeModule = createRequire(sourceFile.fileName).resolve(
+          prismaImport.moduleSpecifier
+        );
+      } catch {
+        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
+          });
+        }
+      }
+    }
+  }
+  return imports.length > 0 ? { imports } : void 0;
+}
+function getPrismaImport(statement) {
+  if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier) || !statement.importClause?.namedBindings || !ts.isNamedImports(statement.importClause.namedBindings)) {
+    return void 0;
+  }
+  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/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");
+}
+async function isCurrentGeneratedPackage(output, hash) {
+  return await readOptionalFile(join(output, ".project-hash")) === hash && await generatedPackageExists(output);
+}
+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)
+        )
+      )
+    ]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+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;
+    }
+    throw error;
+  }
+}
+
+// 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 program2 = 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
+    }
+  });
+  const result = program2.emit();
+  const diagnostics = [
+    ...ts3.getPreEmitDiagnostics(program2),
+    ...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")
+  );
+  Object.assign(manifest, {
+    name: packageName,
+    version: "0.0.1",
+    type: "module",
+    main: "./dist/index.js",
+    module: "./dist/index.js",
+    types: "./dist/index.d.ts"
+  });
+  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)}
+`);
+}
+
+// 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
+  });
+  await compileGeneratedPackage(output, packageName);
+  await writeFile2(join3(output, ".project-hash"), hash);
+}
+
+// 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";
+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 {
+    ...config,
+    tsconfig: resolve2(directory, config.tsconfig),
+    output: resolve2(directory, config.output ?? ".sdk-it")
+  };
+}
+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 packagePath = join4(cwd, "package.json");
+  const manifest = JSON.parse(
+    await readFile3(packagePath, "utf8")
+  );
+  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/
+`);
+  }
+  if (manifestChanged) {
+    await writeFile3(packagePath, `${JSON.stringify(manifest, null, 2)}
+`);
+  }
+  if (existingConfig === void 0) {
+    await writeFile3(configPath, configSource);
+  }
+}
+function addGeneratedWorkspace(manifest) {
+  const workspaces = manifest.workspaces;
+  if (Array.isArray(workspaces)) {
+    if (workspaces.includes(".sdk-it")) return false;
+    workspaces.push(".sdk-it");
+    return true;
+  }
+  if (workspaces && Array.isArray(workspaces.packages)) {
+    if (workspaces.packages.includes(".sdk-it")) return false;
+    workspaces.packages.push(".sdk-it");
+    return true;
+  }
+  manifest.workspaces = [".sdk-it"];
+  return true;
+}
+function ignoresGeneratedWorkspace(gitignore) {
+  return gitignore.split(/\r?\n/).some((line) => line.trim() === ".sdk-it/" || line.trim() === ".sdk-it");
+}
+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;
+    }
+  }
+  throw new Error(`Could not find a TypeScript project at ${path}.`);
+}
+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;
+    }
+  }
+}
+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;
+    }
+    throw error;
+  }
+}
+
+// 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);
+}
+
+// packages/cli/src/lib/commands/find-framework.ts
+import { resolve as resolve4 } from "node:path";
+import { exist } from "@sdk-it/core/file-system.js";
+var monorepoIndicators = {
+  lerna: () => exist(resolve4(process.cwd(), "lerna.json")),
+  nx: () => exist(resolve4(process.cwd(), "nx.json")),
+  pnpm: () => exist(resolve4(process.cwd(), "pnpm-workspace.yaml")),
+  rush: () => exist(resolve4(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 resolve5 } 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(resolve5(process.cwd(), name))) {
+      return `./${name}`;
+    }
+  }
+  return void 0;
+}
+
+// packages/cli/src/lib/commands/guess-default-package-name.ts
+import { join as join5 } from "node:path";
+import { readJson } from "@sdk-it/core/file-system.js";
+async function guessTypescriptPackageName(consideringMultipleGenerator) {
+  try {
+    const packageJson = await readJson(
+      join5(process.cwd(), "package.json")
+    );
+    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;
+      }
+      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);
+    },
+    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").option("--project <tsconfig>", "Initialize from a backend tsconfig").action(async (options) => {
+  if (options.project) {
+    await initializeProject({ tsconfig: options.project });
+    console.log("SDK-IT project configuration initialized.");
+    return;
+  }
+  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: {}
+  };
+  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;
+      }
+      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 = resolve6(process.cwd(), "sdk-it.json");
+  await writeFile4(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 as dirname2, join as join6 } 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}`;
+}
+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;
+        continue;
+      }
+      if (val === "false") {
+        config[key] = false;
+        continue;
+      }
+      config[key] = val;
+    }
+  }
+  return config;
+}
+function parsePagination(config) {
+  if (config === true || config === void 0) {
+    return void 0;
+  }
+  if (config === false) {
+    return false;
+  }
+  return config;
+}
+
+// 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 = join6(dirname2(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/generators/dart.ts
+import { Command as Command3 } from "commander";
+import { execFile, execSync } from "node:child_process";
+import { generate as generate2 } 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 generate2(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"
+        });
+      }
+    }
+  });
+}
+
+// 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 as readdir2 } from "node:fs/promises";
+import { join as join7 } 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
+        )
+
+
+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 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
+      };
+    }
+    const unionType = `Union[${variantTypes.join(", ")}]`;
+    return {
+      type: unionType,
+      content: "",
+      use: unionType,
+      fromJson: unionType,
+      simple: true
+    };
+  }
+  #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);
+    }
+    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 generate3(openapi, settings) {
+  const spec = await 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 readdir2(folder, { withFileTypes: true });
+    return files.map((file) => ({
+      fileName: file.name,
+      filePath: join7(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 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}']
+`
+  });
+  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(
+      join7(output, "models"),
+      settings.readFolder
+    ),
+    "inputs/__init__.py": await generateModuleInit(
+      join7(output, "inputs"),
+      settings.readFolder
+    ),
+    "outputs/__init__.py": await generateModuleInit(
+      join7(output, "outputs"),
+      settings.readFolder
+    ),
+    "api/__init__.py": await generateModuleInit(
+      join7(output, "api"),
+      settings.readFolder
+    ),
+    "http/__init__.py": `"""HTTP utilities."""
+
+from .dispatcher import Dispatcher, RequestConfig
+from .interceptors import *
+from .responses import *
+
+__all__ = [
+    'Dispatcher',
+    'RequestConfig',
+    'ApiResponse',
+    'ErrorResponse',
+    'Interceptor',
+    'BaseUrlInterceptor',
+    'LoggingInterceptor',
+    'AuthInterceptor',
+]
+`
+  });
+  if (settings.formatCode) {
+    await settings.formatCode({ output: settings.output });
+  }
+}
+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';
+  }
+}
+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";
+      }
+    }
+  }
+  return {
+    inputName,
+    haveInput,
+    contentType
+  };
+}
+function toOutput(spec, operation) {
+  if (!operation.responses) {
+    return null;
+  }
+  const successResponse = Object.entries(operation.responses).find(
+    ([code]) => isSuccessStatusCode(Number(code))
+  );
+  if (!successResponse) {
+    return null;
+  }
+  const [, response] = successResponse;
+  if (isRef2(response)) {
+    return null;
+  }
+  const content = response.content;
+  if (!content) {
+    return { returnType: "None", successModel: null, errorModel: null };
+  }
+  const jsonContent = Object.entries(content).find(
+    ([type]) => parseJsonContentType(type)
+  );
+  if (!jsonContent) {
+    return {
+      returnType: "httpx.Response",
+      successModel: null,
+      errorModel: null
+    };
+  }
+  const [, mediaType] = jsonContent;
+  const schema = mediaType.schema;
+  if (!schema || isRef2(schema)) {
+    return { returnType: "Any", successModel: null, errorModel: null };
+  }
+  const emitter = new PythonEmitter(spec);
+  const result = emitter.handle(schema, {});
+  return {
+    returnType: result.type || "Any",
+    successModel: result.type,
+    errorModel: null
+    // TODO: Handle error models
+  };
+}
+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;
+}
+
+// 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 = await toIR2({ spec: await loadSpec2(options.spec) }, true);
+  await generate3(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."
+              );
+            }
+          }
+        }
+      }
+    }
+  });
+}
+
+// packages/cli/src/lib/generators/readme.ts
+import { Command as Command5 } from "commander";
+import { writeFile as writeFile5 } 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 = await toIR3({ spec: await loadSpec3(specFile) });
+  const content = toReadme(spec);
+  await writeFile5(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 as readFile4 } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join as join8 } 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 generate4 } 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
+    });
+  }
+}
+async function emitLocal(spec, options) {
+  await generate4(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"
+        });
+      }
+    }
+  });
+  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 = join8(tmpdir(), crypto.randomUUID());
+  await emitLocal(spec, {
+    ...options,
+    output: path,
+    install: false,
+    mode: "full"
+  });
+  const manifest = JSON.parse(
+    await readFile4(join8(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
+    }
+  } : 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."
+    );
+  }
+  const packResult = execSync3("npm pack --pack-destination .", { cwd: path });
+  const [tgzName] = packResult.toString().trim().split("\n");
+  await publish(manifest, await readFile4(join8(path, tgzName)), {
+    registry,
+    defaultTag: "latest",
+    forceAuth: {
+      token: auth.token
+    },
+    strictSSL: true,
+    preferOnline: true
+  });
+}
+
+// packages/cli/src/lib/cli.ts
+var generate5 = new Command7("generate").option("-c, --config <path>", "Path to an SDK-IT configuration file").action(async (options) => {
+  if (!options.config || options.config.endsWith(".ts")) {
+    try {
+      const config2 = await loadProjectConfig({ config: options.config });
+      await generateProject(config2);
+      console.log("Client generated successfully!");
+      return;
+    } catch (error) {
+      if (options.config || !(error instanceof Error) || !error.message.startsWith("Could not find sdk-it.config.ts")) {
+        throw error;
+      }
+    }
+  }
+  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(generate5, { isDefault: true }).addCommand(init_default).addCommand(
+  new Command7("_internal").action(() => {
+  }),
+  { hidden: true }
+).parse(process.argv);
+//# sourceMappingURL=bin.js.map