ng-openapi 0.0.2

package/index.js

@@ -0,0 +1,1807 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  SwaggerParser: () => SwaggerParser,
+  generateFromConfig: () => generateFromConfig
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/lib/core/swagger-parser.ts
+var fs = __toESM(require("fs"));
+var _SwaggerParser = class _SwaggerParser {
+  constructor(swaggerPath) {
+    __publicField(this, "spec");
+    const swaggerContent = fs.readFileSync(swaggerPath, "utf8");
+    this.spec = JSON.parse(swaggerContent);
+  }
+  getDefinitions() {
+    var _a;
+    return this.spec.definitions || ((_a = this.spec.components) == null ? void 0 : _a.schemas) || {};
+  }
+  getDefinition(name) {
+    const definitions = this.getDefinitions();
+    return definitions[name];
+  }
+  resolveReference(ref) {
+    const parts = ref.split("/");
+    const definitionName = parts[parts.length - 1];
+    return this.getDefinition(definitionName);
+  }
+  getAllDefinitionNames() {
+    return Object.keys(this.getDefinitions());
+  }
+};
+__name(_SwaggerParser, "SwaggerParser");
+var SwaggerParser = _SwaggerParser;
+
+// src/lib/core/generator.ts
+var import_ts_morph4 = require("ts-morph");
+
+// src/lib/generators/type/type.generator.ts
+var import_ts_morph = require("ts-morph");
+
+// src/lib/config/constants.ts
+var disableLinting = `/* @ts-nocheck */
+/* eslint-disable */
+/* @noformat */
+/* @formatter:off */
+`;
+var authorComment = `/**
+* Generated by ng-openapi
+`;
+var defaultHeaderComment = disableLinting + authorComment;
+var TYPE_GENERATOR_HEADER_COMMENT = defaultHeaderComment + `* Generated TypeScript interfaces from Swagger specification
+* Do not edit this file manually
+*/
+`;
+var SERVICE_INDEX_GENERATOR_HEADER_COMMENT = defaultHeaderComment + `* Generated service exports
+* Do not edit this file manually
+*/
+`;
+var SERVICE_GENERATOR_HEADER_COMMENT = /* @__PURE__ */ __name((controllerName) => defaultHeaderComment + `* Generated Angular service for ${controllerName} controller
+* Do not edit this file manually
+*/
+`, "SERVICE_GENERATOR_HEADER_COMMENT");
+
+// src/lib/generators/type/type.generator.ts
+var _TypeGenerator = class _TypeGenerator {
+  constructor(swaggerPath, outputRoot, config) {
+    __publicField(this, "project");
+    __publicField(this, "parser");
+    __publicField(this, "sourceFile");
+    __publicField(this, "generatedTypes", /* @__PURE__ */ new Set());
+    __publicField(this, "config");
+    this.config = config;
+    const outputPath = outputRoot + "/models/index.ts";
+    this.project = new import_ts_morph.Project({
+      compilerOptions: __spreadValues({
+        declaration: true,
+        target: import_ts_morph.ScriptTarget.ES2022,
+        module: import_ts_morph.ModuleKind.Preserve,
+        strict: true
+      }, this.config.compilerOptions)
+    });
+    try {
+      this.parser = new SwaggerParser(swaggerPath);
+      this.sourceFile = this.project.createSourceFile(outputPath, "", {
+        overwrite: true
+      });
+    } catch (error) {
+      console.error("Error initializing TypeGenerator:", error);
+      throw error;
+    }
+  }
+  generate() {
+    try {
+      const definitions = this.parser.getDefinitions();
+      if (!definitions || Object.keys(definitions).length === 0) {
+        console.warn("No definitions found in swagger file");
+        return;
+      }
+      this.sourceFile.insertText(0, TYPE_GENERATOR_HEADER_COMMENT);
+      Object.entries(definitions).forEach(([name, definition]) => {
+        this.generateInterface(name, definition);
+      });
+      this.sourceFile.saveSync();
+    } catch (error) {
+      console.error("Error in generate():", error);
+      throw new Error(`Failed to generate types: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  generateInterface(name, definition) {
+    const interfaceName = this.pascalCaseForEnums(name);
+    if (this.generatedTypes.has(interfaceName)) {
+      return;
+    }
+    this.generatedTypes.add(interfaceName);
+    if (definition.enum) {
+      this.generateEnum(interfaceName, definition);
+      return;
+    }
+    if (definition.allOf) {
+      this.generateCompositeType(interfaceName, definition);
+      return;
+    }
+    const interfaceDeclaration = this.sourceFile.addInterface({
+      name: interfaceName,
+      isExported: true,
+      docs: definition.description ? [
+        definition.description
+      ] : void 0
+    });
+    this.addInterfaceProperties(interfaceDeclaration, definition);
+  }
+  generateEnum(name, definition) {
+    var _a;
+    if (!((_a = definition.enum) == null ? void 0 : _a.length)) return;
+    const isStringEnum = definition.enum.some((value) => typeof value === "string");
+    if (isStringEnum) {
+      const unionType = definition.enum.map((value) => typeof value === "string" ? `'${this.escapeString(value)}'` : String(value)).join(" | ");
+      this.sourceFile.addTypeAlias({
+        name,
+        type: unionType,
+        isExported: true,
+        docs: definition.description ? [
+          definition.description
+        ] : void 0
+      });
+    } else if (definition.description && this.config.options.generateEnumBasedOnDescription) {
+      const enumDeclaration = this.sourceFile.addEnum({
+        name,
+        isExported: true
+      });
+      try {
+        const enumValueObjects = JSON.parse(definition.description);
+        enumValueObjects.forEach((enumValueObject) => {
+          enumDeclaration.addMember({
+            name: enumValueObject.Name,
+            value: enumValueObject.Value
+          });
+        });
+      } catch (e) {
+        console.error(`Failed to parse enum description for ${name}`);
+        definition.enum.forEach((value) => {
+          const enumKey = this.toEnumKey(value);
+          enumDeclaration.addMember({
+            name: enumKey,
+            value
+          });
+        });
+      }
+    } else {
+      const enumDeclaration = this.sourceFile.addEnum({
+        name,
+        isExported: true,
+        docs: definition.description ? [
+          definition.description
+        ] : void 0
+      });
+      definition.enum.forEach((value) => {
+        const enumKey = this.toEnumKey(value);
+        enumDeclaration.addMember({
+          name: enumKey,
+          value
+        });
+      });
+    }
+  }
+  generateCompositeType(name, definition) {
+    let typeExpression = "";
+    if (definition.allOf) {
+      const types = definition.allOf.map((def) => this.resolveSwaggerType(def)).filter((type) => type !== "any" && type !== "unknown");
+      typeExpression = types.length > 0 ? types.join(" & ") : "Record<string, unknown>";
+    }
+    this.sourceFile.addTypeAlias({
+      name,
+      type: typeExpression,
+      isExported: true,
+      docs: definition.description ? [
+        definition.description
+      ] : void 0
+    });
+  }
+  addInterfaceProperties(interfaceDeclaration, definition) {
+    if (!definition.properties && definition.additionalProperties === false) {
+      interfaceDeclaration.addIndexSignature({
+        keyName: "key",
+        keyType: "string",
+        returnType: "never"
+      });
+      return;
+    }
+    if (!definition.properties && definition.additionalProperties === true) {
+      interfaceDeclaration.addIndexSignature({
+        keyName: "key",
+        keyType: "string",
+        returnType: "any"
+      });
+      return;
+    }
+    if (!definition.properties) {
+      console.warn(`No properties found for interface ${interfaceDeclaration.getName()}`);
+      return;
+    }
+    Object.entries(definition.properties).forEach(([propertyName, property]) => {
+      var _a, _b;
+      const isRequired = (_b = (_a = definition.required) == null ? void 0 : _a.includes(propertyName)) != null ? _b : false;
+      const isReadOnly = property.readOnly;
+      const propertyType = this.resolveSwaggerType(property);
+      const sanitizedName = this.sanitizePropertyName(propertyName);
+      interfaceDeclaration.addProperty({
+        name: sanitizedName,
+        type: propertyType,
+        isReadonly: isReadOnly,
+        hasQuestionToken: !isRequired,
+        docs: property.description ? [
+          property.description
+        ] : void 0
+      });
+    });
+  }
+  resolveSwaggerType(schema) {
+    if (schema.$ref) {
+      return this.resolveReference(schema.$ref);
+    }
+    if (schema.enum) {
+      return schema.enum.map((value) => typeof value === "string" ? `'${this.escapeString(value)}'` : String(value)).join(" | ");
+    }
+    if (schema.allOf) {
+      return schema.allOf.map((def) => this.resolveSwaggerType(def)).filter((type) => type !== "any" && type !== "unknown").join(" & ") || "Record";
+    }
+    if (schema.oneOf) {
+      return schema.oneOf.map((def) => this.resolveSwaggerType(def)).filter((type) => type !== "any" && type !== "unknown").join(" | ") || "unknown";
+    }
+    if (schema.anyOf) {
+      return schema.anyOf.map((def) => this.resolveSwaggerType(def)).filter((type) => type !== "any" && type !== "unknown").join(" | ") || "unknown";
+    }
+    if (schema.type === "array") {
+      const itemType = schema.items ? this.getArrayItemType(schema.items) : "unknown";
+      return `${itemType}[]`;
+    }
+    if (schema.type === "object") {
+      if (schema.properties) {
+        return this.generateInlineObjectType(schema);
+      }
+      if (schema.additionalProperties) {
+        const valueType = typeof schema.additionalProperties === "object" ? this.resolveSwaggerType(schema.additionalProperties) : "unknown";
+        return `Record<string, ${valueType}>`;
+      }
+      return "Record<string, unknown>";
+    }
+    return this.mapSwaggerTypeToTypeScript(schema.type, schema.format, schema.nullable);
+  }
+  generateInlineObjectType(definition) {
+    if (!definition.properties) {
+      if (definition.additionalProperties) {
+        const additionalType = typeof definition.additionalProperties === "object" ? this.resolveSwaggerType(definition.additionalProperties) : "unknown";
+        return `Record<string, ${additionalType}>`;
+      }
+      return "Record<string, unknown>";
+    }
+    const properties = Object.entries(definition.properties).map(([key, prop]) => {
+      var _a, _b;
+      const isRequired = (_b = (_a = definition.required) == null ? void 0 : _a.includes(key)) != null ? _b : false;
+      const questionMark = isRequired ? "" : "?";
+      const sanitizedKey = this.sanitizePropertyName(key);
+      return `${sanitizedKey}${questionMark}: ${this.resolveSwaggerType(prop)}`;
+    }).join("; ");
+    return `{ ${properties} }`;
+  }
+  resolveReference(ref) {
+    try {
+      const refDefinition = this.parser.resolveReference(ref);
+      const refName = ref.split("/").pop();
+      if (!refName) {
+        console.warn(`Invalid reference format: ${ref}`);
+        return "unknown";
+      }
+      const typeName = this.pascalCaseForEnums(refName);
+      if (refDefinition && !this.generatedTypes.has(typeName)) {
+        this.generateInterface(refName, refDefinition);
+      }
+      return typeName;
+    } catch (error) {
+      console.warn(`Failed to resolve reference ${ref}:`, error);
+      return "unknown";
+    }
+  }
+  mapSwaggerTypeToTypeScript(type, format, isNullable) {
+    if (!type) return "unknown";
+    switch (type) {
+      case "string":
+        if (format === "date" || format === "date-time") {
+          const dateType = this.config.options.dateType === "Date" ? "Date" : "string";
+          return this.nullableType(dateType, isNullable);
+        }
+        if (format === "binary") return "Blob";
+        if (format === "uuid") return "string";
+        if (format === "email") return "string";
+        if (format === "uri") return "string";
+        return this.nullableType("string", isNullable);
+      case "number":
+      case "integer":
+        return this.nullableType("number", isNullable);
+      case "boolean":
+        return this.nullableType("boolean", isNullable);
+      case "array":
+        return this.nullableType("unknown[]", isNullable);
+      case "object":
+        return this.nullableType("Record<string, unknown>", isNullable);
+      case "null":
+        return this.nullableType("null", isNullable);
+      default:
+        console.warn(`Unknown swagger type: ${type}`);
+        return this.nullableType("unknown", isNullable);
+    }
+  }
+  nullableType(type, isNullable) {
+    return type + (isNullable ? " | null" : "");
+  }
+  pascalCaseForEnums(str) {
+    return str.replace(/[^a-zA-Z0-9]/g, "_").replace(/(?:^|_)([a-z])/g, (_, char) => char.toUpperCase()).replace(/^([0-9])/, "_$1");
+  }
+  sanitizePropertyName(name) {
+    if (!/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name)) {
+      return `"${name}"`;
+    }
+    return name;
+  }
+  toEnumKey(value) {
+    return value.toString().replace(/[^a-zA-Z0-9]/g, "_").replace(/^([0-9])/, "_$1").toUpperCase();
+  }
+  getArrayItemType(items) {
+    if (Array.isArray(items)) {
+      const types = items.map((item) => this.resolveSwaggerType(item));
+      return `[${types.join(", ")}]`;
+    } else {
+      return this.resolveSwaggerType(items);
+    }
+  }
+  escapeString(str) {
+    return str.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+  }
+};
+__name(_TypeGenerator, "TypeGenerator");
+var TypeGenerator = _TypeGenerator;
+
+// src/lib/generators/utility/token.generator.ts
+var import_ts_morph2 = require("ts-morph");
+var path = __toESM(require("path"));
+var _TokenGenerator = class _TokenGenerator {
+  constructor(project) {
+    __publicField(this, "project");
+    this.project = project;
+  }
+  generate(outputDir) {
+    const tokensDir = path.join(outputDir, "tokens");
+    const filePath = path.join(tokensDir, "index.ts");
+    const sourceFile = this.project.createSourceFile(filePath, "", {
+      overwrite: true
+    });
+    sourceFile.addImportDeclaration({
+      namedImports: [
+        "InjectionToken"
+      ],
+      moduleSpecifier: "@angular/core"
+    });
+    sourceFile.addVariableStatement({
+      isExported: true,
+      declarationKind: import_ts_morph2.VariableDeclarationKind.Const,
+      declarations: [
+        {
+          name: "BASE_PATH",
+          initializer: `new InjectionToken<string>('BASE_PATH', {
+  providedIn: 'root',
+  factory: () => '/api', // Default fallback
+})`
+        }
+      ],
+      leadingTrivia: `/**
+ * Injection token for the base API path
+ */
+`
+    });
+    sourceFile.saveSync();
+  }
+};
+__name(_TokenGenerator, "TokenGenerator");
+var TokenGenerator = _TokenGenerator;
+
+// src/lib/generators/utility/file-download.generator.ts
+var path2 = __toESM(require("path"));
+var _FileDownloadGenerator = class _FileDownloadGenerator {
+  constructor(project) {
+    __publicField(this, "project");
+    this.project = project;
+  }
+  generate(outputDir) {
+    const utilsDir = path2.join(outputDir, "utils");
+    const filePath = path2.join(utilsDir, "file-download.ts");
+    const sourceFile = this.project.createSourceFile(filePath, "", {
+      overwrite: true
+    });
+    sourceFile.addImportDeclaration({
+      namedImports: [
+        "Observable"
+      ],
+      moduleSpecifier: "rxjs"
+    });
+    sourceFile.addImportDeclaration({
+      namedImports: [
+        "tap"
+      ],
+      moduleSpecifier: "rxjs/operators"
+    });
+    sourceFile.addFunction({
+      name: "downloadFile",
+      isExported: true,
+      parameters: [
+        {
+          name: "blob",
+          type: "Blob"
+        },
+        {
+          name: "filename",
+          type: "string"
+        },
+        {
+          name: "mimeType",
+          type: "string",
+          hasQuestionToken: true
+        }
+      ],
+      returnType: "void",
+      statements: `
+    // Create a temporary URL for the blob
+    const url = window.URL.createObjectURL(blob);
+    
+    // Create a temporary anchor element and trigger download
+    const link = document.createElement('a');
+    link.href = url;
+    link.download = filename;
+    
+    // Append to body, click, and remove
+    document.body.appendChild(link);
+    link.click();
+    document.body.removeChild(link);
+    
+    // Clean up the URL
+    window.URL.revokeObjectURL(url);`
+    });
+    sourceFile.addFunction({
+      name: "downloadFileOperator",
+      isExported: true,
+      typeParameters: [
+        {
+          name: "T",
+          constraint: "Blob"
+        }
+      ],
+      parameters: [
+        {
+          name: "filename",
+          type: "string | ((blob: T) => string)"
+        },
+        {
+          name: "mimeType",
+          type: "string",
+          hasQuestionToken: true
+        }
+      ],
+      returnType: "(source: Observable<T>) => Observable<T>",
+      statements: `
+    return (source: Observable<T>) => {
+        return source.pipe(
+            tap((blob: T) => {
+                const actualFilename = typeof filename === 'function' ? filename(blob) : filename;
+                downloadFile(blob, actualFilename, mimeType);
+            })
+        );
+    };`
+    });
+    sourceFile.addFunction({
+      name: "extractFilenameFromContentDisposition",
+      isExported: true,
+      parameters: [
+        {
+          name: "contentDisposition",
+          type: "string | null"
+        },
+        {
+          name: "fallbackFilename",
+          type: "string",
+          initializer: '"download"'
+        }
+      ],
+      returnType: "string",
+      statements: `
+    if (!contentDisposition) {
+        return fallbackFilename;
+    }
+    
+    // Try to extract filename from Content-Disposition header
+    // Supports both "filename=" and "filename*=" formats
+    const filenameMatch = contentDisposition.match(/filename\\*?=['"]?([^'"\\n;]+)['"]?/i);
+    
+    if (filenameMatch && filenameMatch[1]) {
+        // Decode if it's RFC 5987 encoded (filename*=UTF-8''...)
+        const filename = filenameMatch[1];
+        if (filename.includes("''")) {
+            const parts = filename.split("''");
+            if (parts.length === 2) {
+                try {
+                    return decodeURIComponent(parts[1]);
+                } catch {
+                    return parts[1];
+                }
+            }
+        }
+        return filename;
+    }
+    
+    return fallbackFilename;`
+    });
+    sourceFile.saveSync();
+  }
+};
+__name(_FileDownloadGenerator, "FileDownloadGenerator");
+var FileDownloadGenerator = _FileDownloadGenerator;
+
+// src/lib/generators/utility/date-transformer.generator.ts
+var path3 = __toESM(require("path"));
+var _DateTransformerGenerator = class _DateTransformerGenerator {
+  constructor(project) {
+    __publicField(this, "project");
+    this.project = project;
+  }
+  generate(outputDir) {
+    const utilsDir = path3.join(outputDir, "utils");
+    const filePath = path3.join(utilsDir, "date-transformer.ts");
+    const sourceFile = this.project.createSourceFile(filePath, "", {
+      overwrite: true
+    });
+    sourceFile.addImportDeclaration({
+      namedImports: [
+        "HttpInterceptor",
+        "HttpRequest",
+        "HttpHandler",
+        "HttpEvent",
+        "HttpResponse"
+      ],
+      moduleSpecifier: "@angular/common/http"
+    });
+    sourceFile.addImportDeclaration({
+      namedImports: [
+        "Injectable"
+      ],
+      moduleSpecifier: "@angular/core"
+    });
+    sourceFile.addImportDeclaration({
+      namedImports: [
+        "Observable"
+      ],
+      moduleSpecifier: "rxjs"
+    });
+    sourceFile.addImportDeclaration({
+      namedImports: [
+        "map"
+      ],
+      moduleSpecifier: "rxjs/operators"
+    });
+    sourceFile.addVariableStatement({
+      isExported: true,
+      declarationKind: "const",
+      declarations: [
+        {
+          name: "ISO_DATE_REGEX",
+          initializer: "/^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\.\\d{3})?Z?$/"
+        }
+      ]
+    });
+    sourceFile.addFunction({
+      name: "transformDates",
+      isExported: true,
+      parameters: [
+        {
+          name: "obj",
+          type: "any"
+        }
+      ],
+      returnType: "any",
+      statements: `
+    if (obj === null || obj === undefined || typeof obj !== 'object') {
+        return obj;
+    }
+
+    if (obj instanceof Date) {
+        return obj;
+    }
+
+    if (Array.isArray(obj)) {
+        return obj.map(item => transformDates(item));
+    }
+
+    if (typeof obj === 'object') {
+        const transformed: any = {};
+        for (const key of Object.keys(obj)) {
+            const value = obj[key];
+            if (typeof value === 'string' && ISO_DATE_REGEX.test(value)) {
+                transformed[key] = new Date(value);
+            } else {
+                transformed[key] = transformDates(value);
+            }
+        }
+        return transformed;
+    }
+
+    return obj;`
+    });
+    sourceFile.addClass({
+      name: "DateInterceptor",
+      isExported: true,
+      decorators: [
+        {
+          name: "Injectable",
+          arguments: []
+        }
+      ],
+      implements: [
+        "HttpInterceptor"
+      ],
+      methods: [
+        {
+          name: "intercept",
+          parameters: [
+            {
+              name: "req",
+              type: "HttpRequest<any>"
+            },
+            {
+              name: "next",
+              type: "HttpHandler"
+            }
+          ],
+          returnType: "Observable<HttpEvent<any>>",
+          statements: `
+    return next.handle(req).pipe(
+        map(event => {
+            if (event instanceof HttpResponse && event.body) {
+                return event.clone({ body: transformDates(event.body) });
+            }
+            return event;
+        })
+    );`
+        }
+      ]
+    });
+    sourceFile.saveSync();
+  }
+};
+__name(_DateTransformerGenerator, "DateTransformerGenerator");
+var DateTransformerGenerator = _DateTransformerGenerator;
+
+// src/lib/generators/service/service.generator.ts
+var import_ts_morph3 = require("ts-morph");
+var path4 = __toESM(require("path"));
+
+// src/lib/utils/string.utils.ts
+function camelCase(str) {
+  const cleaned = str.replace(/[-_](\w)/g, (_, c) => c.toUpperCase());
+  return cleaned.charAt(0).toLowerCase() + cleaned.slice(1);
+}
+__name(camelCase, "camelCase");
+function kebabCase(str) {
+  return str.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
+}
+__name(kebabCase, "kebabCase");
+function pascalCase(str) {
+  return str.replace(/(?:^|[-_])([a-z])/g, (_, char) => char.toUpperCase());
+}
+__name(pascalCase, "pascalCase");
+
+// src/lib/utils/type.utils.ts
+function getTypeScriptType(schemaOrType, config, formatOrNullable, isNullable, context = "type") {
+  let schema;
+  let nullable;
+  if (typeof schemaOrType === "string" || schemaOrType === void 0) {
+    schema = {
+      type: schemaOrType,
+      format: typeof formatOrNullable === "string" ? formatOrNullable : void 0
+    };
+    nullable = typeof formatOrNullable === "boolean" ? formatOrNullable : isNullable;
+  } else {
+    schema = schemaOrType;
+    nullable = typeof formatOrNullable === "boolean" ? formatOrNullable : schema.nullable;
+  }
+  if (!schema) {
+    return "any";
+  }
+  if (schema.$ref) {
+    const refName = schema.$ref.split("/").pop();
+    return nullableType(pascalCase(refName), nullable);
+  }
+  if (schema.type === "array") {
+    const itemType = schema.items ? getTypeScriptType(schema.items, config, void 0, void 0, context) : "unknown";
+    return nullable ? `(${itemType}[] | null)` : `${itemType}[]`;
+  }
+  switch (schema.type) {
+    case "string":
+      if (schema.format === "date" || schema.format === "date-time") {
+        const dateType = config.options.dateType === "Date" ? "Date" : "string";
+        return nullableType(dateType, nullable);
+      }
+      if (schema.format === "binary") {
+        const binaryType = context === "type" ? "Blob" : "File";
+        return nullableType(binaryType, nullable);
+      }
+      if (schema.format === "uuid" || schema.format === "email" || schema.format === "uri" || schema.format === "hostname" || schema.format === "ipv4" || schema.format === "ipv6") {
+        return nullableType("string", nullable);
+      }
+      return nullableType("string", nullable);
+    case "number":
+    case "integer":
+      return nullableType("number", nullable);
+    case "boolean":
+      return nullableType("boolean", nullable);
+    case "object":
+      return nullableType(context === "type" ? "Record<string, unknown>" : "any", nullable);
+    case "null":
+      return "null";
+    default:
+      console.warn(`Unknown swagger type: ${schema.type}`);
+      return nullableType("any", nullable);
+  }
+}
+__name(getTypeScriptType, "getTypeScriptType");
+function nullableType(type, isNullable) {
+  return type + (isNullable ? " | null" : "");
+}
+__name(nullableType, "nullableType");
+
+// src/lib/generators/service/service-method/service-method-body.generator.ts
+var _ServiceMethodBodyGenerator = class _ServiceMethodBodyGenerator {
+  constructor(config) {
+    __publicField(this, "config");
+    this.config = config;
+  }
+  generateMethodBody(operation) {
+    const context = this.createGenerationContext(operation);
+    const bodyParts = [
+      this.generateUrlConstruction(operation, context),
+      this.generateQueryParams(context),
+      this.generateHeaders(context),
+      this.generateMultipartFormData(operation, context),
+      this.generateRequestOptions(context),
+      this.generateHttpRequest(operation, context)
+    ];
+    return bodyParts.filter(Boolean).join("\n");
+  }
+  getRequestBodyType(requestBody) {
+    const content = requestBody.content || {};
+    const jsonContent = content["application/json"];
+    if (jsonContent == null ? void 0 : jsonContent.schema) {
+      return getTypeScriptType(jsonContent.schema, this.config, jsonContent.schema.nullable);
+    }
+    return "any";
+  }
+  isMultipartFormData(operation) {
+    var _a, _b;
+    return !!((_b = (_a = operation.requestBody) == null ? void 0 : _a.content) == null ? void 0 : _b["multipart/form-data"]);
+  }
+  getFormDataFields(operation) {
+    var _a, _b, _c, _d;
+    if (!this.isMultipartFormData(operation)) {
+      return [];
+    }
+    const properties = ((_d = (_c = (_b = (_a = operation.requestBody) == null ? void 0 : _a.content) == null ? void 0 : _b["multipart/form-data"]) == null ? void 0 : _c.schema) == null ? void 0 : _d.properties) || {};
+    return Object.keys(properties);
+  }
+  getResponseTypeFromResponse(response) {
+    var _a, _b, _c;
+    const content = response.content || {};
+    if (Object.keys(content).length === 0) {
+      return "json";
+    }
+    const responseTypes = [];
+    for (const [contentType, mediaType] of Object.entries(content)) {
+      const schema = mediaType == null ? void 0 : mediaType.schema;
+      const mapping = ((_b = (_a = this.config) == null ? void 0 : _a.options) == null ? void 0 : _b.responseTypeMapping) || {};
+      if (mapping[contentType]) {
+        responseTypes.push({
+          type: mapping[contentType],
+          priority: 1,
+          contentType
+        });
+        continue;
+      }
+      if ((schema == null ? void 0 : schema.format) === "binary" || (schema == null ? void 0 : schema.format) === "byte") {
+        responseTypes.push({
+          type: "blob",
+          priority: 2,
+          contentType
+        });
+        continue;
+      }
+      if ((schema == null ? void 0 : schema.type) === "string" && ((schema == null ? void 0 : schema.format) === "binary" || (schema == null ? void 0 : schema.format) === "byte")) {
+        responseTypes.push({
+          type: "blob",
+          priority: 2,
+          contentType
+        });
+        continue;
+      }
+      const inferredType = this.inferResponseTypeFromContentType(contentType);
+      let priority = 3;
+      if (inferredType === "json") {
+        priority = 2;
+      }
+      responseTypes.push({
+        type: inferredType,
+        priority,
+        contentType
+      });
+    }
+    responseTypes.sort((a, b) => a.priority - b.priority);
+    return ((_c = responseTypes[0]) == null ? void 0 : _c.type) || "json";
+  }
+  createGenerationContext(operation) {
+    var _a, _b;
+    return {
+      pathParams: ((_a = operation.parameters) == null ? void 0 : _a.filter((p) => p.in === "path")) || [],
+      queryParams: ((_b = operation.parameters) == null ? void 0 : _b.filter((p) => p.in === "query")) || [],
+      hasBody: !!operation.requestBody,
+      isMultipart: this.isMultipartFormData(operation),
+      formDataFields: this.getFormDataFields(operation),
+      responseType: this.determineResponseType(operation)
+    };
+  }
+  generateUrlConstruction(operation, context) {
+    let urlExpression = `\`\${this.basePath}${operation.path}\``;
+    if (context.pathParams.length > 0) {
+      context.pathParams.forEach((param) => {
+        urlExpression = urlExpression.replace(`{${param.name}}`, `\${${param.name}}`);
+      });
+    }
+    return `const url = ${urlExpression};`;
+  }
+  generateQueryParams(context) {
+    if (context.queryParams.length === 0) {
+      return "";
+    }
+    const paramMappings = context.queryParams.map((param) => `if (${param.name} !== undefined) {
+  params = params.set('${param.name}', String(${param.name}));
+}`).join("\n");
+    return `
+let params = new HttpParams();
+${paramMappings}`;
+  }
+  generateHeaders(context) {
+    const hasCustomHeaders = this.config.options.customHeaders;
+    if (!hasCustomHeaders && !context.isMultipart) {
+      return "";
+    }
+    let headerCode = `
+let headers: HttpHeaders;
+if (options?.headers instanceof HttpHeaders) {
+  headers = options.headers;
+} else {
+  headers = new HttpHeaders(options?.headers);
+}`;
+    if (hasCustomHeaders) {
+      headerCode += `
+// Add default headers if not already present
+${Object.entries(this.config.options.customHeaders || {}).map(([key, value]) => `if (!headers.has('${key}')) {
+  headers = headers.set('${key}', '${value}');
+}`).join("\n")}`;
+    }
+    if (context.isMultipart) {
+      headerCode += `
+// Remove Content-Type for multipart (browser will set it with boundary)
+headers = headers.delete('Content-Type');`;
+    } else if (!context.isMultipart) {
+      headerCode += `
+// Set Content-Type for JSON requests if not already set
+if (!headers.has('Content-Type')) {
+  headers = headers.set('Content-Type', 'application/json');
+}`;
+    }
+    return headerCode;
+  }
+  generateMultipartFormData(operation, context) {
+    if (!context.isMultipart || context.formDataFields.length === 0) {
+      return "";
+    }
+    const formDataAppends = context.formDataFields.map((field) => {
+      var _a, _b, _c, _d, _e;
+      const fieldSchema = (_e = (_d = (_c = (_b = (_a = operation.requestBody) == null ? void 0 : _a.content) == null ? void 0 : _b["multipart/form-data"]) == null ? void 0 : _c.schema) == null ? void 0 : _d.properties) == null ? void 0 : _e[field];
+      const isFile = (fieldSchema == null ? void 0 : fieldSchema.type) === "string" && (fieldSchema == null ? void 0 : fieldSchema.format) === "binary";
+      const valueExpression = isFile ? field : `String(${field})`;
+      return `if (${field} !== undefined) {
+  formData.append('${field}', ${valueExpression});
+}`;
+    }).join("\n");
+    return `
+const formData = new FormData();
+${formDataAppends}`;
+  }
+  generateRequestOptions(context) {
+    const options = [];
+    options.push("observe: observe as any");
+    const hasHeaders = this.config.options.customHeaders || context.isMultipart;
+    if (hasHeaders) {
+      options.push("headers");
+    }
+    if (context.queryParams.length > 0) {
+      options.push("params");
+    }
+    if (context.responseType !== "json") {
+      options.push(`responseType: '${context.responseType}' as '${context.responseType}'`);
+    }
+    options.push("reportProgress: options?.reportProgress");
+    options.push("withCredentials: options?.withCredentials");
+    if (options.length > 0) {
+      options.push("context: options?.context");
+    }
+    const formattedOptions = options.filter((opt) => opt && !opt.includes("undefined")).join(",\n  ");
+    return `
+const requestOptions: any = {
+  ${formattedOptions}
+};`;
+  }
+  generateHttpRequest(operation, context) {
+    var _a, _b;
+    const httpMethod = operation.method.toLowerCase();
+    let bodyParam = "";
+    if (context.hasBody) {
+      if (context.isMultipart) {
+        bodyParam = "formData";
+      } else if ((_b = (_a = operation.requestBody) == null ? void 0 : _a.content) == null ? void 0 : _b["application/json"]) {
+        const bodyType = this.getRequestBodyType(operation.requestBody);
+        const isInterface = this.isDataTypeInterface(bodyType);
+        bodyParam = isInterface ? camelCase(bodyType) : "requestBody";
+      }
+    }
+    const methodsWithBody = [
+      "post",
+      "put",
+      "patch"
+    ];
+    if (methodsWithBody.includes(httpMethod)) {
+      return `
+return this.httpClient.${httpMethod}(url, ${bodyParam || "null"}, requestOptions);`;
+    } else {
+      return `
+return this.httpClient.${httpMethod}(url, requestOptions);`;
+    }
+  }
+  determineResponseType(operation) {
+    var _a;
+    const successResponses = [
+      "200",
+      "201",
+      "202",
+      "204",
+      "206"
+    ];
+    for (const statusCode of successResponses) {
+      const response = (_a = operation.responses) == null ? void 0 : _a[statusCode];
+      if (!response) continue;
+      return this.getResponseTypeFromResponse(response);
+    }
+    return "json";
+  }
+  isDataTypeInterface(type) {
+    const invalidTypes = [
+      "any",
+      "File",
+      "string",
+      "number",
+      "boolean",
+      "object",
+      "unknown",
+      "[]",
+      "Array"
+    ];
+    return !invalidTypes.some((invalidType) => type.includes(invalidType));
+  }
+  inferResponseTypeFromContentType(contentType) {
+    const normalizedType = contentType.split(";")[0].trim().toLowerCase();
+    if (normalizedType.includes("json") || normalizedType === "application/ld+json" || normalizedType === "application/hal+json" || normalizedType === "application/vnd.api+json") {
+      return "json";
+    }
+    if (normalizedType.includes("xml") || normalizedType === "application/soap+xml" || normalizedType === "application/atom+xml" || normalizedType === "application/rss+xml") {
+      return "text";
+    }
+    if (normalizedType.startsWith("text/")) {
+      const binaryTextTypes = [
+        "text/rtf",
+        "text/cache-manifest",
+        "text/vcard",
+        "text/calendar"
+      ];
+      if (binaryTextTypes.includes(normalizedType)) {
+        return "blob";
+      }
+      return "text";
+    }
+    if (normalizedType === "application/x-www-form-urlencoded" || normalizedType === "multipart/form-data") {
+      return "text";
+    }
+    if (normalizedType === "application/javascript" || normalizedType === "application/typescript" || normalizedType === "application/css" || normalizedType === "application/yaml" || normalizedType === "application/x-yaml" || normalizedType === "application/toml") {
+      return "text";
+    }
+    if (normalizedType.startsWith("image/") || normalizedType.startsWith("audio/") || normalizedType.startsWith("video/") || normalizedType === "application/pdf" || normalizedType === "application/zip" || normalizedType.includes("octet-stream")) {
+      return "arraybuffer";
+    }
+    return "blob";
+  }
+};
+__name(_ServiceMethodBodyGenerator, "ServiceMethodBodyGenerator");
+var ServiceMethodBodyGenerator = _ServiceMethodBodyGenerator;
+
+// src/lib/generators/service/service-method/service-method-params.generator.ts
+var _ServiceMethodParamsGenerator = class _ServiceMethodParamsGenerator {
+  constructor(config) {
+    __publicField(this, "config");
+    this.config = config;
+  }
+  generateMethodParameters(operation) {
+    const params = this.generateApiParameters(operation);
+    const optionsParam = this.addOptionsParameter();
+    const combined = [
+      ...params,
+      ...optionsParam
+    ];
+    const seen = /* @__PURE__ */ new Set();
+    const uniqueParams = [];
+    for (const param of combined) {
+      if (!seen.has(param.name)) {
+        seen.add(param.name);
+        uniqueParams.push(param);
+      }
+    }
+    return uniqueParams;
+  }
+  generateApiParameters(operation) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+    const params = [];
+    const pathParams = ((_a = operation.parameters) == null ? void 0 : _a.filter((p) => p.in === "path")) || [];
+    pathParams.forEach((param) => {
+      params.push({
+        name: param.name,
+        type: getTypeScriptType(param.schema || param, this.config),
+        hasQuestionToken: !param.required
+      });
+    });
+    if (operation.requestBody && ((_c = (_b = operation.requestBody) == null ? void 0 : _b.content) == null ? void 0 : _c["multipart/form-data"])) {
+      Object.entries((_g = (_f = (_e = (_d = operation.requestBody) == null ? void 0 : _d.content) == null ? void 0 : _e["multipart/form-data"].schema) == null ? void 0 : _f.properties) != null ? _g : {}).forEach(([key, value]) => {
+        params.push({
+          name: key,
+          type: getTypeScriptType(value, this.config, value.nullable),
+          hasQuestionToken: !value.required
+        });
+      });
+    }
+    if (operation.requestBody && ((_i = (_h = operation.requestBody) == null ? void 0 : _h.content) == null ? void 0 : _i["application/json"])) {
+      const bodyType = this.getRequestBodyType(operation.requestBody);
+      const isInterface = this.isDataTypeInterface(bodyType);
+      params.push({
+        name: isInterface ? camelCase(bodyType) : "requestBody",
+        type: bodyType,
+        hasQuestionToken: !operation.requestBody.required
+      });
+    }
+    const queryParams = ((_j = operation.parameters) == null ? void 0 : _j.filter((p) => p.in === "query")) || [];
+    queryParams.forEach((param) => {
+      params.push({
+        name: param.name,
+        type: getTypeScriptType(param.schema || param, this.config),
+        hasQuestionToken: !param.required
+      });
+    });
+    return params;
+  }
+  addOptionsParameter() {
+    return [
+      {
+        name: "observe",
+        type: `'body' | 'events' | 'response'`,
+        hasQuestionToken: true
+      },
+      {
+        name: "options",
+        type: `{ headers?: HttpHeaders; params?: HttpParams; reportProgress?: boolean; responseType?: 'arraybuffer' | 'blob' | 'json' | 'text'; withCredentials?: boolean; context?: HttpContext; }`,
+        hasQuestionToken: true
+      }
+    ];
+  }
+  isDataTypeInterface(type) {
+    const invalidTypes = [
+      "any",
+      "File",
+      "string",
+      "number",
+      "boolean",
+      "object",
+      "unknown",
+      "[]",
+      "Array"
+    ];
+    return !invalidTypes.some((invalidType) => type.includes(invalidType));
+  }
+  getRequestBodyType(requestBody) {
+    const content = requestBody.content || {};
+    const jsonContent = content["application/json"];
+    if (jsonContent == null ? void 0 : jsonContent.schema) {
+      return getTypeScriptType(jsonContent.schema, this.config, jsonContent.schema.nullable);
+    }
+    return "any";
+  }
+};
+__name(_ServiceMethodParamsGenerator, "ServiceMethodParamsGenerator");
+var ServiceMethodParamsGenerator = _ServiceMethodParamsGenerator;
+
+// src/lib/generators/service/service-method/service-method-overloads.generator.ts
+var _ServiceMethodOverloadsGenerator = class _ServiceMethodOverloadsGenerator {
+  constructor(config) {
+    __publicField(this, "config");
+    __publicField(this, "paramsGenerator");
+    this.config = config;
+    this.paramsGenerator = new ServiceMethodParamsGenerator(config);
+  }
+  generateMethodOverloads(operation) {
+    const observeTypes = [
+      "body",
+      "response",
+      "events"
+    ];
+    const overloads = [];
+    const responseType = this.determineResponseTypeForOperation(operation);
+    observeTypes.forEach((observe) => {
+      const overload = this.generateMethodOverload(operation, observe, responseType);
+      if (overload) {
+        overloads.push(overload);
+      }
+    });
+    return overloads;
+  }
+  generateMethodOverload(operation, observe, responseType) {
+    const responseDataType = this.generateOverloadResponseType(operation);
+    const params = this.generateOverloadParameters(operation, observe, responseType);
+    const returnType = this.generateOverloadReturnType(responseDataType, observe);
+    return {
+      parameters: params,
+      returnType
+    };
+  }
+  generateOverloadParameters(operation, observe, responseType) {
+    const params = this.paramsGenerator.generateApiParameters(operation);
+    const optionsParam = this.addOverloadOptionsParameter(observe, responseType);
+    const combined = [
+      ...params,
+      ...optionsParam
+    ];
+    const seen = /* @__PURE__ */ new Set();
+    const uniqueParams = [];
+    for (const param of combined) {
+      if (!seen.has(param.name)) {
+        seen.add(param.name);
+        uniqueParams.push(param);
+      }
+    }
+    return uniqueParams;
+  }
+  addOverloadOptionsParameter(observe, responseType) {
+    return [
+      {
+        name: "observe",
+        type: `'${observe}'`,
+        hasQuestionToken: true
+      },
+      {
+        name: "options",
+        type: `{ headers?: HttpHeaders; reportProgress?: boolean; responseType?: '${responseType}'; withCredentials?: boolean; context?: HttpContext; }`,
+        hasQuestionToken: true
+      }
+    ];
+  }
+  generateOverloadResponseType(operation) {
+    var _a, _b, _c;
+    const response = ((_a = operation.responses) == null ? void 0 : _a["200"]) || ((_b = operation.responses) == null ? void 0 : _b["201"]) || ((_c = operation.responses) == null ? void 0 : _c["204"]);
+    if (!response) {
+      return "any";
+    }
+    return this.getResponseType(response);
+  }
+  generateOverloadReturnType(responseType, observe) {
+    switch (observe) {
+      case "body":
+        return `Observable<${responseType}>`;
+      case "response":
+        return `Observable<HttpResponse<${responseType}>>`;
+      case "events":
+        return `Observable<HttpEvent<${responseType}>>`;
+      default:
+        throw new Error(`Unsupported observe type: ${observe}`);
+    }
+  }
+  getResponseTypeFromResponse(response) {
+    var _a, _b, _c;
+    const content = response.content || {};
+    if (Object.keys(content).length === 0) {
+      return "json";
+    }
+    const responseTypes = [];
+    for (const [contentType, mediaType] of Object.entries(content)) {
+      const schema = mediaType == null ? void 0 : mediaType.schema;
+      const mapping = ((_b = (_a = this.config) == null ? void 0 : _a.options) == null ? void 0 : _b.responseTypeMapping) || {};
+      if (mapping[contentType]) {
+        responseTypes.push({
+          type: mapping[contentType],
+          priority: 1,
+          contentType
+        });
+        continue;
+      }
+      if ((schema == null ? void 0 : schema.format) === "binary" || (schema == null ? void 0 : schema.format) === "byte") {
+        responseTypes.push({
+          type: "blob",
+          priority: 2,
+          contentType
+        });
+        continue;
+      }
+      if ((schema == null ? void 0 : schema.type) === "string" && ((schema == null ? void 0 : schema.format) === "binary" || (schema == null ? void 0 : schema.format) === "byte")) {
+        responseTypes.push({
+          type: "blob",
+          priority: 2,
+          contentType
+        });
+        continue;
+      }
+      const inferredType = this.inferResponseTypeFromContentType(contentType);
+      let priority = 3;
+      if (inferredType === "json") {
+        priority = 2;
+      }
+      responseTypes.push({
+        type: inferredType,
+        priority,
+        contentType
+      });
+    }
+    responseTypes.sort((a, b) => a.priority - b.priority);
+    return ((_c = responseTypes[0]) == null ? void 0 : _c.type) || "json";
+  }
+  getResponseType(response) {
+    const responseType = this.getResponseTypeFromResponse(response);
+    switch (responseType) {
+      case "blob":
+        return "Blob";
+      case "arraybuffer":
+        return "ArrayBuffer";
+      case "text":
+        return "string";
+      case "json": {
+        const content = response.content || {};
+        for (const [contentType, mediaType] of Object.entries(content)) {
+          if (this.inferResponseTypeFromContentType(contentType) === "json" && (mediaType == null ? void 0 : mediaType.schema)) {
+            return getTypeScriptType(mediaType.schema, this.config, mediaType.schema.nullable);
+          }
+        }
+        return "any";
+      }
+      default:
+        return "any";
+    }
+  }
+  determineResponseTypeForOperation(operation) {
+    var _a;
+    const successResponses = [
+      "200",
+      "201",
+      "202",
+      "204",
+      "206"
+    ];
+    for (const statusCode of successResponses) {
+      const response = (_a = operation.responses) == null ? void 0 : _a[statusCode];
+      if (!response) continue;
+      return this.getResponseTypeFromResponse(response);
+    }
+    return "json";
+  }
+  inferResponseTypeFromContentType(contentType) {
+    const normalizedType = contentType.split(";")[0].trim().toLowerCase();
+    if (normalizedType.includes("json") || normalizedType === "application/ld+json" || normalizedType === "application/hal+json" || normalizedType === "application/vnd.api+json") {
+      return "json";
+    }
+    if (normalizedType.includes("xml") || normalizedType === "application/soap+xml" || normalizedType === "application/atom+xml" || normalizedType === "application/rss+xml") {
+      return "text";
+    }
+    if (normalizedType.startsWith("text/")) {
+      const binaryTextTypes = [
+        "text/rtf",
+        "text/cache-manifest",
+        "text/vcard",
+        "text/calendar"
+      ];
+      if (binaryTextTypes.includes(normalizedType)) {
+        return "blob";
+      }
+      return "text";
+    }
+    if (normalizedType === "application/x-www-form-urlencoded" || normalizedType === "multipart/form-data") {
+      return "text";
+    }
+    if (normalizedType === "application/javascript" || normalizedType === "application/typescript" || normalizedType === "application/css" || normalizedType === "application/yaml" || normalizedType === "application/x-yaml" || normalizedType === "application/toml") {
+      return "text";
+    }
+    if (normalizedType.startsWith("image/") || normalizedType.startsWith("audio/") || normalizedType.startsWith("video/") || normalizedType === "application/pdf" || normalizedType === "application/zip" || normalizedType.includes("octet-stream")) {
+      return "arraybuffer";
+    }
+    return "blob";
+  }
+};
+__name(_ServiceMethodOverloadsGenerator, "ServiceMethodOverloadsGenerator");
+var ServiceMethodOverloadsGenerator = _ServiceMethodOverloadsGenerator;
+
+// src/lib/generators/service/service-method.generator.ts
+var _ServiceMethodGenerator = class _ServiceMethodGenerator {
+  constructor(config) {
+    __publicField(this, "config");
+    __publicField(this, "bodyGenerator");
+    __publicField(this, "overloadsGenerator");
+    __publicField(this, "paramsGenerator");
+    this.config = config;
+    this.bodyGenerator = new ServiceMethodBodyGenerator(config);
+    this.overloadsGenerator = new ServiceMethodOverloadsGenerator(config);
+    this.paramsGenerator = new ServiceMethodParamsGenerator(config);
+  }
+  addServiceMethod(serviceClass, operation) {
+    const methodName = this.generateMethodName(operation);
+    const parameters = this.paramsGenerator.generateMethodParameters(operation);
+    const returnType = this.generateReturnType();
+    const methodBody = this.bodyGenerator.generateMethodBody(operation);
+    const methodOverLoads = this.overloadsGenerator.generateMethodOverloads(operation);
+    serviceClass.addMethod({
+      name: methodName,
+      parameters,
+      returnType,
+      statements: methodBody,
+      overloads: methodOverLoads
+    });
+  }
+  generateMethodName(operation) {
+    if (this.config.options.customizeMethodName) {
+      if (operation.operationId == null) {
+        throw new Error(`Operation ID is required for method name customization of operation: (${operation.method}) ${operation.path}`);
+      }
+      return this.config.options.customizeMethodName(operation.operationId);
+    } else {
+      return this.defaultNameGenerator(operation);
+    }
+  }
+  generateReturnType() {
+    return "Observable<any>";
+  }
+  defaultNameGenerator(operation) {
+    if (operation.operationId) {
+      return camelCase(operation.operationId);
+    }
+    const method = operation.method.toLowerCase();
+    const pathParts = operation.path.split("/").filter((p) => p && !p.startsWith("{"));
+    const resource = pathParts[pathParts.length - 1] || "resource";
+    return `${method}${pascalCase(resource)}`;
+  }
+};
+__name(_ServiceMethodGenerator, "ServiceMethodGenerator");
+var ServiceMethodGenerator = _ServiceMethodGenerator;
+
+// src/lib/generators/service/service.generator.ts
+var _ServiceGenerator = class _ServiceGenerator {
+  constructor(swaggerPath, project, config) {
+    __publicField(this, "project");
+    __publicField(this, "parser");
+    __publicField(this, "spec");
+    __publicField(this, "config");
+    __publicField(this, "methodGenerator");
+    this.config = config;
+    this.project = project;
+    this.parser = new SwaggerParser(swaggerPath);
+    this.spec = JSON.parse(require("fs").readFileSync(swaggerPath, "utf8"));
+    this.methodGenerator = new ServiceMethodGenerator(config);
+  }
+  generate(outputRoot) {
+    const outputDir = path4.join(outputRoot, "services");
+    const paths = this.extractPaths();
+    const controllerGroups = this.groupPathsByController(paths);
+    Object.entries(controllerGroups).forEach(([controllerName, operations]) => {
+      this.generateServiceFile(controllerName, operations, outputDir);
+    });
+  }
+  extractPaths() {
+    const paths = [];
+    const swaggerPaths = this.spec.paths || {};
+    Object.entries(swaggerPaths).forEach(([path6, pathItem]) => {
+      const methods = [
+        "get",
+        "post",
+        "put",
+        "patch",
+        "delete",
+        "options",
+        "head"
+      ];
+      methods.forEach((method) => {
+        if (pathItem[method]) {
+          const operation = pathItem[method];
+          paths.push({
+            path: path6,
+            method: method.toUpperCase(),
+            operationId: operation.operationId,
+            summary: operation.summary,
+            description: operation.description,
+            tags: operation.tags || [],
+            parameters: this.parseParameters(operation.parameters || [], pathItem.parameters || []),
+            requestBody: operation.requestBody,
+            responses: operation.responses || {}
+          });
+        }
+      });
+    });
+    return paths;
+  }
+  parseParameters(operationParams, pathParams) {
+    const allParams = [
+      ...pathParams,
+      ...operationParams
+    ];
+    return allParams.map((param) => ({
+      name: param.name,
+      in: param.in,
+      required: param.required || param.in === "path",
+      schema: param.schema,
+      type: param.type,
+      format: param.format,
+      description: param.description
+    }));
+  }
+  groupPathsByController(paths) {
+    const groups = {};
+    paths.forEach((path6) => {
+      let controllerName = "Default";
+      if (path6.tags && path6.tags.length > 0) {
+        controllerName = path6.tags[0];
+      } else {
+        const pathParts = path6.path.split("/").filter((p) => p && !p.startsWith("{"));
+        if (pathParts.length > 1) {
+          controllerName = pascalCase(pathParts[1]);
+        }
+      }
+      controllerName = pascalCase(controllerName);
+      if (!groups[controllerName]) {
+        groups[controllerName] = [];
+      }
+      groups[controllerName].push(path6);
+    });
+    return groups;
+  }
+  generateServiceFile(controllerName, operations, outputDir) {
+    const fileName = `${kebabCase(controllerName)}.service.ts`;
+    const filePath = path4.join(outputDir, fileName);
+    const sourceFile = this.project.createSourceFile(filePath, "", {
+      overwrite: true
+    });
+    const usedTypes = this.collectUsedTypes(operations);
+    this.addImports(sourceFile, usedTypes);
+    this.addServiceClass(sourceFile, controllerName, operations);
+    sourceFile.saveSync();
+  }
+  collectUsedTypes(operations) {
+    const usedTypes = /* @__PURE__ */ new Set();
+    operations.forEach((operation) => {
+      var _a;
+      (_a = operation.parameters) == null ? void 0 : _a.forEach((param) => {
+        this.collectTypesFromSchema(param.schema || param, usedTypes);
+      });
+      if (operation.requestBody) {
+        this.collectTypesFromRequestBody(operation.requestBody, usedTypes);
+      }
+      if (operation.responses) {
+        Object.values(operation.responses).forEach((response) => {
+          this.collectTypesFromResponse(response, usedTypes);
+        });
+      }
+    });
+    return usedTypes;
+  }
+  collectTypesFromSchema(schema, usedTypes) {
+    if (!schema) return;
+    if (schema.$ref) {
+      const refName = schema.$ref.split("/").pop();
+      if (refName) {
+        usedTypes.add(pascalCase(refName));
+      }
+    }
+    if (schema.type === "array" && schema.items) {
+      this.collectTypesFromSchema(schema.items, usedTypes);
+    }
+    if (schema.type === "object" && schema.properties) {
+      Object.values(schema.properties).forEach((prop) => {
+        this.collectTypesFromSchema(prop, usedTypes);
+      });
+    }
+    if (schema.allOf) {
+      schema.allOf.forEach((subSchema) => {
+        this.collectTypesFromSchema(subSchema, usedTypes);
+      });
+    }
+    if (schema.oneOf) {
+      schema.oneOf.forEach((subSchema) => {
+        this.collectTypesFromSchema(subSchema, usedTypes);
+      });
+    }
+    if (schema.anyOf) {
+      schema.anyOf.forEach((subSchema) => {
+        this.collectTypesFromSchema(subSchema, usedTypes);
+      });
+    }
+  }
+  collectTypesFromRequestBody(requestBody, usedTypes) {
+    const content = requestBody.content || {};
+    Object.values(content).forEach((mediaType) => {
+      if (mediaType.schema) {
+        this.collectTypesFromSchema(mediaType.schema, usedTypes);
+      }
+    });
+  }
+  collectTypesFromResponse(response, usedTypes) {
+    const content = response.content || {};
+    Object.values(content).forEach((mediaType) => {
+      if (mediaType.schema) {
+        this.collectTypesFromSchema(mediaType.schema, usedTypes);
+      }
+    });
+  }
+  addImports(sourceFile, usedTypes) {
+    sourceFile.addImportDeclarations([
+      {
+        namedImports: [
+          "Injectable",
+          "inject"
+        ],
+        moduleSpecifier: "@angular/core"
+      },
+      {
+        namedImports: [
+          "HttpClient",
+          "HttpParams",
+          "HttpHeaders",
+          "HttpContext",
+          "HttpResponse",
+          "HttpEvent"
+        ],
+        moduleSpecifier: "@angular/common/http"
+      },
+      {
+        namedImports: [
+          "Observable"
+        ],
+        moduleSpecifier: "rxjs"
+      },
+      {
+        namedImports: [
+          "BASE_PATH"
+        ],
+        moduleSpecifier: "../tokens"
+      }
+    ]);
+    if (usedTypes.size > 0) {
+      sourceFile.addImportDeclaration({
+        namedImports: Array.from(usedTypes).sort(),
+        moduleSpecifier: "../models"
+      });
+    }
+  }
+  addServiceClass(sourceFile, controllerName, operations) {
+    const className = `${controllerName}Service`;
+    sourceFile.insertText(0, SERVICE_GENERATOR_HEADER_COMMENT(controllerName));
+    const serviceClass = sourceFile.addClass({
+      name: className,
+      isExported: true,
+      decorators: [
+        {
+          name: "Injectable",
+          arguments: [
+            '{ providedIn: "root" }'
+          ]
+        }
+      ]
+    });
+    serviceClass.addProperty({
+      name: "httpClient",
+      type: "HttpClient",
+      scope: import_ts_morph3.Scope.Private,
+      isReadonly: true,
+      initializer: "inject(HttpClient)"
+    });
+    serviceClass.addProperty({
+      name: "basePath",
+      type: "string",
+      scope: import_ts_morph3.Scope.Private,
+      isReadonly: true,
+      initializer: "inject(BASE_PATH)"
+    });
+    operations.forEach((operation) => {
+      this.methodGenerator.addServiceMethod(serviceClass, operation);
+    });
+    if (this.hasDuplicateMethodNames(serviceClass.getMethods())) {
+      throw new Error(`Duplicate method names found in service class ${className}. Please ensure unique method names for each operation.`);
+    }
+  }
+  hasDuplicateMethodNames(arr) {
+    return new Set(arr.map((method) => method.getName())).size !== arr.length;
+  }
+};
+__name(_ServiceGenerator, "ServiceGenerator");
+var ServiceGenerator = _ServiceGenerator;
+
+// src/lib/generators/service/service-index.generator.ts
+var fs2 = __toESM(require("fs"));
+var path5 = __toESM(require("path"));
+var _ServiceIndexGenerator = class _ServiceIndexGenerator {
+  constructor(project) {
+    __publicField(this, "project");
+    this.project = project;
+  }
+  generateIndex(outputRoot) {
+    const servicesDir = path5.join(outputRoot, "services");
+    const indexPath = path5.join(servicesDir, "index.ts");
+    const sourceFile = this.project.createSourceFile(indexPath, "", {
+      overwrite: true
+    });
+    sourceFile.insertText(0, SERVICE_INDEX_GENERATOR_HEADER_COMMENT);
+    const serviceFiles = fs2.readdirSync(servicesDir).filter((file) => file.endsWith(".service.ts")).map((file) => file.replace(".service.ts", ""));
+    serviceFiles.forEach((serviceName) => {
+      const className = pascalCase(serviceName) + "Service";
+      sourceFile.addExportDeclaration({
+        namedExports: [
+          className
+        ],
+        moduleSpecifier: `./${serviceName}.service`
+      });
+    });
+    sourceFile.saveSync();
+  }
+};
+__name(_ServiceIndexGenerator, "ServiceIndexGenerator");
+var ServiceIndexGenerator = _ServiceIndexGenerator;
+
+// src/lib/core/generator.ts
+var fs3 = __toESM(require("fs"));
+function generateFromConfig(config) {
+  return __async(this, null, function* () {
+    var _a;
+    if (!fs3.existsSync(config.input)) {
+      throw new Error(`Input file not found: ${config.input}`);
+    }
+    const outputPath = config.output;
+    const generateServices = (_a = config.options.generateServices) != null ? _a : true;
+    if (!fs3.existsSync(outputPath)) {
+      fs3.mkdirSync(outputPath, {
+        recursive: true
+      });
+    }
+    try {
+      const project = new import_ts_morph4.Project({
+        compilerOptions: __spreadValues({
+          declaration: true,
+          target: import_ts_morph4.ScriptTarget.ES2022,
+          module: import_ts_morph4.ModuleKind.Preserve,
+          strict: true
+        }, config.compilerOptions)
+      });
+      const typeGenerator = new TypeGenerator(config.input, outputPath, config);
+      typeGenerator.generate();
+      console.log(`\u2705 TypeScript interfaces generated`);
+      if (generateServices) {
+        const tokenGenerator = new TokenGenerator(project);
+        tokenGenerator.generate(outputPath);
+        if (config.options.dateType === "Date") {
+          const dateTransformer = new DateTransformerGenerator(project);
+          dateTransformer.generate(outputPath);
+          console.log(`\u2705 Date transformer generated`);
+        }
+        const fileDownloadHelper = new FileDownloadGenerator(project);
+        fileDownloadHelper.generate(outputPath);
+        console.log(`\u2705 File download helper generated`);
+        const serviceGenerator = new ServiceGenerator(config.input, project, config);
+        serviceGenerator.generate(outputPath);
+        const indexGenerator = new ServiceIndexGenerator(project);
+        indexGenerator.generateIndex(outputPath);
+        console.log(`\u2705 Angular services generated`);
+      }
+      console.log("\u{1F389} Generation completed successfully at:", outputPath);
+    } catch (error) {
+      if (error instanceof Error) {
+        console.error("\u274C Error during generation:", error.message);
+      } else {
+        console.error("\u274C Unknown error during generation:", error);
+      }
+      throw error;
+    }
+  });
+}
+__name(generateFromConfig, "generateFromConfig");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SwaggerParser,
+  generateFromConfig
+});
+//# sourceMappingURL=index.js.map