ng-openapi 0.0.2

package/cli.cjs

@@ -0,0 +1,1827 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: 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
+));
+
+// src/lib/cli.ts
+var import_commander = require("commander");
+var path6 = __toESM(require("path"));
+var fs4 = __toESM(require("fs"));
+
+// src/lib/core/swagger-parser.ts
+var fs = __toESM(require("fs"));
+var SwaggerParser = class {
+  static {
+    __name(this, "SwaggerParser");
+  }
+  spec;
+  constructor(swaggerPath) {
+    const swaggerContent = fs.readFileSync(swaggerPath, "utf8");
+    this.spec = JSON.parse(swaggerContent);
+  }
+  getDefinitions() {
+    return this.spec.definitions || this.spec.components?.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());
+  }
+};
+
+// 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 {
+  static {
+    __name(this, "TypeGenerator");
+  }
+  project;
+  parser;
+  sourceFile;
+  generatedTypes = /* @__PURE__ */ new Set();
+  config;
+  constructor(swaggerPath, outputRoot, config) {
+    this.config = config;
+    const outputPath = outputRoot + "/models/index.ts";
+    this.project = new import_ts_morph.Project({
+      compilerOptions: {
+        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) {
+    if (!definition.enum?.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]) => {
+      const isRequired = definition.required?.includes(propertyName) ?? 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]) => {
+      const isRequired = definition.required?.includes(key) ?? 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, "\\'");
+  }
+};
+
+// src/lib/generators/utility/token.generator.ts
+var import_ts_morph2 = require("ts-morph");
+var path = __toESM(require("path"));
+var TokenGenerator = class {
+  static {
+    __name(this, "TokenGenerator");
+  }
+  project;
+  constructor(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();
+  }
+};
+
+// src/lib/generators/utility/file-download.generator.ts
+var path2 = __toESM(require("path"));
+var FileDownloadGenerator = class {
+  static {
+    __name(this, "FileDownloadGenerator");
+  }
+  project;
+  constructor(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();
+  }
+};
+
+// src/lib/generators/utility/date-transformer.generator.ts
+var path3 = __toESM(require("path"));
+var DateTransformerGenerator = class {
+  static {
+    __name(this, "DateTransformerGenerator");
+  }
+  project;
+  constructor(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();
+  }
+};
+
+// 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 {
+  static {
+    __name(this, "ServiceMethodBodyGenerator");
+  }
+  config;
+  constructor(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?.schema) {
+      return getTypeScriptType(jsonContent.schema, this.config, jsonContent.schema.nullable);
+    }
+    return "any";
+  }
+  isMultipartFormData(operation) {
+    return !!operation.requestBody?.content?.["multipart/form-data"];
+  }
+  getFormDataFields(operation) {
+    if (!this.isMultipartFormData(operation)) {
+      return [];
+    }
+    const properties = operation.requestBody?.content?.["multipart/form-data"]?.schema?.properties || {};
+    return Object.keys(properties);
+  }
+  getResponseTypeFromResponse(response) {
+    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?.schema;
+      const mapping = this.config?.options?.responseTypeMapping || {};
+      if (mapping[contentType]) {
+        responseTypes.push({
+          type: mapping[contentType],
+          priority: 1,
+          contentType
+        });
+        continue;
+      }
+      if (schema?.format === "binary" || schema?.format === "byte") {
+        responseTypes.push({
+          type: "blob",
+          priority: 2,
+          contentType
+        });
+        continue;
+      }
+      if (schema?.type === "string" && (schema?.format === "binary" || 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 responseTypes[0]?.type || "json";
+  }
+  createGenerationContext(operation) {
+    return {
+      pathParams: operation.parameters?.filter((p) => p.in === "path") || [],
+      queryParams: operation.parameters?.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) => {
+      const fieldSchema = operation.requestBody?.content?.["multipart/form-data"]?.schema?.properties?.[field];
+      const isFile = fieldSchema?.type === "string" && 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) {
+    const httpMethod = operation.method.toLowerCase();
+    let bodyParam = "";
+    if (context.hasBody) {
+      if (context.isMultipart) {
+        bodyParam = "formData";
+      } else if (operation.requestBody?.content?.["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) {
+    const successResponses = [
+      "200",
+      "201",
+      "202",
+      "204",
+      "206"
+    ];
+    for (const statusCode of successResponses) {
+      const response = operation.responses?.[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";
+  }
+};
+
+// src/lib/generators/service/service-method/service-method-params.generator.ts
+var ServiceMethodParamsGenerator = class {
+  static {
+    __name(this, "ServiceMethodParamsGenerator");
+  }
+  config;
+  constructor(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) {
+    const params = [];
+    const pathParams = operation.parameters?.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 && operation.requestBody?.content?.["multipart/form-data"]) {
+      Object.entries(operation.requestBody?.content?.["multipart/form-data"].schema?.properties ?? {}).forEach(([key, value]) => {
+        params.push({
+          name: key,
+          type: getTypeScriptType(value, this.config, value.nullable),
+          hasQuestionToken: !value.required
+        });
+      });
+    }
+    if (operation.requestBody && operation.requestBody?.content?.["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 = operation.parameters?.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?.schema) {
+      return getTypeScriptType(jsonContent.schema, this.config, jsonContent.schema.nullable);
+    }
+    return "any";
+  }
+};
+
+// src/lib/generators/service/service-method/service-method-overloads.generator.ts
+var ServiceMethodOverloadsGenerator = class {
+  static {
+    __name(this, "ServiceMethodOverloadsGenerator");
+  }
+  config;
+  paramsGenerator;
+  constructor(config) {
+    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) {
+    const response = operation.responses?.["200"] || operation.responses?.["201"] || operation.responses?.["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) {
+    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?.schema;
+      const mapping = this.config?.options?.responseTypeMapping || {};
+      if (mapping[contentType]) {
+        responseTypes.push({
+          type: mapping[contentType],
+          priority: 1,
+          contentType
+        });
+        continue;
+      }
+      if (schema?.format === "binary" || schema?.format === "byte") {
+        responseTypes.push({
+          type: "blob",
+          priority: 2,
+          contentType
+        });
+        continue;
+      }
+      if (schema?.type === "string" && (schema?.format === "binary" || 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 responseTypes[0]?.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?.schema) {
+            return getTypeScriptType(mediaType.schema, this.config, mediaType.schema.nullable);
+          }
+        }
+        return "any";
+      }
+      default:
+        return "any";
+    }
+  }
+  determineResponseTypeForOperation(operation) {
+    const successResponses = [
+      "200",
+      "201",
+      "202",
+      "204",
+      "206"
+    ];
+    for (const statusCode of successResponses) {
+      const response = operation.responses?.[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";
+  }
+};
+
+// src/lib/generators/service/service-method.generator.ts
+var ServiceMethodGenerator = class {
+  static {
+    __name(this, "ServiceMethodGenerator");
+  }
+  config;
+  bodyGenerator;
+  overloadsGenerator;
+  paramsGenerator;
+  constructor(config) {
+    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)}`;
+  }
+};
+
+// src/lib/generators/service/service.generator.ts
+var ServiceGenerator = class {
+  static {
+    __name(this, "ServiceGenerator");
+  }
+  project;
+  parser;
+  spec;
+  config;
+  methodGenerator;
+  constructor(swaggerPath, project, config) {
+    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(([path7, pathItem]) => {
+      const methods = [
+        "get",
+        "post",
+        "put",
+        "patch",
+        "delete",
+        "options",
+        "head"
+      ];
+      methods.forEach((method) => {
+        if (pathItem[method]) {
+          const operation = pathItem[method];
+          paths.push({
+            path: path7,
+            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((path7) => {
+      let controllerName = "Default";
+      if (path7.tags && path7.tags.length > 0) {
+        controllerName = path7.tags[0];
+      } else {
+        const pathParts = path7.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(path7);
+    });
+    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) => {
+      operation.parameters?.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;
+  }
+};
+
+// src/lib/generators/service/service-index.generator.ts
+var fs2 = __toESM(require("fs"));
+var path5 = __toESM(require("path"));
+var ServiceIndexGenerator = class {
+  static {
+    __name(this, "ServiceIndexGenerator");
+  }
+  project;
+  constructor(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();
+  }
+};
+
+// src/lib/core/generator.ts
+var fs3 = __toESM(require("fs"));
+async function generateFromConfig(config) {
+  if (!fs3.existsSync(config.input)) {
+    throw new Error(`Input file not found: ${config.input}`);
+  }
+  const outputPath = config.output;
+  const generateServices = config.options.generateServices ?? true;
+  if (!fs3.existsSync(outputPath)) {
+    fs3.mkdirSync(outputPath, {
+      recursive: true
+    });
+  }
+  try {
+    const project = new import_ts_morph4.Project({
+      compilerOptions: {
+        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");
+
+// src/lib/cli.ts
+var program = new import_commander.Command();
+async function loadConfigFile(configPath) {
+  const resolvedPath = path6.resolve(configPath);
+  if (!fs4.existsSync(resolvedPath)) {
+    throw new Error(`Configuration file not found: ${resolvedPath}`);
+  }
+  delete require.cache[require.resolve(resolvedPath)];
+  try {
+    if (resolvedPath.endsWith(".ts")) {
+      require("ts-node/register");
+    }
+    const configModule = require(resolvedPath);
+    const config = configModule.default || configModule.config || configModule;
+    if (!config.input || !config.output) {
+      throw new Error('Configuration must include "input" and "output" properties');
+    }
+    return config;
+  } catch (error) {
+    throw new Error(`Failed to load configuration file: ${error instanceof Error ? error.message : error}`);
+  }
+}
+__name(loadConfigFile, "loadConfigFile");
+async function generateFromOptions(options) {
+  try {
+    if (options.config) {
+      const config = await loadConfigFile(options.config);
+      await generateFromConfig(config);
+    } else if (options.input) {
+      const inputPath = path6.resolve(options.input);
+      if (!fs4.existsSync(inputPath)) {
+        console.error(`Error: Input file not found: ${inputPath}`);
+        process.exit(1);
+      }
+      const config = {
+        input: inputPath,
+        output: options.output || "./src/generated",
+        options: {
+          dateType: options.dateType || "Date",
+          enumStyle: "enum",
+          generateEnumBasedOnDescription: true,
+          generateServices: !options.typesOnly
+        }
+      };
+      await generateFromConfig(config);
+    } else {
+      console.error("Error: Either --config or --input option is required");
+      program.help();
+      process.exit(1);
+    }
+    console.log("\u2728 Generation completed successfully!");
+  } catch (error) {
+    console.error("\u274C Generation failed:", error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+}
+__name(generateFromOptions, "generateFromOptions");
+program.name("ng-openapi").description("Generate Angular services and types from Swagger/OpenAPI spec").version("0.0.1").option("-c, --config <path>", "Path to configuration file").option("-i, --input <path>", "Path to Swagger/OpenAPI specification file").option("-o, --output <path>", "Output directory", "./src/generated").option("--types-only", "Generate only TypeScript interfaces").option("--date-type <type>", "Date type to use (string | Date)", "Date").action(async (options) => {
+  await generateFromOptions(options);
+});
+program.command("generate").alias("gen").description("Generate code from Swagger specification").option("-c, --config <path>", "Path to configuration file").option("-i, --input <path>", "Path to Swagger/OpenAPI specification file").option("-o, --output <path>", "Output directory", "./src/generated").option("--types-only", "Generate only TypeScript interfaces").option("--date-type <type>", "Date type to use (string | Date)", "Date").action(async (options) => {
+  await generateFromOptions(options);
+});
+program.on("--help", () => {
+  console.log("");
+  console.log("Examples:");
+  console.log("  $ ng-openapi -c ./openapi.config.ts");
+  console.log("  $ ng-openapi -i ./swagger.json -o ./src/api");
+  console.log("  $ ng-openapi generate -c ./openapi.config.ts");
+  console.log("  $ ng-openapi generate -i ./api.yaml --types-only");
+});
+program.parse();
+//# sourceMappingURL=cli.cjs.map