dto2ts 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Serkan Çakmak
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,254 @@
+# dto2ts
+
+Generate **TypeScript models** and **fetch-based CRUD services** from your C# API.
+
+Point it at your ASP.NET Core backend and get a fully typed, ready-to-use client for your
+frontend — no manual DTO copying, no drift between backend and frontend.
+
+Two input sources are supported:
+
+- **OpenAPI / Swagger** — a `swagger.json` file or a live URL (e.g. the spec ASP.NET Core
+  generates automatically). The most robust option.
+- **C# source files** (`.cs`) — parses your DTO/record/enum definitions directly, no need to
+  run the API first.
+
+The generated code has **zero runtime dependencies** — it uses the built-in `fetch`, so it
+runs in the browser, Node 18+, Angular, React, Vue, or anywhere else.
+
+---
+
+## Installation
+
+```bash
+npm install --save-dev dto2ts
+```
+
+Or run it once without installing:
+
+```bash
+npx dto2ts --help
+```
+
+## Quick start
+
+### From OpenAPI / Swagger
+
+```bash
+# From a live API
+npx dto2ts -s openapi -i https://localhost:5001/openapi/v1.json -o ./src/api
+
+# From a local file
+npx dto2ts -s openapi -i ./swagger.json -o ./src/api
+```
+
+### From C# source files
+
+```bash
+# Point at a folder — all .cs files are scanned recursively (bin/ and obj/ are skipped)
+npx dto2ts -s csharp -i ../Backend/Dtos -o ./src/api
+```
+
+## What gets generated
+
+One file per type, following the Angular style guide (`.model.ts` / `.enum.ts` / `.service.ts`),
+with barrel `index.ts` files so you can import from a single path:
+
+```
+src/api/
+├── models/
+│   ├── product-dto.model.ts      # export interface ProductDto
+│   ├── category-dto.model.ts     # export interface CategoryDto
+│   ├── product-status.enum.ts    # export enum ProductStatus
+│   └── index.ts                  # barrel
+├── services/
+│   ├── product.service.ts        # export class ProductService
+│   ├── category.service.ts
+│   └── index.ts                  # barrel
+├── http-client.ts                # fetch-based HttpClient + ApiError
+└── index.ts                      # top-level barrel re-export
+```
+
+Model files reference each other with `import type` (no runtime coupling), and services import
+their DTOs from the `../models` barrel — so everything compiles cleanly even under strict
+`verbatimModuleSyntax`.
+
+Example generated model:
+
+```ts
+export enum ProductStatus {
+  Draft = 0,
+  Active = 1,
+  Archived = 2,
+}
+
+export interface ProductDto {
+  id: number;
+  name: string;
+  description?: string;
+  price: number;
+  stock?: number;
+  status: ProductStatus;
+  createdAt: string;
+  tags: string[];
+  category?: CategoryDto;
+}
+```
+
+And a generated service:
+
+```ts
+export class ProductService {
+  constructor(
+    private readonly http: HttpClient,
+    private readonly basePath: string = "/api/products"
+  ) {}
+
+  list(options?: RequestOptions): Promise<ProductDto[]>;
+  getById(id: number, options?: RequestOptions): Promise<ProductDto>;
+  create(payload: ProductDto, options?: RequestOptions): Promise<ProductDto>;
+  update(id: number, payload: ProductDto, options?: RequestOptions): Promise<ProductDto>;
+  patch(id: number, payload: Partial<ProductDto>, options?: RequestOptions): Promise<ProductDto>;
+  remove(id: number, options?: RequestOptions): Promise<void>;
+}
+```
+
+## Using the generated client
+
+```ts
+import { HttpClient, ProductService, ApiError } from "./api";
+
+const http = new HttpClient({
+  baseUrl: "https://api.example.com",
+  // Optional: attach headers to every request (sync or async — great for auth tokens)
+  getHeaders: () => ({ Authorization: `Bearer ${getToken()}` }),
+});
+
+const products = new ProductService(http);
+
+// CRUD
+const all      = await products.list({ query: { page: 1, pageSize: 20 } });
+const one       = await products.getById(42);
+const created   = await products.create({ id: 0, name: "Pen", price: 9.9, status: 1, tags: [], createdAt: "" });
+const updated   = await products.update(42, created);
+const patched   = await products.patch(42, { price: 12.5 });
+await products.remove(42);
+
+// Error handling
+try {
+  await products.getById(999);
+} catch (e) {
+  if (e instanceof ApiError) {
+    console.error(e.status, e.body); // e.g. 404 and the server response body
+  }
+}
+```
+
+### Angular
+
+The generated `HttpClient` is framework-agnostic. In Angular you can register a service via DI:
+
+```ts
+// app.config.ts
+import { HttpClient, ProductService } from "./api";
+
+export const appConfig = {
+  providers: [
+    { provide: HttpClient, useFactory: () => new HttpClient({ baseUrl: "http://localhost:5099" }) },
+    ProductService,
+  ],
+};
+```
+
+```ts
+// a component
+private readonly products = inject(ProductService);
+this.products.list().then((items) => (this.items = items));
+```
+
+## Configuration file
+
+Instead of CLI flags, drop a `dto2ts.config.json` in your project root:
+
+```json
+{
+  "source": "openapi",
+  "input": "./swagger.json",
+  "output": "./src/api",
+  "camelCase": true,
+  "dateAsString": true,
+  "generateServices": true,
+  "idType": "number",
+  "entities": ["ProductDto", "CategoryDto"],
+  "basePaths": { "ProductDto": "/api/v1/products" }
+}
+```
+
+Then just run `npx dto2ts`. CLI flags override the config file.
+
+## Options
+
+| CLI flag           | Config key             | Description                                          | Default          |
+| ------------------ | ---------------------- | ---------------------------------------------------- | ---------------- |
+| `-s, --source`     | `source`               | `openapi` \| `csharp`                                | — (required)     |
+| `-i, --input`      | `input`                | `swagger.json` path/URL, or a `.cs` file/folder      | — (required)     |
+| `-o, --output`     | `output`               | Output directory                                     | — (required)     |
+| `--no-camel-case`  | `camelCase: false`     | Keep original PascalCase field names                 | camelCase        |
+| `--date-as-date`   | `dateAsString: false`  | Map `DateTime` → `Date` instead of `string`          | `string`         |
+| `--no-services`    | `generateServices: false` | Generate models only, no services                 | services on      |
+| `--entities a,b`   | `entities: [...]`      | Only generate services for these models              | all with an `id` |
+| `--id-type`        | `idType`               | Default TS type for the `id` parameter               | `number`         |
+| —                  | `basePaths`            | Map of model name → base path override               | convention       |
+
+## Type mapping (C# → TypeScript)
+
+| C#                                              | TypeScript                        |
+| ----------------------------------------------- | --------------------------------- |
+| `string`, `char`, `Guid`                        | `string`                          |
+| `int`, `long`, `decimal`, `double`, `byte`, …   | `number`                          |
+| `bool`                                          | `boolean`                         |
+| `DateTime`, `DateTimeOffset`, `DateOnly`        | `string` (or `Date`)              |
+| `T?`, `Nullable<T>`                             | optional field (`prop?`)          |
+| `List<T>`, `IEnumerable<T>`, `T[]`, `HashSet<T>`| `T[]`                             |
+| `Dictionary<K,V>`                               | `Record<string \| number, V>`     |
+| `Task<T>`                                       | `T` (unwrapped)                   |
+| `enum`                                          | `enum`                            |
+| custom class / record                           | reference to the matching interface |
+
+## How services are generated
+
+- **OpenAPI**: real routes are detected from the `paths` section — the base path and id type
+  come straight from the spec.
+- **C#**: any interface with an `id` field is treated as a resource; the base path follows the
+  `/api/<pluralized-name>` convention.
+- In both cases you can override with the `entities` and `basePaths` config options.
+
+## Programmatic API
+
+```ts
+import { generate } from "dto2ts";
+
+const { api, files } = await generate({
+  source: "openapi",
+  input: "./swagger.json",
+  output: "./src/api",
+});
+
+console.log(`Generated ${api.models.length} models`, files);
+```
+
+## Notes & gotchas
+
+- Generated files are **overwritten on every run** — don't edit them by hand. Re-run dto2ts as
+  part of your build instead.
+- ASP.NET Core serializes JSON as camelCase by default, so keep `camelCase: true` (the default).
+- **Enums via .NET's default OpenAPI**: `System.Text.Json` serializes enums as integers, and the
+  generated spec exposes them as a bare `{ "type": "integer" }` with no member names. If you use
+  the `openapi` source, such enums become an empty type. Two fixes:
+  1. Prefer the **`csharp` source**, which reads the real enum definition, or
+  2. Register a `JsonStringEnumConverter` in your API so the spec carries the enum values.
+- The C# parser is regex-based and covers standard DTO/record/enum shapes. For deeply nested or
+  heavily generic types, prefer the OpenAPI source.
+
+## License
+
+MIT

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,59 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const config_1 = require("./config");
+const generate_1 = require("./generate");
+const program = new commander_1.Command();
+program
+    .name("dto2ts")
+    .description("C# API (OpenAPI/Swagger veya .cs DTO) kaynaklarından TS model + fetch CRUD service üretir.")
+    .version("0.1.0");
+program
+    .command("generate", { isDefault: true })
+    .description("Model ve service dosyalarını üret")
+    .option("-s, --source <source>", "kaynak türü: openapi | csharp")
+    .option("-i, --input <path>", "swagger.json yolu/URL'si veya .cs dosyası/klasörü")
+    .option("-o, --output <dir>", "çıktı klasörü")
+    .option("--no-camel-case", "alan adlarını camelCase'e çevirme (orijinal PascalCase kalsın)")
+    .option("--date-as-date", "DateTime alanlarını Date olarak üret (varsayılan: string)")
+    .option("--no-services", "yalnızca model üret, service üretme")
+    .option("--entities <list>", "yalnızca bu modeller için service üret (virgülle ayır)")
+    .option("--id-type <type>", "id alanının varsayılan tipi (number | string)")
+    .action(async (opts) => {
+    try {
+        const fileConfig = (0, config_1.loadConfigFile)() ?? {};
+        const cli = {};
+        if (opts.source)
+            cli.source = opts.source;
+        if (opts.input)
+            cli.input = opts.input;
+        if (opts.output)
+            cli.output = opts.output;
+        if (opts.camelCase === false)
+            cli.camelCase = false;
+        if (opts.dateAsDate)
+            cli.dateAsString = false;
+        if (opts.services === false)
+            cli.generateServices = false;
+        if (opts.entities)
+            cli.entities = String(opts.entities).split(",").map((s) => s.trim()).filter(Boolean);
+        if (opts.idType)
+            cli.idType = opts.idType;
+        const merged = { ...fileConfig, ...cli };
+        const start = Date.now();
+        const { api, files } = await (0, generate_1.generate)(merged);
+        const ms = Date.now() - start;
+        const modelCount = api.models.length;
+        const serviceCount = api.resources.length;
+        console.log(`✔ dto2ts tamamlandı (${ms}ms)`);
+        console.log(`  ${modelCount} model, ${serviceCount} service üretildi:`);
+        for (const f of files)
+            console.log(`    → ${f}`);
+    }
+    catch (err) {
+        console.error(`✖ Hata: ${err instanceof Error ? err.message : String(err)}`);
+        process.exitCode = 1;
+    }
+});
+program.parseAsync(process.argv);

package/dist/config.d.ts

@@ -0,0 +1,24 @@
+export interface GenConfig {
+    /** Girdi kaynağı. */
+    source: "openapi" | "csharp";
+    /** openapi için swagger.json yolu/URL'si; csharp için dosya ya da klasör yolu. */
+    input: string;
+    /** Üretilen dosyaların yazılacağı klasör. */
+    output: string;
+    /** Alan adlarını camelCase'e çevir (ASP.NET Core varsayılan JSON davranışı). Varsayılan: true. */
+    camelCase?: boolean;
+    /** DateTime alanlarını "string" olarak üret (false ise "Date"). Varsayılan: true. */
+    dateAsString?: boolean;
+    /** CRUD service üretilsin mi. Varsayılan: true. */
+    generateServices?: boolean;
+    /** Service üretimini yalnızca bu modellerle sınırla (boşsa hepsi/uygun olanlar). */
+    entities?: string[];
+    /** Model adı -> base path override. Örn. { "ProductDto": "/api/v1/products" }. */
+    basePaths?: Record<string, string>;
+    /** Id alanının varsayılan tipi (base path'e /{id} eklenirken). Varsayılan: "number". */
+    idType?: string;
+}
+export declare const DEFAULT_CONFIG: Partial<GenConfig>;
+/** Çalışma dizininde config dosyası ara ve yükle. */
+export declare function loadConfigFile(cwd?: string): Partial<GenConfig> | null;
+export declare function resolveConfig(partial: Partial<GenConfig>): GenConfig;

package/dist/config.js

@@ -0,0 +1,68 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_CONFIG = void 0;
+exports.loadConfigFile = loadConfigFile;
+exports.resolveConfig = resolveConfig;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+exports.DEFAULT_CONFIG = {
+    camelCase: true,
+    dateAsString: true,
+    generateServices: true,
+    idType: "number",
+};
+const CONFIG_FILE_NAMES = ["dto2ts.config.json", ".dto2tsrc.json"];
+/** Çalışma dizininde config dosyası ara ve yükle. */
+function loadConfigFile(cwd = process.cwd()) {
+    for (const name of CONFIG_FILE_NAMES) {
+        const p = path.join(cwd, name);
+        if (fs.existsSync(p)) {
+            const raw = fs.readFileSync(p, "utf8");
+            return JSON.parse(raw);
+        }
+    }
+    return null;
+}
+function resolveConfig(partial) {
+    const merged = { ...exports.DEFAULT_CONFIG, ...partial };
+    if (!merged.source)
+        throw new Error('config: "source" zorunlu ("openapi" | "csharp").');
+    if (!merged.input)
+        throw new Error('config: "input" zorunlu.');
+    if (!merged.output)
+        throw new Error('config: "output" zorunlu.');
+    return merged;
+}

package/dist/generate.d.ts

@@ -0,0 +1,10 @@
+import { GenConfig } from "./config";
+import { ApiModel } from "./ir";
+export interface GenerateResult {
+    api: ApiModel;
+    files: string[];
+}
+/** Kaynağı parse edip ApiModel (IR) üret. */
+export declare function parseSource(config: GenConfig): Promise<ApiModel>;
+/** Tam üretim akışı: parse -> generate -> diske yaz. */
+export declare function generate(partial: Partial<GenConfig>): Promise<GenerateResult>;

package/dist/generate.js

@@ -0,0 +1,87 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSource = parseSource;
+exports.generate = generate;
+const path = __importStar(require("path"));
+const config_1 = require("./config");
+const openapi_1 = require("./parsers/openapi");
+const csharp_1 = require("./parsers/csharp");
+const models_1 = require("./generators/models");
+const services_1 = require("./generators/services");
+const http_client_1 = require("./generators/http-client");
+const fs_1 = require("./utils/fs");
+/** Kaynağı parse edip ApiModel (IR) üret. */
+async function parseSource(config) {
+    if (config.source === "openapi")
+        return (0, openapi_1.parseOpenApi)(config);
+    if (config.source === "csharp")
+        return (0, csharp_1.parseCsharp)(config);
+    throw new Error(`Bilinmeyen source: ${config.source}`);
+}
+function generateBarrel(hasServices) {
+    const lines = [
+        "// Bu dosya dto2ts tarafından otomatik üretildi.",
+        'export * from "./models";',
+        'export * from "./http-client";',
+    ];
+    if (hasServices)
+        lines.push('export * from "./services";');
+    return lines.join("\n") + "\n";
+}
+/** Tam üretim akışı: parse -> generate -> diske yaz. */
+async function generate(partial) {
+    const config = (0, config_1.resolveConfig)(partial);
+    const api = await parseSource(config);
+    const outDir = path.resolve(config.output);
+    const written = [];
+    const emit = (relPath, content) => {
+        const full = path.join(outDir, relPath);
+        (0, fs_1.writeFile)(full, content);
+        written.push(full);
+    };
+    // models/*.model.ts | *.enum.ts + models/index.ts
+    for (const file of (0, models_1.generateModelFiles)(api))
+        emit(file.path, file.content);
+    // http-client.ts
+    emit("http-client.ts", (0, http_client_1.generateHttpClient)());
+    // services/*.service.ts + services/index.ts
+    const serviceFiles = config.generateServices === false ? [] : (0, services_1.generateServiceFiles)(api);
+    for (const file of serviceFiles)
+        emit(file.path, file.content);
+    // kök index.ts
+    emit("index.ts", generateBarrel(serviceFiles.length > 0));
+    return { api, files: written };
+}

package/dist/generators/http-client.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Statik http-client.ts içeriği. Üretilen service'lerin dayandığı,
+ * fetch tabanlı, sıfır bağımlılıklı istemci.
+ */
+export declare function generateHttpClient(): string;

package/dist/generators/http-client.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateHttpClient = generateHttpClient;
+/**
+ * Statik http-client.ts içeriği. Üretilen service'lerin dayandığı,
+ * fetch tabanlı, sıfır bağımlılıklı istemci.
+ */
+function generateHttpClient() {
+    return `// Bu dosya dto2ts tarafından otomatik üretildi. Elle düzenlenebilir kabul edilir ama
+// yeniden üretimde üzerine yazılır.
+
+export type QueryValue = string | number | boolean | null | undefined | Array<string | number | boolean>;
+
+export interface RequestOptions {
+  /** İstek başlıkları (base başlıklarla birleşir). */
+  headers?: Record<string, string>;
+  /** Query string parametreleri. */
+  query?: Record<string, QueryValue>;
+  /** İptal için AbortSignal. */
+  signal?: AbortSignal;
+}
+
+export interface HttpClientOptions {
+  /** API kök adresi. Örn. "https://api.example.com". */
+  baseUrl: string;
+  /** Her isteğe eklenecek başlıklar (senkron ya da async, örn. token). */
+  getHeaders?: () => Record<string, string> | Promise<Record<string, string>>;
+  /** Özel fetch implementasyonu (test/SSR için). Varsayılan: global fetch. */
+  fetch?: typeof fetch;
+}
+
+/** HTTP başarısız olduğunda fırlatılan hata. */
+export class ApiError extends Error {
+  constructor(
+    public readonly status: number,
+    public readonly statusText: string,
+    public readonly body: unknown,
+    public readonly url: string
+  ) {
+    super(\`HTTP \${status} \${statusText} — \${url}\`);
+    this.name = "ApiError";
+  }
+}
+
+function buildQuery(query?: Record<string, QueryValue>): string {
+  if (!query) return "";
+  const params = new URLSearchParams();
+  for (const [key, value] of Object.entries(query)) {
+    if (value === null || value === undefined) continue;
+    if (Array.isArray(value)) {
+      for (const v of value) params.append(key, String(v));
+    } else {
+      params.append(key, String(value));
+    }
+  }
+  const s = params.toString();
+  return s ? \`?\${s}\` : "";
+}
+
+export class HttpClient {
+  private readonly baseUrl: string;
+  private readonly fetchImpl: typeof fetch;
+
+  constructor(private readonly options: HttpClientOptions) {
+    this.baseUrl = options.baseUrl.replace(/\\/+$/, "");
+    this.fetchImpl = options.fetch ?? globalThis.fetch;
+    if (!this.fetchImpl) {
+      throw new Error("Global fetch bulunamadı. Node 18+ kullanın ya da options.fetch verin.");
+    }
+  }
+
+  async request<T>(
+    method: string,
+    path: string,
+    body?: unknown,
+    options: RequestOptions = {}
+  ): Promise<T> {
+    const url = \`\${this.baseUrl}\${path.startsWith("/") ? path : "/" + path}\${buildQuery(options.query)}\`;
+
+    const headers: Record<string, string> = {
+      Accept: "application/json",
+      ...(this.options.getHeaders ? await this.options.getHeaders() : {}),
+      ...options.headers,
+    };
+
+    const hasBody = body !== undefined && body !== null;
+    if (hasBody) headers["Content-Type"] = headers["Content-Type"] ?? "application/json";
+
+    const res = await this.fetchImpl(url, {
+      method,
+      headers,
+      body: hasBody ? JSON.stringify(body) : undefined,
+      signal: options.signal,
+    });
+
+    if (!res.ok) {
+      let errBody: unknown = null;
+      try {
+        errBody = await res.json();
+      } catch {
+        try {
+          errBody = await res.text();
+        } catch {
+          /* yoksay */
+        }
+      }
+      throw new ApiError(res.status, res.statusText, errBody, url);
+    }
+
+    if (res.status === 204) return undefined as T;
+    const text = await res.text();
+    if (!text) return undefined as T;
+    return JSON.parse(text) as T;
+  }
+
+  get<T>(path: string, options?: RequestOptions): Promise<T> {
+    return this.request<T>("GET", path, undefined, options);
+  }
+  post<T>(path: string, body?: unknown, options?: RequestOptions): Promise<T> {
+    return this.request<T>("POST", path, body, options);
+  }
+  put<T>(path: string, body?: unknown, options?: RequestOptions): Promise<T> {
+    return this.request<T>("PUT", path, body, options);
+  }
+  patch<T>(path: string, body?: unknown, options?: RequestOptions): Promise<T> {
+    return this.request<T>("PATCH", path, body, options);
+  }
+  delete<T>(path: string, options?: RequestOptions): Promise<T> {
+    return this.request<T>("DELETE", path, undefined, options);
+  }
+}
+`;
+}

package/dist/generators/models.d.ts

@@ -0,0 +1,10 @@
+import { ApiModel, ModelDef } from "../ir";
+export interface GeneratedFile {
+    /** Çıktı klasörüne göre göreli yol. Örn. "models/product-dto.model.ts". */
+    path: string;
+    content: string;
+}
+/** Bir modelin uzantısız dosya adı tabanı. */
+export declare function modelFileBase(m: ModelDef): string;
+/** Her modeli kendi dosyasına derle (models/<ad>.model.ts | <ad>.enum.ts) + barrel. */
+export declare function generateModelFiles(api: ApiModel): GeneratedFile[];