ng-openapi 0.2.22 → 0.3.0

package/cli.cjs

@@ -24,6 +24,9 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
+// ../shared/src/core/spec-loader.ts
+var fs = __toESM(require("fs"));
+
 // ../shared/src/utils/functions/is-url.ts
 function isUrl(input) {
   try {
@@ -38,16 +41,197 @@ function isUrl(input) {
 }
 __name(isUrl, "isUrl");
 
-// src/lib/cli.ts
-var import_commander = require("commander");
-var fs4 = __toESM(require("fs"));
-var path13 = __toESM(require("path"));
+// ../shared/src/errors.ts
+var NgOpenApiError = class extends Error {
+  static {
+    __name(this, "NgOpenApiError");
+  }
+  /** The underlying error that caused this one, when there is one. */
+  cause;
+  constructor(message, cause) {
+    super(message);
+    this.name = new.target.name;
+    this.cause = cause;
+  }
+};
+var SpecLoadError = class extends NgOpenApiError {
+  static {
+    __name(this, "SpecLoadError");
+  }
+  /** The file path or URL that failed to load. */
+  source;
+  constructor(message, source, cause) {
+    super(message, cause);
+    this.source = source;
+  }
+};
+var SpecParseError = class extends NgOpenApiError {
+  static {
+    __name(this, "SpecParseError");
+  }
+  /** The file path or URL the content came from, when known. */
+  source;
+  constructor(message, source, cause) {
+    super(message, cause);
+    this.source = source;
+  }
+};
 
-// package.json
-var version = "0.2.22";
+// ../shared/src/core/spec-loader.ts
+async function loadSpecContent(pathOrUrl) {
+  if (isUrl(pathOrUrl)) {
+    return await fetchUrlContent(pathOrUrl);
+  }
+  try {
+    return fs.readFileSync(pathOrUrl, "utf8");
+  } catch (error) {
+    throw new SpecLoadError(`Failed to read spec file: ${pathOrUrl}${error instanceof Error ? ` - ${error.message}` : ""}`, pathOrUrl, error);
+  }
+}
+__name(loadSpecContent, "loadSpecContent");
+async function fetchUrlContent(url) {
+  try {
+    const response = await fetch(url, {
+      method: "GET",
+      headers: {
+        Accept: "application/json, application/yaml, text/yaml, text/plain, */*",
+        "User-Agent": "ng-openapi"
+      },
+      // 30 second timeout
+      signal: AbortSignal.timeout(3e4)
+    });
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+    const content = await response.text();
+    if (!content || content.trim() === "") {
+      throw new Error(`Empty response from URL: ${url}`);
+    }
+    return content;
+  } catch (error) {
+    let errorMessage = `Failed to fetch content from URL: ${url}`;
+    if (error instanceof Error && (error.name === "TimeoutError" || error.name === "AbortError")) {
+      errorMessage += " - Request timeout (30s)";
+    } else if (error instanceof Error && error.message) {
+      errorMessage += ` - ${error.message}`;
+    }
+    throw new SpecLoadError(errorMessage, url, error);
+  }
+}
+__name(fetchUrlContent, "fetchUrlContent");
 
-// src/lib/core/generator.ts
-var import_ts_morph7 = require("ts-morph");
+// ../shared/src/core/spec-format.ts
+var path = __toESM(require("path"));
+var yaml = __toESM(require("js-yaml"));
+function parseSpecContent(content, pathOrUrl) {
+  let format;
+  if (isUrl(pathOrUrl)) {
+    const urlPath = new URL(pathOrUrl).pathname.toLowerCase();
+    if (urlPath.endsWith(".json")) {
+      format = "json";
+    } else if (urlPath.endsWith(".yaml") || urlPath.endsWith(".yml")) {
+      format = "yaml";
+    } else {
+      format = detectFormat(content);
+    }
+  } else {
+    const extension = path.extname(pathOrUrl).toLowerCase();
+    switch (extension) {
+      case ".json":
+        format = "json";
+        break;
+      case ".yaml":
+        format = "yaml";
+        break;
+      case ".yml":
+        format = "yml";
+        break;
+      default:
+        format = detectFormat(content);
+    }
+  }
+  try {
+    switch (format) {
+      case "json":
+        return JSON.parse(content);
+      case "yaml":
+      case "yml":
+        return yaml.load(content);
+      default:
+        throw new Error(`Unable to determine format for: ${pathOrUrl}`);
+    }
+  } catch (error) {
+    throw new SpecParseError(`Failed to parse ${format.toUpperCase()} content from: ${pathOrUrl}. Error: ${error instanceof Error ? error.message : error}`, pathOrUrl, error);
+  }
+}
+__name(parseSpecContent, "parseSpecContent");
+function detectFormat(content) {
+  const trimmed = content.trim();
+  if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+    return "json";
+  }
+  if (trimmed.includes("openapi:") || trimmed.includes("swagger:") || trimmed.includes("---") || /^[a-zA-Z][a-zA-Z0-9_]*\s*:/.test(trimmed)) {
+    return "yaml";
+  }
+  return "json";
+}
+__name(detectFormat, "detectFormat");
+
+// ../shared/src/utils/content-types.constants.ts
+var CONTENT_TYPES = {
+  MULTIPART: "multipart/form-data",
+  FORM_URLENCODED: "application/x-www-form-urlencoded",
+  JSON: "application/json"
+};
+
+// ../shared/src/utils/functions/extract-paths.ts
+function extractPaths(swaggerPaths = {}, methods = [
+  "get",
+  "post",
+  "put",
+  "patch",
+  "delete",
+  "options",
+  "head"
+]) {
+  const paths = [];
+  Object.entries(swaggerPaths).forEach(([path14, pathItem]) => {
+    methods.forEach((method) => {
+      const operation = pathItem[method];
+      if (operation) {
+        paths.push({
+          path: path14,
+          method: method.toUpperCase(),
+          operationId: operation.operationId,
+          summary: operation.summary,
+          description: operation.description,
+          tags: operation.tags || [],
+          parameters: parseParameters(operation.parameters || [], pathItem.parameters || []),
+          requestBody: operation.requestBody,
+          responses: operation.responses || {}
+        });
+      }
+    });
+  });
+  return paths;
+}
+__name(extractPaths, "extractPaths");
+function 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
+  }));
+}
+__name(parseParameters, "parseParameters");
 
 // ../shared/src/utils/string.utils.ts
 function camelCase(str) {
@@ -85,7 +269,7 @@ function getTypeScriptType(schemaOrType, config, formatOrNullable, isNullable, c
     return nullableType(pascalCaseForEnums(refName), nullable);
   }
   if (schema.type === "array") {
-    const itemType = schema.items ? getTypeScriptType(schema.items, config, void 0, void 0, context) : "unknown";
+    const itemType = schema.items ? Array.isArray(schema.items) ? "any" : getTypeScriptType(schema.items, config, void 0, void 0, context) : "unknown";
     return nullable ? `(Array<${itemType}> | null)` : `Array<${itemType}>`;
   }
   switch (schema.type) {
@@ -132,78 +316,6 @@ function escapeString(str) {
 }
 __name(escapeString, "escapeString");
 
-// ../shared/src/utils/functions/token-names.ts
-function getClientContextTokenName(clientName = "default") {
-  const clientSuffix = clientName.toUpperCase().replace(/[^A-Z0-9]/g, "_");
-  return `CLIENT_CONTEXT_TOKEN_${clientSuffix}`;
-}
-__name(getClientContextTokenName, "getClientContextTokenName");
-function getBasePathTokenName(clientName = "default") {
-  const clientSuffix = clientName.toUpperCase().replace(/[^A-Z0-9]/g, "_");
-  return `BASE_PATH_${clientSuffix}`;
-}
-__name(getBasePathTokenName, "getBasePathTokenName");
-function getInterceptorsTokenName(clientName = "default") {
-  const clientSuffix = clientName.toUpperCase().replace(/[^A-Z0-9]/g, "_");
-  return `HTTP_INTERCEPTORS_${clientSuffix}`;
-}
-__name(getInterceptorsTokenName, "getInterceptorsTokenName");
-
-// ../shared/src/utils/functions/duplicate-function-name.ts
-function hasDuplicateFunctionNames(arr) {
-  return new Set(arr.map((fn) => fn.getName())).size !== arr.length;
-}
-__name(hasDuplicateFunctionNames, "hasDuplicateFunctionNames");
-
-// ../shared/src/utils/functions/extract-paths.ts
-function extractPaths(swaggerPaths = {}, methods = [
-  "get",
-  "post",
-  "put",
-  "patch",
-  "delete",
-  "options",
-  "head"
-]) {
-  const paths = [];
-  Object.entries(swaggerPaths).forEach(([path14, pathItem]) => {
-    methods.forEach((method) => {
-      if (pathItem[method]) {
-        const operation = pathItem[method];
-        paths.push({
-          path: path14,
-          method: method.toUpperCase(),
-          operationId: operation.operationId,
-          summary: operation.summary,
-          description: operation.description,
-          tags: operation.tags || [],
-          parameters: parseParameters(operation.parameters || [], pathItem.parameters || []),
-          requestBody: operation.requestBody,
-          responses: operation.responses || {}
-        });
-      }
-    });
-  });
-  return paths;
-}
-__name(extractPaths, "extractPaths");
-function 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
-  }));
-}
-__name(parseParameters, "parseParameters");
-
 // ../shared/src/utils/functions/extract-swagger-response-type.ts
 function getResponseTypeFromResponse(response, responseTypeMapping) {
   const content = response.content || {};
@@ -267,7 +379,7 @@ function isPrimitiveType(schema) {
     "integer",
     "boolean"
   ];
-  if (primitiveTypes.includes(schema.type)) {
+  if (schema.type && primitiveTypes.includes(schema.type)) {
     return true;
   }
   if (schema.type === "array") {
@@ -338,199 +450,204 @@ function getResponseType(response, config) {
 }
 __name(getResponseType, "getResponseType");
 
-// ../shared/src/utils/content-types.constants.ts
-var CONTENT_TYPES = {
-  MULTIPART: "multipart/form-data",
-  FORM_URLENCODED: "application/x-www-form-urlencoded",
-  JSON: "application/json"
-};
-
-// ../shared/src/utils/functions/get-request-body-type.ts
-function getRequestBodyType(requestBody, config) {
-  const content = requestBody.content || {};
-  const jsonContent = content[CONTENT_TYPES.JSON];
-  if (jsonContent?.schema) {
-    return getTypeScriptType(jsonContent.schema, config, jsonContent.schema.nullable);
+// ../shared/src/core/normalize.ts
+function normalizeSpec(spec) {
+  const rawDefinitions = spec.definitions || spec.components?.schemas || {};
+  const definitions = Object.fromEntries(Object.entries(rawDefinitions).map(([name, definition]) => [
+    name,
+    normalizeSchema(definition)
+  ]));
+  const resolveReference = /* @__PURE__ */ __name((ref) => {
+    const parts = ref.split("/");
+    return definitions[parts[parts.length - 1]];
+  }, "resolveReference");
+  return {
+    version: spec.swagger ? {
+      type: "swagger",
+      version: spec.swagger
+    } : spec.openapi ? {
+      type: "openapi",
+      version: spec.openapi
+    } : null,
+    definitions,
+    operations: extractPaths(spec.paths).map((operation) => normalizeOperation(normalizeOperationSchemas(operation), resolveReference)),
+    resolveReference
+  };
+}
+__name(normalizeSpec, "normalizeSpec");
+function normalizeSchema(schema) {
+  const normalized = {
+    ...schema
+  };
+  const rawType = normalized.type;
+  if (Array.isArray(rawType)) {
+    const types = rawType.filter((t) => t !== "null");
+    if (types.length < rawType.length) {
+      normalized.nullable = true;
+    }
+    normalized.type = types.length === 1 ? types[0] : types.length === 0 ? "null" : types;
+  }
+  if (normalized.const !== void 0 && !normalized.enum) {
+    const constType = typeof normalized.const;
+    if (constType === "string" || constType === "number") {
+      normalized.enum = [
+        normalized.const
+      ];
+      if (normalized.type === void 0) {
+        normalized.type = constType;
+      }
+      delete normalized.const;
+    } else if (constType === "boolean") {
+      if (normalized.type === void 0) {
+        normalized.type = "boolean";
+      }
+      delete normalized.const;
+    }
   }
-  return "any";
+  if (normalized.properties) {
+    normalized.properties = Object.fromEntries(Object.entries(normalized.properties).map(([name, property]) => [
+      name,
+      normalizeSchema(property)
+    ]));
+  }
+  if (normalized.items) {
+    normalized.items = Array.isArray(normalized.items) ? normalized.items.map(normalizeSchema) : normalizeSchema(normalized.items);
+  }
+  if (typeof normalized.additionalProperties === "object") {
+    normalized.additionalProperties = normalizeSchema(normalized.additionalProperties);
+  }
+  if (normalized.allOf) {
+    normalized.allOf = normalized.allOf.map(normalizeSchema);
+  }
+  if (normalized.oneOf) {
+    normalized.oneOf = normalized.oneOf.map(normalizeSchema);
+  }
+  if (normalized.anyOf) {
+    normalized.anyOf = normalized.anyOf.map(normalizeSchema);
+  }
+  return normalized;
 }
-__name(getRequestBodyType, "getRequestBodyType");
-
-// ../shared/src/utils/functions/is-data-type-interface.ts
-function isDataTypeInterface(type) {
-  const invalidTypes = [
-    "any",
-    "File",
-    "string",
-    "number",
-    "boolean",
-    "object",
-    "unknown",
-    "[]",
-    "Array"
+__name(normalizeSchema, "normalizeSchema");
+function normalizeOperationSchemas(operation) {
+  return {
+    ...operation,
+    parameters: operation.parameters?.map((parameter) => parameter.schema ? {
+      ...parameter,
+      schema: normalizeSchema(parameter.schema)
+    } : parameter),
+    requestBody: operation.requestBody ? {
+      ...operation.requestBody,
+      content: normalizeContentSchemas(operation.requestBody.content)
+    } : operation.requestBody,
+    responses: operation.responses ? Object.fromEntries(Object.entries(operation.responses).map(([status, response]) => [
+      status,
+      {
+        ...response,
+        content: normalizeContentSchemas(response.content)
+      }
+    ])) : operation.responses
+  };
+}
+__name(normalizeOperationSchemas, "normalizeOperationSchemas");
+function normalizeContentSchemas(content) {
+  if (!content) return content;
+  return Object.fromEntries(Object.entries(content).map(([contentType, mediaType]) => [
+    contentType,
+    mediaType?.schema ? {
+      ...mediaType,
+      schema: normalizeSchema(mediaType.schema)
+    } : mediaType
+  ]));
+}
+__name(normalizeContentSchemas, "normalizeContentSchemas");
+function normalizeOperation(operation, resolveRef) {
+  const content = operation.requestBody?.content;
+  const isMultipart = !!content?.[CONTENT_TYPES.MULTIPART];
+  const isUrlEncoded = !!content?.[CONTENT_TYPES.FORM_URLENCODED] && !content?.[CONTENT_TYPES.JSON];
+  const formDataSchema = isMultipart ? resolveBodySchema(operation.requestBody, CONTENT_TYPES.MULTIPART, resolveRef) : void 0;
+  const urlEncodedSchema = isUrlEncoded ? resolveBodySchema(operation.requestBody, CONTENT_TYPES.FORM_URLENCODED, resolveRef) : void 0;
+  return {
+    ...operation,
+    pathParams: operation.parameters?.filter((p) => p.in === "path") || [],
+    queryParams: operation.parameters?.filter((p) => p.in === "query") || [],
+    hasBody: !!operation.requestBody,
+    isMultipart,
+    isUrlEncoded,
+    formDataSchema,
+    formDataFields: Object.keys(formDataSchema?.properties || {}),
+    urlEncodedSchema,
+    urlEncodedFields: Object.keys(urlEncodedSchema?.properties || {}),
+    responseType: determineResponseType(operation)
+  };
+}
+__name(normalizeOperation, "normalizeOperation");
+function resolveBodySchema(requestBody, contentType, resolveRef) {
+  const schema = requestBody?.content?.[contentType]?.schema;
+  return schema?.$ref ? resolveRef(schema.$ref) : schema;
+}
+__name(resolveBodySchema, "resolveBodySchema");
+function determineResponseType(operation) {
+  const successResponses = [
+    "200",
+    "201",
+    "202",
+    "204",
+    "206"
   ];
-  return !invalidTypes.some((invalidType) => type.includes(invalidType));
+  for (const statusCode of successResponses) {
+    const response = operation.responses?.[statusCode];
+    if (!response) continue;
+    return getResponseTypeFromResponse(response);
+  }
+  return "json";
 }
-__name(isDataTypeInterface, "isDataTypeInterface");
-
-// ../shared/src/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");
-var REQUEST_PARAMS_GENERATOR_HEADER_COMMENT = defaultHeaderComment + `* Generated request parameter interfaces
-* Do not edit this file manually
-*/
-`;
-var MAIN_INDEX_GENERATOR_HEADER_COMMENT = defaultHeaderComment + `* Entrypoint for the client
-* Do not edit this file manually
-*/
-`;
-var PROVIDER_GENERATOR_HEADER_COMMENT = defaultHeaderComment + `* Generated provider functions for easy setup
-* Do not edit this file manually
-*/
-`;
-var BASE_INTERCEPTOR_HEADER_COMMENT = /* @__PURE__ */ __name((clientName) => defaultHeaderComment + `* Generated Base Interceptor for client ${clientName}
-* Do not edit this file manually
-*/
-`, "BASE_INTERCEPTOR_HEADER_COMMENT");
-var ZOD_PLUGIN_INDEX_GENERATOR_HEADER_COMMENT = defaultHeaderComment + `* Generated Zod Schemas exports
-* Do not edit this file manually
-*/
-`;
+__name(determineResponseType, "determineResponseType");
 
 // ../shared/src/core/swagger-parser.ts
-var fs = __toESM(require("fs"));
-var path = __toESM(require("path"));
-var yaml = __toESM(require("js-yaml"));
 var SwaggerParser = class _SwaggerParser {
   static {
     __name(this, "SwaggerParser");
   }
   spec;
+  normalized;
   constructor(spec, config) {
     const isInputValid = config.validateInput?.(spec) ?? true;
     if (!isInputValid) {
-      throw new Error("Swagger spec is not valid. Check your `validateInput` condition.");
+      throw new SpecParseError("Swagger spec is not valid. Check your `validateInput` condition.");
     }
     this.spec = spec;
   }
+  /**
+   * Loads, parses and wraps a spec.
+   *
+   * @throws SpecLoadError when the file/URL cannot be read.
+   * @throws SpecParseError when the content cannot be parsed or the
+   *   config's `validateInput` hook rejects the spec.
+   */
   static async create(swaggerPathOrUrl, config) {
-    const swaggerContent = await _SwaggerParser.loadContent(swaggerPathOrUrl);
-    const spec = _SwaggerParser.parseSpecContent(swaggerContent, swaggerPathOrUrl);
+    const swaggerContent = await loadSpecContent(swaggerPathOrUrl);
+    const spec = parseSpecContent(swaggerContent, swaggerPathOrUrl);
     return new _SwaggerParser(spec, config);
   }
-  static async loadContent(pathOrUrl) {
-    if (isUrl(pathOrUrl)) {
-      return await _SwaggerParser.fetchUrlContent(pathOrUrl);
-    } else {
-      return fs.readFileSync(pathOrUrl, "utf8");
-    }
-  }
-  static async fetchUrlContent(url) {
-    try {
-      const response = await fetch(url, {
-        method: "GET",
-        headers: {
-          Accept: "application/json, application/yaml, text/yaml, text/plain, */*",
-          "User-Agent": "ng-openapi"
-        },
-        // 30 second timeout
-        signal: AbortSignal.timeout(3e4)
-      });
-      if (!response.ok) {
-        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-      }
-      const content = await response.text();
-      if (!content || content.trim() === "") {
-        throw new Error(`Empty response from URL: ${url}`);
-      }
-      return content;
-    } catch (error) {
-      let errorMessage = `Failed to fetch content from URL: ${url}`;
-      if (error.name === "AbortError") {
-        errorMessage += " - Request timeout (30s)";
-      } else if (error.message) {
-        errorMessage += ` - ${error.message}`;
-      }
-      throw new Error(errorMessage);
-    }
-  }
-  static parseSpecContent(content, pathOrUrl) {
-    let format;
-    if (isUrl(pathOrUrl)) {
-      const urlPath = new URL(pathOrUrl).pathname.toLowerCase();
-      if (urlPath.endsWith(".json")) {
-        format = "json";
-      } else if (urlPath.endsWith(".yaml") || urlPath.endsWith(".yml")) {
-        format = "yaml";
-      } else {
-        format = _SwaggerParser.detectFormat(content);
-      }
-    } else {
-      const extension = path.extname(pathOrUrl).toLowerCase();
-      switch (extension) {
-        case ".json":
-          format = "json";
-          break;
-        case ".yaml":
-          format = "yaml";
-          break;
-        case ".yml":
-          format = "yml";
-          break;
-        default:
-          format = _SwaggerParser.detectFormat(content);
-      }
-    }
-    try {
-      switch (format) {
-        case "json":
-          return JSON.parse(content);
-        case "yaml":
-        case "yml":
-          return yaml.load(content);
-        default:
-          throw new Error(`Unable to determine format for: ${pathOrUrl}`);
-      }
-    } catch (error) {
-      throw new Error(`Failed to parse ${format.toUpperCase()} content from: ${pathOrUrl}. Error: ${error instanceof Error ? error.message : error}`);
-    }
-  }
-  static detectFormat(content) {
-    const trimmed = content.trim();
-    if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
-      return "json";
-    }
-    if (trimmed.includes("openapi:") || trimmed.includes("swagger:") || trimmed.includes("---") || /^[a-zA-Z][a-zA-Z0-9_]*\s*:/.test(trimmed)) {
-      return "yaml";
-    }
-    return "json";
+  /**
+   * The version-free model generators consume. Computed once and cached —
+   * all generators share the same NormalizedOperation instances, so they
+   * can be used as Map keys across generators.
+   */
+  getNormalizedSpec() {
+    this.normalized ??= normalizeSpec(this.spec);
+    return this.normalized;
   }
+  /** Definition map regardless of version: 2.0 `definitions` or 3.x `components.schemas`. */
   getDefinitions() {
     return this.spec.definitions || this.spec.components?.schemas || {};
   }
+  /** One definition by bare name, or undefined when the spec has none by that name. */
   getDefinition(name) {
     const definitions = this.getDefinitions();
     return definitions[name];
   }
+  /** Resolves "#/definitions/X" / "#/components/schemas/X" style refs by their last segment. */
   resolveReference(ref) {
     const parts = ref.split("/");
     const definitionName = parts[parts.length - 1];
@@ -539,15 +656,18 @@ var SwaggerParser = class _SwaggerParser {
   getAllDefinitionNames() {
     return Object.keys(this.getDefinitions());
   }
+  /** The raw parsed spec — prefer getNormalizedSpec() unless raw access is the point. */
   getSpec() {
     return this.spec;
   }
   getPaths() {
     return this.spec.paths || {};
   }
+  /** Whether the spec declares a supported version (Swagger 2.x or OpenAPI 3.x). */
   isValidSpec() {
     return !!(this.spec.swagger && this.spec.swagger.startsWith("2.") || this.spec.openapi && this.spec.openapi.startsWith("3."));
   }
+  /** Detected flavor + literal version string, or null when neither field is present. */
   getSpecVersion() {
     if (this.spec.swagger) {
       return {
@@ -565,94 +685,374 @@ var SwaggerParser = class _SwaggerParser {
   }
 };
 
-// src/lib/generators/type/type.generator.ts
+// ../shared/src/emit/headers.emit.ts
+function emitHeaders(options) {
+  const { optionsExpression, customHeaders, contentType } = options;
+  let headerCode = `
+let headers: HttpHeaders;
+if (${optionsExpression}?.headers instanceof HttpHeaders) {
+  headers = ${optionsExpression}.headers;
+} else {
+  headers = new HttpHeaders(${optionsExpression}?.headers);
+}`;
+  if (customHeaders) {
+    headerCode += `
+// Add default headers if not already present
+${emitDefaultHeaderGuards(customHeaders)}`;
+  }
+  if (contentType?.isMultipart) {
+    headerCode += `
+// Remove Content-Type for multipart (browser will set it with boundary)
+headers = headers.delete('Content-Type');`;
+  } else if (contentType?.isUrlEncoded) {
+    headerCode += `
+// Set Content-Type for URL-encoded form data
+if (!headers.has('Content-Type')) {
+  headers = headers.set('Content-Type', 'application/x-www-form-urlencoded');
+}`;
+  } else if (contentType?.hasBody) {
+    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;
+}
+__name(emitHeaders, "emitHeaders");
+function emitDefaultHeaderGuards(customHeaders) {
+  return Object.entries(customHeaders).map(([key, value]) => `if (!headers.has('${key}')) {
+  headers = headers.set('${key}', '${value}');
+}`).join("\n");
+}
+__name(emitDefaultHeaderGuards, "emitDefaultHeaderGuards");
+
+// ../shared/src/emit/url.emit.ts
+function plainParamValue(identifier) {
+  return identifier;
+}
+__name(plainParamValue, "plainParamValue");
+function emitUrlExpression(path14, pathParams, paramValue = plainParamValue) {
+  let urlExpression = `\`\${this.basePath}${path14}\``;
+  pathParams.forEach((param) => {
+    urlExpression = urlExpression.replace(`{${param.name}}`, `\${${paramValue(camelCase(param.name))}}`);
+  });
+  return urlExpression;
+}
+__name(emitUrlExpression, "emitUrlExpression");
+function emitUrlConstruction(path14, pathParams) {
+  return `const url = ${emitUrlExpression(path14, pathParams)};`;
+}
+__name(emitUrlConstruction, "emitUrlConstruction");
+
+// ../shared/src/emit/query-params.emit.ts
+function emitQueryParams(queryParams) {
+  if (queryParams.length === 0) {
+    return "";
+  }
+  const paramMappings = queryParams.map((param) => `if (${camelCase(param.name)} != null) {
+  params = HttpParamsBuilder.addToHttpParams(params, ${camelCase(param.name)}, '${param.name}');
+}`).join("\n");
+  return `
+let params = new HttpParams();
+${paramMappings}`;
+}
+__name(emitQueryParams, "emitQueryParams");
+
+// ../shared/src/emit/response-type.emit.ts
+function emitResponseTypeOption(responseType) {
+  if (responseType === "json") {
+    return "";
+  }
+  return `responseType: '${responseType}'`;
+}
+__name(emitResponseTypeOption, "emitResponseTypeOption");
+function joinRequestOptionEntries(entries) {
+  return entries.filter((entry) => entry && !entry.includes("undefined")).join(",\n  ");
+}
+__name(joinRequestOptionEntries, "joinRequestOptionEntries");
+
+// ../shared/src/utils/functions/token-names.ts
+function getClientContextTokenName(clientName = "default") {
+  const clientSuffix = clientName.toUpperCase().replace(/[^A-Z0-9]/g, "_");
+  return `CLIENT_CONTEXT_TOKEN_${clientSuffix}`;
+}
+__name(getClientContextTokenName, "getClientContextTokenName");
+function getBasePathTokenName(clientName = "default") {
+  const clientSuffix = clientName.toUpperCase().replace(/[^A-Z0-9]/g, "_");
+  return `BASE_PATH_${clientSuffix}`;
+}
+__name(getBasePathTokenName, "getBasePathTokenName");
+function getInterceptorsTokenName(clientName = "default") {
+  const clientSuffix = clientName.toUpperCase().replace(/[^A-Z0-9]/g, "_");
+  return `HTTP_INTERCEPTORS_${clientSuffix}`;
+}
+__name(getInterceptorsTokenName, "getInterceptorsTokenName");
+
+// ../shared/src/utils/functions/duplicate-function-name.ts
+function hasDuplicateFunctionNames(arr) {
+  return new Set(arr.map((fn) => fn.getName())).size !== arr.length;
+}
+__name(hasDuplicateFunctionNames, "hasDuplicateFunctionNames");
+
+// ../shared/src/utils/functions/get-request-body-type.ts
+function getRequestBodyType(requestBody, config) {
+  const content = requestBody.content || {};
+  const jsonContent = content[CONTENT_TYPES.JSON];
+  if (jsonContent?.schema) {
+    return getTypeScriptType(jsonContent.schema, config, jsonContent.schema.nullable);
+  }
+  return "any";
+}
+__name(getRequestBodyType, "getRequestBodyType");
+
+// ../shared/src/utils/functions/is-data-type-interface.ts
+function isDataTypeInterface(type) {
+  const invalidTypes = [
+    "any",
+    "File",
+    "string",
+    "number",
+    "boolean",
+    "object",
+    "unknown",
+    "[]",
+    "Array"
+  ];
+  return !invalidTypes.some((invalidType) => type.includes(invalidType));
+}
+__name(isDataTypeInterface, "isDataTypeInterface");
+
+// ../shared/src/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");
+var REQUEST_PARAMS_GENERATOR_HEADER_COMMENT = defaultHeaderComment + `* Generated request parameter interfaces
+* Do not edit this file manually
+*/
+`;
+var MAIN_INDEX_GENERATOR_HEADER_COMMENT = defaultHeaderComment + `* Entrypoint for the client
+* Do not edit this file manually
+*/
+`;
+var PROVIDER_GENERATOR_HEADER_COMMENT = defaultHeaderComment + `* Generated provider functions for easy setup
+* Do not edit this file manually
+*/
+`;
+var BASE_INTERCEPTOR_HEADER_COMMENT = /* @__PURE__ */ __name((clientName) => defaultHeaderComment + `* Generated Base Interceptor for client ${clientName}
+* Do not edit this file manually
+*/
+`, "BASE_INTERCEPTOR_HEADER_COMMENT");
+var ZOD_PLUGIN_INDEX_GENERATOR_HEADER_COMMENT = defaultHeaderComment + `* Generated Zod Schemas exports
+* Do not edit this file manually
+*/
+`;
+
+// src/lib/cli.ts
+var import_commander = require("commander");
+var fs4 = __toESM(require("fs"));
+var path13 = __toESM(require("path"));
+
+// package.json
+var version = "0.3.0";
+
+// src/lib/core/generator.ts
+var import_ts_morph10 = require("ts-morph");
+
+// src/lib/generators/type/enum-builder.ts
 var import_ts_morph = require("ts-morph");
-var TypeGenerator = class {
+
+// src/lib/generators/type/type-resolver.ts
+function escapeString2(str) {
+  return str.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+}
+__name(escapeString2, "escapeString");
+function sanitizePropertyName(name) {
+  if (!/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name)) {
+    return `"${name}"`;
+  }
+  return name;
+}
+__name(sanitizePropertyName, "sanitizePropertyName");
+var TypeResolver = class {
   static {
-    __name(this, "TypeGenerator");
+    __name(this, "TypeResolver");
   }
-  project;
-  parser;
-  sourceFile;
-  generatedTypes = /* @__PURE__ */ new Set();
   config;
-  // Performance caches
+  onWarning;
+  resolutionCache = /* @__PURE__ */ new WeakMap();
   pascalCaseCache = /* @__PURE__ */ new Map();
   sanitizedNameCache = /* @__PURE__ */ new Map();
-  typeResolutionCache = /* @__PURE__ */ new Map();
-  // Batch collection for AST operations
-  statements = [];
-  deferredTypes = /* @__PURE__ */ new Map();
-  constructor(parser, project, config, outputRoot) {
+  constructor(config, onWarning) {
     this.config = config;
-    this.project = project;
-    this.parser = parser;
-    const outputPath = outputRoot + "/models/index.ts";
-    this.sourceFile = this.project.createSourceFile(outputPath, "", {
-      overwrite: true
-    });
+    this.onWarning = onWarning;
   }
-  async generate() {
-    try {
-      const definitions = this.parser.getDefinitions();
-      if (!definitions || Object.keys(definitions).length === 0) {
-        console.warn("No definitions found in swagger file");
-      }
-      this.collectAllTypeStructures(definitions);
-      this.collectSdkTypes();
-      this.applyBatchUpdates();
-      await this.finalize();
-    } catch (error) {
-      console.error("Error in generate():", error);
-      throw new Error(`Failed to generate types: ${error instanceof Error ? error.message : "Unknown error"}`);
+  resolve(schema) {
+    const cached = this.resolutionCache.get(schema);
+    if (cached !== void 0) {
+      return cached;
     }
+    const result = this.resolveUncached(schema);
+    this.resolutionCache.set(schema, result);
+    return result;
   }
-  collectAllTypeStructures(definitions) {
-    Object.keys(definitions).forEach((name) => {
-      const interfaceName = this.getCachedPascalCase(name);
-      this.generatedTypes.add(interfaceName);
-    });
-    Object.entries(definitions).forEach(([name, definition]) => {
-      this.collectTypeStructure(name, definition);
-    });
-    this.deferredTypes.forEach((definition, name) => {
-      this.collectTypeStructure(name, definition);
-    });
+  pascalName(str) {
+    if (!this.pascalCaseCache.has(str)) {
+      this.pascalCaseCache.set(str, pascalCaseForEnums(str));
+    }
+    return this.pascalCaseCache.get(str);
   }
-  collectTypeStructure(name, definition) {
-    const interfaceName = this.getCachedPascalCase(name) ?? "";
-    if (definition.enum) {
-      this.collectEnumStructure(interfaceName, definition);
-    } else if (definition.allOf) {
-      this.collectCompositeTypeStructure(interfaceName, definition);
-    } else if (definition.items) {
-      this.collectArrayTypeStructure(interfaceName, definition);
-    } else if (definition.properties) {
-      this.collectInterfaceStructure(interfaceName, definition);
+  sanitizeName(name) {
+    if (!this.sanitizedNameCache.has(name)) {
+      this.sanitizedNameCache.set(name, sanitizePropertyName(name));
+    }
+    return this.sanitizedNameCache.get(name);
+  }
+  getArrayItemType(items) {
+    if (Array.isArray(items)) {
+      const types = items.map((item) => this.resolve(item));
+      return `[${types.join(", ")}]`;
     } else {
-      const propertyType = this.resolveSwaggerTypeCached(definition);
-      this.statements.push({
-        kind: import_ts_morph.StructureKind.TypeAlias,
-        name: interfaceName,
-        isExported: true,
-        docs: definition.description ? [
-          definition.description
-        ] : void 0,
-        type: propertyType
-      });
+      return this.resolve(items);
+    }
+  }
+  resolveUncached(schema) {
+    if (schema.$ref) {
+      return this.resolveReference(schema.$ref);
+    }
+    if (schema.enum) {
+      return schema.enum.map((value) => typeof value === "string" ? `'${escapeString2(value)}'` : String(value)).join(" | ");
+    }
+    if (schema.allOf) {
+      return schema.allOf.map((def) => this.resolve(def)).filter((type) => type !== "any" && type !== "unknown").join(" & ") || "Record<string, unknown>";
+    }
+    if (schema.oneOf) {
+      return schema.oneOf.map((def) => this.resolve(def)).filter((type, index, array) => type !== "any" && type !== "unknown" && array.indexOf(type) === index).join(" | ") || "unknown";
+    }
+    if (schema.anyOf) {
+      return schema.anyOf.map((def) => this.resolve(def)).filter((type) => type !== "any" && type !== "unknown").join(" | ") || "unknown";
+    }
+    if (schema.type === "array") {
+      const itemType = schema.items ? this.getArrayItemType(schema.items) : "unknown";
+      return `Array<${itemType}>`;
+    }
+    if (schema.type === "object") {
+      if (schema.properties) {
+        return this.generateInlineObjectType(schema);
+      }
+      if (schema.additionalProperties) {
+        const valueType = typeof schema.additionalProperties === "object" ? this.resolve(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.resolve(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.sanitizeName(key);
+      return `${sanitizedKey}${questionMark}: ${this.resolve(prop)}`;
+    }).join("; ");
+    return `{ ${properties} }`;
+  }
+  resolveReference(ref) {
+    const refName = ref.split("/").pop();
+    if (!refName) {
+      this.onWarning?.(`Invalid reference format: ${ref}`);
+      return "unknown";
+    }
+    return this.pascalName(refName);
+  }
+  mapSwaggerTypeToTypeScript(type, format, isNullable) {
+    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("any[]", isNullable);
+      case "object":
+        return this.nullableType("Record<string, unknown>", isNullable);
+      case "null":
+        return this.nullableType("null", isNullable);
+      default:
+        if (Array.isArray(type)) {
+          const types = type.map((t) => this.mapSwaggerTypeToTypeScript(t, void 0, isNullable));
+          return this.nullableType(types.join(" | "), isNullable);
+        }
+        return this.nullableType("any", isNullable);
     }
   }
-  collectEnumStructure(name, definition) {
-    if (!definition.enum?.length) return;
+  nullableType(type, isNullable) {
+    return type + (isNullable ? " | null" : "");
+  }
+};
+
+// src/lib/generators/type/enum-builder.ts
+function toEnumKey(value) {
+  const str = value.toString();
+  const hasLeadingMinus = str.startsWith("-");
+  const pascalCased = pascalCase(str);
+  return hasLeadingMinus ? pascalCased.replace(/^([0-9])/, "_n$1") : pascalCased.replace(/^([0-9])/, "_$1");
+}
+__name(toEnumKey, "toEnumKey");
+var EnumBuilder = class {
+  static {
+    __name(this, "EnumBuilder");
+  }
+  config;
+  onWarning;
+  constructor(config, onWarning) {
+    this.config = config;
+    this.onWarning = onWarning;
+  }
+  build(name, definition) {
+    if (!definition.enum?.length) return [];
     const docs = !this.config.options.generateEnumBasedOnDescription && definition.description ? [
       definition.description
     ] : void 0;
     if (this.config.options.enumStyle === "enum") {
-      const statement = this.buildEnumAsEnum(name, definition, docs);
-      this.statements.push(...statement);
+      return this.buildEnumAsEnum(name, definition, docs);
     } else {
-      const statement = this.buildEnumAsUnion(name, definition, docs);
-      this.statements.push(...statement);
+      return this.buildEnumAsUnion(name, definition, docs);
     }
   }
   buildEnumAsEnum(name, definition, docs) {
@@ -661,7 +1061,7 @@ var TypeGenerator = class {
     const isStringEnum = definition.enum.some((value) => typeof value === "string");
     if (isStringEnum) {
       const members = definition.enum.map((value) => ({
-        name: this.toEnumKey(value),
+        name: toEnumKey(value),
         value: `${String(value)}`
       }));
       statements.push({
@@ -672,7 +1072,7 @@ var TypeGenerator = class {
         members
       });
     } else {
-      const members = this.buildEnumMembers(definition);
+      const members = this.buildEnumMembers(name, definition);
       statements.push({
         kind: import_ts_morph.StructureKind.Enum,
         name,
@@ -688,8 +1088,8 @@ var TypeGenerator = class {
     const statements = [];
     const objectProperties = [];
     const unionType = definition.enum.map((value) => {
-      const key = this.toEnumKey(value);
-      const val = typeof value === "string" ? `'${this.escapeString(value)}'` : isNaN(value) ? `'${value}'` : `${value}`;
+      const key = toEnumKey(value);
+      const val = typeof value === "string" ? `'${escapeString2(value)}'` : isNaN(value) ? `'${value}'` : `${value}`;
       objectProperties.push(`${key}: ${val} as ${name}`);
       return val;
     }).join(" | ");
@@ -713,7 +1113,7 @@ var TypeGenerator = class {
     });
     return statements;
   }
-  buildEnumMembers(definition) {
+  buildEnumMembers(name, definition) {
     if (definition.description && this.config.options.generateEnumBasedOnDescription) {
       try {
         const enumValueObjects = JSON.parse(definition.description);
@@ -722,63 +1122,49 @@ var TypeGenerator = class {
           value: obj.Value
         }));
       } catch {
+        if (/^\s*[[{]/.test(definition.description)) {
+          this.onWarning?.(`Enum "${name}": description looks like JSON (generateEnumBasedOnDescription) but could not be used \u2014 falling back to raw enum values`);
+        }
       }
     }
     return definition.enum?.map((value) => ({
-      name: this.toEnumKey(value),
+      name: toEnumKey(value),
       value
     }));
   }
-  collectCompositeTypeStructure(name, definition) {
-    let typeExpression = "";
-    if (definition.allOf) {
-      const types = definition.allOf.map((def) => this.resolveSwaggerTypeCached(def)).filter((type) => type !== "any" && type !== "unknown");
-      typeExpression = types.length > 0 ? types.join(" & ") : "Record<string, unknown>";
-    }
-    this.statements.push({
-      kind: import_ts_morph.StructureKind.TypeAlias,
-      name,
-      type: typeExpression,
-      isExported: true,
-      docs: definition.description ? [
-        definition.description
-      ] : void 0
-    });
+};
+
+// src/lib/generators/type/interface-builder.ts
+var import_ts_morph2 = require("ts-morph");
+var InterfaceBuilder = class {
+  static {
+    __name(this, "InterfaceBuilder");
   }
-  collectArrayTypeStructure(name, definition) {
-    const itemType = definition.items ? this.getArrayItemType(definition.items) : "unknown";
-    this.statements.push({
-      kind: import_ts_morph.StructureKind.TypeAlias,
-      name,
-      isExported: true,
-      docs: definition.description ? [
-        definition.description
-      ] : void 0,
-      type: `Array<${itemType}>`
-    });
+  resolver;
+  constructor(resolver) {
+    this.resolver = resolver;
   }
-  collectInterfaceStructure(name, definition) {
-    const properties = this.buildInterfaceProperties(definition);
-    this.statements.push({
-      kind: import_ts_morph.StructureKind.Interface,
+  build(name, definition) {
+    return {
+      kind: import_ts_morph2.StructureKind.Interface,
       name,
       isExported: true,
       docs: definition.description ? [
         definition.description
       ] : void 0,
-      properties,
+      properties: this.buildProperties(definition),
       indexSignatures: this.buildIndexSignatures(definition)
-    });
+    };
   }
-  buildInterfaceProperties(definition) {
+  buildProperties(definition) {
     if (!definition.properties) {
       return [];
     }
     return Object.entries(definition.properties).map(([propertyName, property]) => {
       const isRequired = definition.required?.includes(propertyName) ?? false;
       const isReadOnly = property.readOnly;
-      const propertyType = this.resolveSwaggerTypeCached(property);
-      const sanitizedName = this.getCachedSanitizedName(propertyName);
+      const propertyType = this.resolver.resolve(property);
+      const sanitizedName = this.resolver.sanitizeName(propertyName);
       return {
         name: sanitizedName,
         type: propertyType,
@@ -820,121 +1206,156 @@ var TypeGenerator = class {
     }
     return [];
   }
-  resolveSwaggerTypeCached(schema) {
-    const cacheKey = JSON.stringify(schema);
-    if (this.typeResolutionCache.has(cacheKey)) {
-      return this.typeResolutionCache.get(cacheKey);
+};
+
+// src/lib/generators/type/sdk-types.ts
+var import_ts_morph3 = require("ts-morph");
+function buildSdkTypes(config) {
+  const { response } = config.options.validation ?? {};
+  const typeParameters = [
+    "TResponseType extends 'arraybuffer' | 'blob' | 'json' | 'text'"
+  ];
+  const properties = [
+    {
+      name: "headers",
+      type: "HttpHeaders",
+      hasQuestionToken: true
+    },
+    {
+      name: "reportProgress",
+      type: "boolean",
+      hasQuestionToken: true
+    },
+    {
+      name: "responseType",
+      type: "TResponseType",
+      hasQuestionToken: true
+    },
+    {
+      name: "withCredentials",
+      type: "boolean",
+      hasQuestionToken: true
+    },
+    {
+      name: "context",
+      type: "HttpContext",
+      hasQuestionToken: true
     }
-    const result = this.resolveSwaggerType(schema);
-    this.typeResolutionCache.set(cacheKey, result);
-    return result;
+  ];
+  if (response) {
+    properties.push({
+      name: "parse",
+      type: "(response: unknown) => TReturnType",
+      hasQuestionToken: true
+    });
+    typeParameters.push("TReturnType");
   }
-  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.resolveSwaggerTypeCached(def)).filter((type) => type !== "any" && type !== "unknown").join(" & ") || "Record<string, unknown>";
-    }
-    if (schema.oneOf) {
-      return schema.oneOf.map((def) => this.resolveSwaggerTypeCached(def)).filter((type, index, array) => type !== "any" && type !== "unknown" && array.indexOf(type) === index).join(" | ") || "unknown";
-    }
-    if (schema.anyOf) {
-      return schema.anyOf.map((def) => this.resolveSwaggerTypeCached(def)).filter((type) => type !== "any" && type !== "unknown").join(" | ") || "unknown";
-    }
-    if (schema.type === "array") {
-      const itemType = schema.items ? this.getArrayItemType(schema.items) : "unknown";
-      return `Array<${itemType}>`;
-    }
-    if (schema.type === "object") {
-      if (schema.properties) {
-        return this.generateInlineObjectType(schema);
-      }
-      if (schema.additionalProperties) {
-        const valueType = typeof schema.additionalProperties === "object" ? this.resolveSwaggerTypeCached(schema.additionalProperties) : "unknown";
-        return `Record<string, ${valueType}>`;
-      }
-      return "Record<string, unknown>";
+  return [
+    {
+      kind: import_ts_morph3.StructureKind.Interface,
+      name: "RequestOptions",
+      isExported: true,
+      typeParameters,
+      properties,
+      docs: [
+        "Request Options for Angular HttpClient requests"
+      ]
     }
-    return this.mapSwaggerTypeToTypeScript(schema.type, schema.format, schema.nullable);
+  ];
+}
+__name(buildSdkTypes, "buildSdkTypes");
+
+// src/lib/generators/type/type.generator.ts
+var import_ts_morph4 = require("ts-morph");
+var TypeGenerator = class {
+  static {
+    __name(this, "TypeGenerator");
   }
-  generateInlineObjectType(definition) {
-    if (!definition.properties) {
-      if (definition.additionalProperties) {
-        const additionalType = typeof definition.additionalProperties === "object" ? this.resolveSwaggerTypeCached(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.getCachedSanitizedName(key);
-      return `${sanitizedKey}${questionMark}: ${this.resolveSwaggerTypeCached(prop)}`;
-    }).join("; ");
-    return `{ ${properties} }`;
+  parser;
+  config;
+  sourceFile;
+  resolver;
+  enumBuilder;
+  interfaceBuilder;
+  statements = [];
+  onWarning;
+  constructor(parser, project, config, outputRoot, onWarning) {
+    this.config = config;
+    this.parser = parser;
+    this.onWarning = onWarning;
+    const outputPath = outputRoot + "/models/index.ts";
+    this.sourceFile = project.createSourceFile(outputPath, "", {
+      overwrite: true
+    });
+    this.resolver = new TypeResolver(config, onWarning);
+    this.enumBuilder = new EnumBuilder(config, onWarning);
+    this.interfaceBuilder = new InterfaceBuilder(this.resolver);
   }
-  resolveReference(ref) {
-    const refName = ref.split("/").pop();
-    if (!refName) {
-      console.warn(`Invalid reference format: ${ref}`);
-      return "unknown";
+  async generate() {
+    try {
+      const definitions = this.parser.getNormalizedSpec().definitions;
+      if (!definitions || Object.keys(definitions).length === 0) {
+        this.onWarning?.("No definitions found in swagger file");
+      }
+      Object.entries(definitions).forEach(([name, definition]) => {
+        this.collectTypeStructure(name, definition);
+      });
+      this.statements.push(...buildSdkTypes(this.config));
+      this.applyBatchUpdates();
+      await this.finalize();
+    } catch (error) {
+      throw new Error(`Failed to generate types: ${error instanceof Error ? error.message : "Unknown error"}`);
     }
-    return this.getCachedPascalCase(refName);
   }
-  collectSdkTypes() {
-    const { response } = this.config.options.validation ?? {};
-    const typeParameters = [
-      "TResponseType extends 'arraybuffer' | 'blob' | 'json' | 'text'"
-    ];
-    const properties = [
-      {
-        name: "headers",
-        type: "HttpHeaders",
-        hasQuestionToken: true
-      },
-      {
-        name: "reportProgress",
-        type: "boolean",
-        hasQuestionToken: true
-      },
-      {
-        name: "responseType",
-        type: "TResponseType",
-        hasQuestionToken: true
-      },
-      {
-        name: "withCredentials",
-        type: "boolean",
-        hasQuestionToken: true
-      },
-      {
-        name: "context",
-        type: "HttpContext",
-        hasQuestionToken: true
-      }
-    ];
-    if (response) {
-      properties.push({
-        name: "parse",
-        type: "(response: unknown) => TReturnType",
-        hasQuestionToken: true
+  collectTypeStructure(name, definition) {
+    const typeName = this.resolver.pascalName(name);
+    if (definition.enum) {
+      this.statements.push(...this.enumBuilder.build(typeName, definition));
+    } else if (definition.allOf) {
+      this.statements.push(this.buildCompositeTypeAlias(typeName, definition));
+    } else if (definition.items) {
+      this.statements.push(this.buildArrayTypeAlias(typeName, definition));
+    } else if (definition.properties) {
+      this.statements.push(this.interfaceBuilder.build(typeName, definition));
+    } else {
+      this.statements.push({
+        kind: import_ts_morph4.StructureKind.TypeAlias,
+        name: typeName,
+        isExported: true,
+        docs: definition.description ? [
+          definition.description
+        ] : void 0,
+        type: this.resolver.resolve(definition)
       });
-      typeParameters.push("TReturnType");
     }
-    this.statements.push({
-      kind: import_ts_morph.StructureKind.Interface,
-      name: "RequestOptions",
+  }
+  buildCompositeTypeAlias(name, definition) {
+    let typeExpression = "";
+    if (definition.allOf) {
+      const types = definition.allOf.map((def) => this.resolver.resolve(def)).filter((type) => type !== "any" && type !== "unknown");
+      typeExpression = types.length > 0 ? types.join(" & ") : "Record<string, unknown>";
+    }
+    return {
+      kind: import_ts_morph4.StructureKind.TypeAlias,
+      name,
+      type: typeExpression,
       isExported: true,
-      typeParameters,
-      properties,
-      docs: [
-        "Request Options for Angular HttpClient requests"
-      ]
-    });
+      docs: definition.description ? [
+        definition.description
+      ] : void 0
+    };
+  }
+  buildArrayTypeAlias(name, definition) {
+    const itemType = definition.items ? this.resolver.getArrayItemType(definition.items) : "unknown";
+    return {
+      kind: import_ts_morph4.StructureKind.TypeAlias,
+      name,
+      isExported: true,
+      docs: definition.description ? [
+        definition.description
+      ] : void 0,
+      type: `Array<${itemType}>`
+    };
   }
   applyBatchUpdates() {
     this.sourceFile.insertText(0, TYPE_GENERATOR_HEADER_COMMENT);
@@ -953,81 +1374,10 @@ var TypeGenerator = class {
     this.sourceFile.formatText();
     await this.sourceFile.save();
   }
-  // Cached helper methods
-  getCachedPascalCase(str) {
-    if (!this.pascalCaseCache.has(str)) {
-      this.pascalCaseCache.set(str, pascalCaseForEnums(str));
-    }
-    return this.pascalCaseCache.get(str);
-  }
-  getCachedSanitizedName(name) {
-    if (!this.sanitizedNameCache.has(name)) {
-      this.sanitizedNameCache.set(name, this.sanitizePropertyName(name));
-    }
-    return this.sanitizedNameCache.get(name);
-  }
-  // Original helper methods
-  mapSwaggerTypeToTypeScript(type, format, isNullable) {
-    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("any[]", isNullable);
-      case "object":
-        return this.nullableType("Record<string, unknown>", isNullable);
-      case "null":
-        return this.nullableType("null", isNullable);
-      default:
-        if (Array.isArray(type)) {
-          const types = type.map((t) => this.mapSwaggerTypeToTypeScript(t, void 0, isNullable));
-          return this.nullableType(types.join(" | "), isNullable);
-        }
-        return this.nullableType("any", isNullable);
-    }
-  }
-  nullableType(type, isNullable) {
-    return type + (isNullable ? " | null" : "");
-  }
-  sanitizePropertyName(name) {
-    if (!/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name)) {
-      return `"${name}"`;
-    }
-    return name;
-  }
-  toEnumKey(value) {
-    const str = value.toString();
-    const hasLeadingMinus = str.startsWith("-");
-    const pascalCased = pascalCase(str);
-    return hasLeadingMinus ? pascalCased.replace(/^([0-9])/, "_n$1") : pascalCased.replace(/^([0-9])/, "_$1");
-  }
-  getArrayItemType(items) {
-    if (Array.isArray(items)) {
-      const types = items.map((item) => this.resolveSwaggerTypeCached(item));
-      return `[${types.join(", ")}]`;
-    } else {
-      return this.resolveSwaggerTypeCached(items);
-    }
-  }
-  escapeString(str) {
-    return str.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
-  }
 };
 
 // src/lib/generators/utility/token.generator.ts
-var import_ts_morph2 = require("ts-morph");
+var import_ts_morph5 = require("ts-morph");
 var path2 = __toESM(require("path"));
 var TokenGenerator = class {
   static {
@@ -1065,7 +1415,7 @@ var TokenGenerator = class {
     const clientContextTokenName = this.getClientContextTokenName();
     sourceFile.addVariableStatement({
       isExported: true,
-      declarationKind: import_ts_morph2.VariableDeclarationKind.Const,
+      declarationKind: import_ts_morph5.VariableDeclarationKind.Const,
       declarations: [
         {
           name: basePathTokenName,
@@ -1082,7 +1432,7 @@ var TokenGenerator = class {
     });
     sourceFile.addVariableStatement({
       isExported: true,
-      declarationKind: import_ts_morph2.VariableDeclarationKind.Const,
+      declarationKind: import_ts_morph5.VariableDeclarationKind.Const,
       declarations: [
         {
           name: interceptorsTokenName,
@@ -1099,7 +1449,7 @@ var TokenGenerator = class {
     });
     sourceFile.addVariableStatement({
       isExported: true,
-      declarationKind: import_ts_morph2.VariableDeclarationKind.Const,
+      declarationKind: import_ts_morph5.VariableDeclarationKind.Const,
       declarations: [
         {
           name: clientContextTokenName,
@@ -1114,7 +1464,7 @@ var TokenGenerator = class {
     if (this.clientName === "default") {
       sourceFile.addVariableStatement({
         isExported: true,
-        declarationKind: import_ts_morph2.VariableDeclarationKind.Const,
+        declarationKind: import_ts_morph5.VariableDeclarationKind.Const,
         declarations: [
           {
             name: "BASE_PATH",
@@ -1128,7 +1478,7 @@ var TokenGenerator = class {
       });
       sourceFile.addVariableStatement({
         isExported: true,
-        declarationKind: import_ts_morph2.VariableDeclarationKind.Const,
+        declarationKind: import_ts_morph5.VariableDeclarationKind.Const,
         declarations: [
           {
             name: "CLIENT_CONTEXT_TOKEN",
@@ -1299,7 +1649,7 @@ var FileDownloadGenerator = class {
 };
 
 // src/lib/generators/utility/date-transformer.generator.ts
-var import_ts_morph3 = require("ts-morph");
+var import_ts_morph6 = require("ts-morph");
 var path4 = __toESM(require("path"));
 var DateTransformerGenerator = class {
   static {
@@ -1342,7 +1692,7 @@ var DateTransformerGenerator = class {
     ]);
     sourceFile.addVariableStatement({
       isExported: true,
-      declarationKind: import_ts_morph3.VariableDeclarationKind.Const,
+      declarationKind: import_ts_morph6.VariableDeclarationKind.Const,
       declarations: [
         {
           name: "ISO_DATE_REGEX",
@@ -1414,7 +1764,7 @@ var DateTransformerGenerator = class {
             {
               name: "dateRegex",
               type: "RegExp",
-              scope: import_ts_morph3.Scope.Private,
+              scope: import_ts_morph6.Scope.Private,
               isReadonly: true,
               initializer: "ISO_DATE_REGEX"
             }
@@ -1712,7 +2062,7 @@ return makeEnvironmentProviders(providers);`;
 };
 
 // src/lib/generators/utility/base-interceptor.generator.ts
-var import_ts_morph4 = require("ts-morph");
+var import_ts_morph7 = require("ts-morph");
 var path7 = __toESM(require("path"));
 var BaseInterceptorGenerator = class {
   static {
@@ -1781,14 +2131,14 @@ var BaseInterceptorGenerator = class {
         {
           name: "httpInterceptors",
           type: "HttpInterceptor[]",
-          scope: import_ts_morph4.Scope.Private,
+          scope: import_ts_morph7.Scope.Private,
           isReadonly: true,
           initializer: `inject(${interceptorsTokenName})`
         },
         {
           name: "clientContextToken",
           type: "HttpContextToken<string>",
-          scope: import_ts_morph4.Scope.Private,
+          scope: import_ts_morph7.Scope.Private,
           isReadonly: true,
           initializer: clientContextTokenName
         }
@@ -1838,7 +2188,7 @@ var BaseInterceptorGenerator = class {
 
 // src/lib/generators/utility/http-params-builder.generator.ts
 var path8 = __toESM(require("path"));
-var import_ts_morph5 = require("ts-morph");
+var import_ts_morph8 = require("ts-morph");
 var HttpParamsBuilderGenerator = class {
   static {
     __name(this, "HttpParamsBuilderGenerator");
@@ -1872,7 +2222,7 @@ var HttpParamsBuilderGenerator = class {
       {
         name: "addToHttpParams",
         isStatic: true,
-        scope: import_ts_morph5.Scope.Public,
+        scope: import_ts_morph8.Scope.Public,
         parameters: [
           {
             name: "httpParams",
@@ -1905,7 +2255,7 @@ return this.addToHttpParamsRecursive(httpParams, value, key);`
       {
         name: "addToHttpParamsRecursive",
         isStatic: true,
-        scope: import_ts_morph5.Scope.Private,
+        scope: import_ts_morph8.Scope.Private,
         parameters: [
           {
             name: "httpParams",
@@ -1944,7 +2294,7 @@ return this.handlePrimitive(httpParams, value, key);`
       {
         name: "handleArray",
         isStatic: true,
-        scope: import_ts_morph5.Scope.Private,
+        scope: import_ts_morph8.Scope.Private,
         parameters: [
           {
             name: "httpParams",
@@ -1969,7 +2319,7 @@ return httpParams;`
       {
         name: "handleDate",
         isStatic: true,
-        scope: import_ts_morph5.Scope.Private,
+        scope: import_ts_morph8.Scope.Private,
         parameters: [
           {
             name: "httpParams",
@@ -1994,7 +2344,7 @@ return httpParams.append(key, date.toISOString());`
       {
         name: "handleObject",
         isStatic: true,
-        scope: import_ts_morph5.Scope.Private,
+        scope: import_ts_morph8.Scope.Private,
         parameters: [
           {
             name: "httpParams",
@@ -2020,7 +2370,7 @@ return httpParams;`
       {
         name: "handlePrimitive",
         isStatic: true,
-        scope: import_ts_morph5.Scope.Private,
+        scope: import_ts_morph8.Scope.Private,
         parameters: [
           {
             name: "httpParams",
@@ -2048,7 +2398,7 @@ return httpParams.append(key, value);`
 };
 
 // src/lib/generators/service/service.generator.ts
-var import_ts_morph6 = require("ts-morph");
+var import_ts_morph9 = require("ts-morph");
 var path10 = __toESM(require("path"));
 
 // src/lib/generators/service/service-method/service-method-body.generator.ts
@@ -2057,132 +2407,30 @@ var ServiceMethodBodyGenerator = class {
     __name(this, "ServiceMethodBodyGenerator");
   }
   config;
-  parser;
-  constructor(config, parser) {
+  constructor(config) {
     this.config = config;
-    this.parser = parser;
   }
   generateMethodBody(operation) {
-    const context = this.createGenerationContext(operation);
     const bodyParts = [
-      this.generateUrlConstruction(operation, context),
-      this.generateQueryParams(context),
-      this.generateHeaders(context),
-      this.generateMultipartFormData(operation, context),
-      this.generateUrlEncodedFormData(operation, context),
-      this.generateRequestOptions(context),
-      this.generateHttpRequest(operation, context)
+      emitUrlConstruction(operation.path, operation.pathParams),
+      emitQueryParams(operation.queryParams),
+      emitHeaders({
+        optionsExpression: "options",
+        customHeaders: this.config.options.customHeaders,
+        contentType: operation
+      }),
+      this.generateMultipartFormData(operation),
+      this.generateUrlEncodedFormData(operation),
+      this.generateHttpRequest(operation)
     ];
     return bodyParts.filter(Boolean).join("\n");
   }
-  isMultipartFormData(operation) {
-    return !!operation.requestBody?.content?.[CONTENT_TYPES.MULTIPART];
-  }
-  isUrlEncodedFormData(operation) {
-    return !!operation.requestBody?.content?.[CONTENT_TYPES.FORM_URLENCODED] && !operation.requestBody?.content?.[CONTENT_TYPES.JSON];
-  }
-  getFormDataFields(operation) {
-    if (!this.isMultipartFormData(operation)) {
-      return [];
-    }
-    const schema = operation.requestBody?.content?.[CONTENT_TYPES.MULTIPART].schema;
-    let resolvedSchema = schema;
-    if (schema?.$ref) {
-      resolvedSchema = this.parser.resolveReference(schema.$ref);
-    }
-    const properties = resolvedSchema?.properties || {};
-    return Object.keys(properties);
-  }
-  getUrlEncodedFields(operation) {
-    if (!this.isUrlEncodedFormData(operation)) {
-      return [];
-    }
-    const schema = operation.requestBody?.content?.[CONTENT_TYPES.FORM_URLENCODED].schema;
-    let resolvedSchema = schema;
-    if (schema?.$ref) {
-      resolvedSchema = this.parser.resolveReference(schema.$ref);
-    }
-    const properties = resolvedSchema?.properties || {};
-    return Object.keys(properties);
-  }
-  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),
-      isUrlEncoded: this.isUrlEncodedFormData(operation),
-      formDataFields: this.getFormDataFields(operation),
-      urlEncodedFields: this.getUrlEncodedFields(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}}`, `\${${camelCase(param.name)}}`);
-      });
-    }
-    return `const url = ${urlExpression};`;
-  }
-  generateQueryParams(context) {
-    if (context.queryParams.length === 0) {
-      return "";
-    }
-    const paramMappings = context.queryParams.map((param) => `if (${camelCase(param.name)} != null) {
-  params = HttpParamsBuilder.addToHttpParams(params, ${camelCase(param.name)}, '${param.name}');
-}`).join("\n");
-    return `
-let params = new HttpParams();
-${paramMappings}`;
-  }
-  generateHeaders(context) {
-    const hasCustomHeaders = this.config.options.customHeaders;
-    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.isUrlEncoded) {
-      headerCode += `
-// Set Content-Type for URL-encoded form data
-if (!headers.has('Content-Type')) {
-  headers = headers.set('Content-Type', 'application/x-www-form-urlencoded');
-}`;
-    } else if (context.hasBody) {
-      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) {
+  generateMultipartFormData(operation) {
+    if (!operation.isMultipart || operation.formDataFields.length === 0) {
       return "";
     }
-    const schema = operation.requestBody?.content?.[CONTENT_TYPES.MULTIPART].schema;
-    let resolvedSchema = schema;
-    if (schema?.$ref) {
-      resolvedSchema = this.parser.resolveReference(schema.$ref);
-    }
-    const properties = resolvedSchema?.properties || {};
-    const formDataAppends = context.formDataFields.map((field) => {
+    const properties = operation.formDataSchema?.properties || {};
+    const formDataAppends = operation.formDataFields.map((field) => {
       const fieldSchema = properties[field];
       const isFile = fieldSchema?.type === "string" && fieldSchema?.format === "binary";
       const isArray = fieldSchema?.type === "array";
@@ -2208,17 +2456,12 @@ if (!headers.has('Content-Type')) {
 const formData = new FormData();
 ${formDataAppends}`;
   }
-  generateUrlEncodedFormData(operation, context) {
-    if (!context.isUrlEncoded || context.urlEncodedFields.length === 0) {
+  generateUrlEncodedFormData(operation) {
+    if (!operation.isUrlEncoded || operation.urlEncodedFields.length === 0) {
       return "";
     }
-    const schema = operation.requestBody?.content?.[CONTENT_TYPES.FORM_URLENCODED].schema;
-    let resolvedSchema = schema;
-    if (schema?.$ref) {
-      resolvedSchema = this.parser.resolveReference(schema.$ref);
-    }
-    const properties = resolvedSchema?.properties || {};
-    const formBodyAppends = context.urlEncodedFields.map((field) => {
+    const properties = operation.urlEncodedSchema?.properties || {};
+    const formBodyAppends = operation.urlEncodedFields.map((field) => {
       const fieldSchema = properties[field];
       const isArray = fieldSchema?.type === "array";
       if (isArray) {
@@ -2239,32 +2482,13 @@ ${formDataAppends}`;
 const formBody = new URLSearchParams();
 ${formBodyAppends}`;
   }
-  generateRequestOptions(context) {
-    const options = [];
-    options.push("observe: observe as any");
-    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");
-    options.push("context: this.createContextWithClientId(options?.context)");
-    const formattedOptions = options.filter((opt) => opt && !opt.includes("undefined")).join(",\n  ");
-    return `
-const requestOptions: any = {
-  ${formattedOptions}
-};`;
-  }
-  generateHttpRequest(operation, context) {
+  generateHttpRequest(operation) {
     const httpMethod = operation.method.toLowerCase();
     let bodyParam = "";
-    if (context.hasBody) {
-      if (context.isMultipart) {
+    if (operation.hasBody) {
+      if (operation.isMultipart) {
         bodyParam = "formData";
-      } else if (context.isUrlEncoded) {
+      } else if (operation.isUrlEncoded) {
         bodyParam = "formBody.toString()";
       } else if (operation.requestBody?.content?.[CONTENT_TYPES.JSON]) {
         const bodyType = getRequestBodyType(operation.requestBody, this.config);
@@ -2278,28 +2502,23 @@ const requestOptions: any = {
       "patch"
     ];
     const parseResponse = this.config.options.validation?.response ? `.pipe(map(response => options?.parse?.(response) ?? response))` : "";
+    const entries = [];
     if (methodsWithBody.includes(httpMethod)) {
-      return `
-return this.httpClient.${httpMethod}(url, ${bodyParam || "null"}, requestOptions)${parseResponse};`;
-    } else {
-      return `
-return this.httpClient.${httpMethod}(url, requestOptions)${parseResponse};`;
+      entries.push(`body: ${bodyParam || "null"}`);
     }
-  }
-  determineResponseType(operation) {
-    const successResponses = [
-      "200",
-      "201",
-      "202",
-      "204",
-      "206"
-    ];
-    for (const statusCode of successResponses) {
-      const response = operation.responses?.[statusCode];
-      if (!response) continue;
-      return getResponseTypeFromResponse(response);
+    entries.push("observe");
+    entries.push("headers");
+    if (operation.queryParams.length > 0) {
+      entries.push("params");
     }
-    return "json";
+    entries.push(emitResponseTypeOption(operation.responseType));
+    entries.push("reportProgress: options?.reportProgress");
+    entries.push("withCredentials: options?.withCredentials");
+    entries.push("context: this.createContextWithClientId(options?.context)");
+    return `
+return this.httpClient.request('${httpMethod}', url, {
+  ${joinRequestOptionEntries(entries)}
+})${parseResponse};`;
   }
 };
 
@@ -2376,10 +2595,8 @@ var ServiceMethodParamsGenerator = class {
     __name(this, "ServiceMethodParamsGenerator");
   }
   config;
-  parser;
-  constructor(config, parser) {
+  constructor(config) {
     this.config = config;
-    this.parser = parser;
   }
   generateMethodParameters(operation) {
     const params = this.generateApiParameters(operation);
@@ -2391,28 +2608,28 @@ var ServiceMethodParamsGenerator = class {
   }
   generateApiParameters(operation) {
     const params = [];
-    const pathParams = operation.parameters?.filter((p) => p.in === "path") || [];
-    pathParams.forEach((param) => {
+    operation.pathParams.forEach((param) => {
       params.push({
         name: camelCase(param.name),
-        type: getTypeScriptType(param.schema || param, this.config),
+        // Swagger 2.0 puts type/format/enum on the parameter itself; the
+        // spread (vs passing param directly) is needed because Parameter
+        // lacks TypeSchema's index signature — a fresh literal satisfies it.
+        type: getTypeScriptType(param.schema || {
+          ...param
+        }, this.config),
         hasQuestionToken: !param.required
       });
     });
     const requestBody = operation.requestBody;
     if (requestBody) {
-      const formDataContent = requestBody.content?.[CONTENT_TYPES.MULTIPART];
-      const urlEncodedContent = requestBody.content?.[CONTENT_TYPES.FORM_URLENCODED];
       const jsonContent = requestBody.content?.[CONTENT_TYPES.JSON];
-      if (formDataContent) {
-        const formParams = this.convertObjectToSingleParams(formDataContent.schema);
-        params.push(...formParams);
+      if (operation.isMultipart) {
+        params.push(...this.convertObjectToSingleParams(operation.formDataSchema));
       }
-      if (!jsonContent && urlEncodedContent) {
-        const formParams = this.convertObjectToSingleParams(urlEncodedContent.schema);
-        params.push(...formParams);
+      if (operation.isUrlEncoded) {
+        params.push(...this.convertObjectToSingleParams(operation.urlEncodedSchema));
       }
-      if (jsonContent && !formDataContent) {
+      if (jsonContent && !operation.isMultipart) {
         const bodyType = this.getRequestBodyType(requestBody);
         const isInterface = isDataTypeInterface(bodyType);
         params.push({
@@ -2422,11 +2639,12 @@ var ServiceMethodParamsGenerator = class {
         });
       }
     }
-    const queryParams = operation.parameters?.filter((p) => p.in === "query") || [];
-    queryParams.forEach((param) => {
+    operation.queryParams.forEach((param) => {
       params.push({
         name: camelCase(param.name),
-        type: getTypeScriptType(param.schema || param, this.config),
+        type: getTypeScriptType(param.schema || {
+          ...param
+        }, this.config),
         hasQuestionToken: !param.required
       });
     });
@@ -2465,17 +2683,14 @@ var ServiceMethodParamsGenerator = class {
     }
     return "any";
   }
+  /** `schema` arrives ref-resolved from the normalizer (formData/urlEncoded schema). */
   convertObjectToSingleParams(schema) {
     const params = [];
-    let resolvedSchema = schema;
-    if (schema?.$ref) {
-      resolvedSchema = this.parser.resolveReference(schema.$ref);
-    }
-    Object.entries(resolvedSchema?.properties ?? {}).forEach(([key, value]) => {
+    Object.entries(schema?.properties ?? {}).forEach(([key, value]) => {
       params.push({
         name: key,
         type: getTypeScriptType(value, this.config, value.nullable),
-        hasQuestionToken: !resolvedSchema?.required?.includes(key)
+        hasQuestionToken: !schema?.required?.includes(key)
       });
     });
     return params;
@@ -2490,9 +2705,9 @@ var ServiceMethodOverloadsGenerator = class {
   config;
   paramsGenerator;
   responseDataType = "any";
-  constructor(config, parser) {
+  constructor(config) {
     this.config = config;
-    this.paramsGenerator = new ServiceMethodParamsGenerator(config, parser);
+    this.paramsGenerator = new ServiceMethodParamsGenerator(config);
   }
   generateMethodOverloads(operation, requestObject) {
     const observeTypes = [
@@ -2501,7 +2716,7 @@ var ServiceMethodOverloadsGenerator = class {
       "events"
     ];
     const overloads = [];
-    const responseType = this.determineResponseTypeForOperation(operation);
+    const responseType = operation.responseType;
     observeTypes.forEach((observe) => {
       const overload = this.generateMethodOverload(operation, observe, responseType, requestObject);
       if (overload) {
@@ -2577,21 +2792,6 @@ var ServiceMethodOverloadsGenerator = class {
     }
     return `RequestOptions<'${responseType}', ${additionalTypeParameters.join(", ")}>`;
   }
-  determineResponseTypeForOperation(operation) {
-    const successResponses = [
-      "200",
-      "201",
-      "202",
-      "204",
-      "206"
-    ];
-    for (const statusCode of successResponses) {
-      const response = operation.responses?.[statusCode];
-      if (!response) continue;
-      return getResponseTypeFromResponse(response);
-    }
-    return "json";
-  }
 };
 
 // src/lib/generators/service/service-method.generator.ts
@@ -2603,11 +2803,11 @@ var ServiceMethodGenerator = class {
   bodyGenerator;
   overloadsGenerator;
   paramsGenerator;
-  constructor(config, parser) {
+  constructor(config) {
     this.config = config;
-    this.bodyGenerator = new ServiceMethodBodyGenerator(config, parser);
-    this.overloadsGenerator = new ServiceMethodOverloadsGenerator(config, parser);
-    this.paramsGenerator = new ServiceMethodParamsGenerator(config, parser);
+    this.bodyGenerator = new ServiceMethodBodyGenerator(config);
+    this.overloadsGenerator = new ServiceMethodOverloadsGenerator(config);
+    this.paramsGenerator = new ServiceMethodParamsGenerator(config);
   }
   addServiceMethod(serviceClass, operation, requestObject) {
     const methodName = this.generateMethodName(operation);
@@ -2672,9 +2872,9 @@ var RequestParamsGenerator = class {
   paramsGenerator;
   registry = /* @__PURE__ */ new Map();
   usedInterfaceNames = /* @__PURE__ */ new Set();
-  constructor(parser, project, config) {
+  constructor(project, config) {
     this.project = project;
-    this.paramsGenerator = new ServiceMethodParamsGenerator(config, parser);
+    this.paramsGenerator = new ServiceMethodParamsGenerator(config);
   }
   buildRegistry(controllerGroups, getMethodName) {
     Object.entries(controllerGroups).forEach(([controllerName, operations]) => {
@@ -2778,31 +2978,27 @@ var ServiceGenerator = class {
   }
   project;
   parser;
-  spec;
   config;
   methodGenerator;
   requestObjects;
-  constructor(parser, project, config) {
+  onWarning;
+  constructor(parser, project, config, onWarning) {
     this.config = config;
     this.project = project;
     this.parser = parser;
-    this.spec = this.parser.getSpec();
-    if (!this.parser.isValidSpec()) {
-      const versionInfo = this.parser.getSpecVersion();
-      throw new Error(`Invalid or unsupported specification format. Expected OpenAPI 3.x or Swagger 2.x. ${versionInfo ? `Found: ${versionInfo.type} ${versionInfo.version}` : "No version info found"}`);
-    }
-    this.methodGenerator = new ServiceMethodGenerator(config, parser);
+    this.onWarning = onWarning;
+    this.methodGenerator = new ServiceMethodGenerator(config);
   }
   async generate(outputRoot) {
     const outputDir = path10.join(outputRoot, "services");
-    const paths = extractPaths(this.spec.paths);
+    const paths = this.parser.getNormalizedSpec().operations;
     if (paths.length === 0) {
-      console.warn("No API paths found in the specification");
+      this.onWarning?.("No API paths found in the specification");
       return;
     }
     const controllerGroups = this.groupPathsByController(paths);
     if (this.config.options.useSingleRequestParameter) {
-      const requestParamsGenerator = new RequestParamsGenerator(this.parser, this.project, this.config);
+      const requestParamsGenerator = new RequestParamsGenerator(this.project, this.config);
       this.requestObjects = requestParamsGenerator.buildRegistry(controllerGroups, (operation) => this.methodGenerator.generateMethodName(operation));
       requestParamsGenerator.generate(outputRoot);
     }
@@ -2898,27 +3094,27 @@ var ServiceGenerator = class {
     serviceClass.addProperty({
       name: "httpClient",
       type: "HttpClient",
-      scope: import_ts_morph6.Scope.Private,
+      scope: import_ts_morph9.Scope.Private,
       isReadonly: true,
       initializer: "inject(HttpClient)"
     });
     serviceClass.addProperty({
       name: "basePath",
       type: "string",
-      scope: import_ts_morph6.Scope.Private,
+      scope: import_ts_morph9.Scope.Private,
       isReadonly: true,
       initializer: `inject(${basePathTokenName})`
     });
     serviceClass.addProperty({
       name: "clientContextToken",
       type: "HttpContextToken<string>",
-      scope: import_ts_morph6.Scope.Private,
+      scope: import_ts_morph9.Scope.Private,
       isReadonly: true,
       initializer: clientContextTokenName
     });
     serviceClass.addMethod({
       name: "createContextWithClientId",
-      scope: import_ts_morph6.Scope.Private,
+      scope: import_ts_morph9.Scope.Private,
       parameters: [
         {
           name: "existingContext",
@@ -2971,6 +3167,111 @@ var ServiceIndexGenerator = class {
   }
 };
 
+// src/lib/core/config-validation.ts
+var RESPONSE_TYPES = [
+  "json",
+  "blob",
+  "arraybuffer",
+  "text"
+];
+var ConfigValidationError = class extends Error {
+  static {
+    __name(this, "ConfigValidationError");
+  }
+  issues;
+  constructor(issues) {
+    super(`Invalid ng-openapi configuration:
+${issues.map((issue) => `  - ${issue}`).join("\n")}`);
+    this.name = "ConfigValidationError";
+    this.issues = issues;
+  }
+};
+function validateGeneratorConfig(config) {
+  if (!config || typeof config !== "object") {
+    throw new ConfigValidationError([
+      "config must be an object \u2014 see https://ng-openapi.dev for the shape"
+    ]);
+  }
+  const issues = [];
+  const c = config;
+  if (typeof c.input !== "string" || c.input.trim() === "") {
+    issues.push("`input` must be a non-empty string (path or URL of the OpenAPI/Swagger spec)");
+  }
+  if (typeof c.output !== "string" || c.output.trim() === "") {
+    issues.push("`output` must be a non-empty string (output directory)");
+  }
+  if (c.clientName !== void 0 && typeof c.clientName !== "string") {
+    issues.push("`clientName` must be a string");
+  }
+  if (c.validateInput !== void 0 && typeof c.validateInput !== "function") {
+    issues.push("`validateInput` must be a function (spec) => boolean");
+  }
+  if (!c.options || typeof c.options !== "object") {
+    issues.push("`options` must be an object with at least `dateType` and `enumStyle`");
+  } else {
+    const options = c.options;
+    if (options.dateType !== "string" && options.dateType !== "Date") {
+      issues.push(`\`options.dateType\` must be "string" or "Date", got ${JSON.stringify(options.dateType)}`);
+    }
+    if (options.enumStyle !== "enum" && options.enumStyle !== "union") {
+      issues.push(`\`options.enumStyle\` must be "enum" or "union", got ${JSON.stringify(options.enumStyle)}`);
+    }
+    const booleanKeys = [
+      "generateServices",
+      "generateEnumBasedOnDescription",
+      "useSingleRequestParameter"
+    ];
+    for (const key of booleanKeys) {
+      if (options[key] !== void 0 && typeof options[key] !== "boolean") {
+        issues.push(`\`options.${key}\` must be a boolean`);
+      }
+    }
+    if (options.customizeMethodName !== void 0 && typeof options.customizeMethodName !== "function") {
+      issues.push("`options.customizeMethodName` must be a function (operationId) => string");
+    }
+    if (options.validation !== void 0 && (typeof options.validation !== "object" || options.validation === null)) {
+      issues.push("`options.validation` must be an object like { response?: boolean }");
+    }
+    if (options.customHeaders !== void 0) {
+      if (typeof options.customHeaders !== "object" || options.customHeaders === null) {
+        issues.push("`options.customHeaders` must be an object of header name \u2192 value strings");
+      } else {
+        for (const [header, value] of Object.entries(options.customHeaders)) {
+          if (typeof value !== "string") {
+            issues.push(`\`options.customHeaders["${header}"]\` must be a string`);
+          }
+        }
+      }
+    }
+    if (options.responseTypeMapping !== void 0) {
+      if (typeof options.responseTypeMapping !== "object" || options.responseTypeMapping === null) {
+        issues.push("`options.responseTypeMapping` must be an object of content type \u2192 response type");
+      } else {
+        for (const [contentType, value] of Object.entries(options.responseTypeMapping)) {
+          if (!RESPONSE_TYPES.includes(value)) {
+            issues.push(`\`options.responseTypeMapping["${contentType}"]\` must be one of ${RESPONSE_TYPES.join(", ")}, got ${JSON.stringify(value)}`);
+          }
+        }
+      }
+    }
+  }
+  if (c.plugins !== void 0) {
+    if (!Array.isArray(c.plugins)) {
+      issues.push("`plugins` must be an array of plugin classes (e.g. HttpResourcePlugin, ZodPlugin)");
+    } else {
+      c.plugins.forEach((plugin, index) => {
+        if (typeof plugin !== "function") {
+          issues.push(`\`plugins[${index}]\` must be a plugin class, got ${typeof plugin}`);
+        }
+      });
+    }
+  }
+  if (issues.length > 0) {
+    throw new ConfigValidationError(issues);
+  }
+}
+__name(validateGeneratorConfig, "validateGeneratorConfig");
+
 // src/lib/core/generator.ts
 var fs3 = __toESM(require("fs"));
 var path12 = __toESM(require("path"));
@@ -2979,7 +3280,7 @@ function validateInput(inputPath) {
     return;
   }
   if (!fs3.existsSync(inputPath)) {
-    throw new Error(`Input file not found: ${inputPath}`);
+    throw new SpecLoadError(`Input file not found: ${inputPath}`, inputPath);
   }
   const extension = path12.extname(inputPath).toLowerCase();
   const supportedExtensions = [
@@ -2988,89 +3289,124 @@ function validateInput(inputPath) {
     ".yml"
   ];
   if (!supportedExtensions.includes(extension)) {
-    throw new Error(`Failed to parse ${extension || "specification"}. Supported formats are .json, .yaml, and .yml.`);
+    throw new SpecLoadError(`Failed to parse ${extension || "specification"}. Supported formats are .json, .yaml, and .yml.`, inputPath);
   }
 }
 __name(validateInput, "validateInput");
-async function generateFromConfig(config) {
+async function generateFromConfig(config, reporter = {}) {
+  const startedAt = Date.now();
+  validateGeneratorConfig(config);
   validateInput(config.input);
   const outputPath = config.output;
   const generateServices = config.options.generateServices ?? true;
-  const inputType = isUrl(config.input) ? "URL" : "file";
+  const warnings = [];
+  const onWarning = /* @__PURE__ */ __name((message) => {
+    warnings.push(message);
+    reporter.onWarning?.(message);
+  }, "onWarning");
   if (!fs3.existsSync(outputPath)) {
     fs3.mkdirSync(outputPath, {
       recursive: true
     });
   }
-  try {
-    const project = new import_ts_morph7.Project({
-      compilerOptions: {
-        declaration: true,
-        target: import_ts_morph7.ScriptTarget.ES2022,
-        module: import_ts_morph7.ModuleKind.Preserve,
-        strict: true,
-        ...config.compilerOptions
-      }
-    });
-    console.log(`\u{1F4E1} Processing OpenAPI specification from ${inputType}: ${config.input}`);
-    const swaggerParser = await SwaggerParser.create(config.input, config);
-    const typeGenerator = new TypeGenerator(swaggerParser, project, config, outputPath);
-    await typeGenerator.generate();
-    console.log(`\u2705 TypeScript interfaces generated`);
-    if (generateServices) {
-      const tokenGenerator = new TokenGenerator(project, config.clientName);
-      tokenGenerator.generate(outputPath);
-      if (config.options.dateType === "Date") {
-        const dateTransformer = new DateTransformerGenerator(project);
-        dateTransformer.generate(outputPath);
-      }
-      const fileDownloadHelper = new FileDownloadGenerator(project);
-      fileDownloadHelper.generate(outputPath);
-      const httpParamsBuilderGenerator = new HttpParamsBuilderGenerator(project);
-      httpParamsBuilderGenerator.generate(outputPath);
-      const providerGenerator = new ProviderGenerator(project, config);
-      providerGenerator.generate(outputPath);
-      const baseInterceptorGenerator = new BaseInterceptorGenerator(project, config.clientName);
-      baseInterceptorGenerator.generate(outputPath);
-      const serviceGenerator = new ServiceGenerator(swaggerParser, project, config);
-      await serviceGenerator.generate(outputPath);
-      const indexGenerator = new ServiceIndexGenerator(project);
-      indexGenerator.generateIndex(outputPath);
-      console.log(`\u2705 Angular services generated`);
-    }
-    if (config.plugins?.length) {
-      for (const plugin of config.plugins) {
-        const generatorClass = plugin;
-        const pluginGenerator = new generatorClass(swaggerParser, project, config);
-        await pluginGenerator.generate(outputPath);
-      }
-      console.log(`\u2705 Plugins are generated`);
-    }
-    const mainIndexGenerator = new MainIndexGenerator(project, config);
-    mainIndexGenerator.generateMainIndex(outputPath);
-    const sourceInfo = `from ${inputType}: ${config.input}`;
-    if (config.clientName) {
-      console.log(`\u{1F389} ${config.clientName} Generation completed successfully ${sourceInfo} -> ${outputPath}`);
-    } else {
-      console.log(`\u{1F389} Generation completed successfully ${sourceInfo} -> ${outputPath}`);
-    }
-  } catch (error) {
-    if (error instanceof Error) {
-      console.error("\u274C Error during generation:", error.message);
-      if (error.message.includes("fetch") || error.message.includes("Failed to fetch")) {
-        console.error("\u{1F4A1} Tip: Make sure the URL is accessible and returns a valid OpenAPI/Swagger specification");
-        console.error("\u{1F4A1} Alternative: Download the specification file locally and use the file path instead");
-      }
-    } else {
-      console.error("\u274C Unknown error during generation:", error);
+  const project = new import_ts_morph10.Project({
+    compilerOptions: {
+      declaration: true,
+      target: import_ts_morph10.ScriptTarget.ES2022,
+      module: import_ts_morph10.ModuleKind.Preserve,
+      strict: true,
+      ...config.compilerOptions
     }
-    throw error;
-  }
+  });
+  reporter.onPhase?.("processing-spec");
+  const swaggerParser = await SwaggerParser.create(config.input, config);
+  if (!swaggerParser.isValidSpec()) {
+    const versionInfo = swaggerParser.getSpecVersion();
+    throw new SpecParseError(`Invalid or unsupported specification format. Expected OpenAPI 3.x or Swagger 2.x. ${versionInfo ? `Found: ${versionInfo.type} ${versionInfo.version}` : "No version info found"}`, config.input);
+  }
+  const normalizedSpec = swaggerParser.getNormalizedSpec();
+  const typeGenerator = new TypeGenerator(swaggerParser, project, config, outputPath, onWarning);
+  await typeGenerator.generate();
+  reporter.onPhase?.("types-generated");
+  if (generateServices) {
+    const tokenGenerator = new TokenGenerator(project, config.clientName);
+    tokenGenerator.generate(outputPath);
+    if (config.options.dateType === "Date") {
+      const dateTransformer = new DateTransformerGenerator(project);
+      dateTransformer.generate(outputPath);
+    }
+    const fileDownloadHelper = new FileDownloadGenerator(project);
+    fileDownloadHelper.generate(outputPath);
+    const httpParamsBuilderGenerator = new HttpParamsBuilderGenerator(project);
+    httpParamsBuilderGenerator.generate(outputPath);
+    const providerGenerator = new ProviderGenerator(project, config);
+    providerGenerator.generate(outputPath);
+    const baseInterceptorGenerator = new BaseInterceptorGenerator(project, config.clientName);
+    baseInterceptorGenerator.generate(outputPath);
+    const serviceGenerator = new ServiceGenerator(swaggerParser, project, config, onWarning);
+    await serviceGenerator.generate(outputPath);
+    const indexGenerator = new ServiceIndexGenerator(project);
+    indexGenerator.generateIndex(outputPath);
+    reporter.onPhase?.("services-generated");
+  }
+  if (config.plugins?.length) {
+    for (const plugin of config.plugins) {
+      const pluginGenerator = new plugin({
+        spec: normalizedSpec,
+        project,
+        config,
+        onWarning
+      });
+      await pluginGenerator.generate(outputPath);
+    }
+    reporter.onPhase?.("plugins-generated");
+  }
+  const mainIndexGenerator = new MainIndexGenerator(project, config);
+  mainIndexGenerator.generateMainIndex(outputPath);
+  return {
+    client: config.clientName,
+    filesWritten: project.getSourceFiles().map((sourceFile) => sourceFile.getFilePath()),
+    warnings,
+    durationMs: Date.now() - startedAt
+  };
 }
 __name(generateFromConfig, "generateFromConfig");
 
 // src/lib/cli.ts
 var program = new import_commander.Command();
+function createConsoleReporter(config) {
+  const inputType = isUrl(config.input) ? "URL" : "file";
+  return {
+    onPhase(phase) {
+      switch (phase) {
+        case "processing-spec":
+          console.log(`\u{1F4E1} Processing OpenAPI specification from ${inputType}: ${config.input}`);
+          break;
+        case "types-generated":
+          console.log("\u2705 TypeScript interfaces generated");
+          break;
+        case "services-generated":
+          console.log("\u2705 Angular services generated");
+          break;
+        case "plugins-generated":
+          console.log("\u2705 Plugins are generated");
+          break;
+      }
+    },
+    onWarning(message) {
+      console.warn(`\u26A0\uFE0F ${message}`);
+    }
+  };
+}
+__name(createConsoleReporter, "createConsoleReporter");
+async function runGeneration(config) {
+  const result = await generateFromConfig(config, createConsoleReporter(config));
+  const inputType = isUrl(config.input) ? "URL" : "file";
+  const sourceInfo = `from ${inputType}: ${config.input}`;
+  const clientPrefix = result.client ? `${result.client} ` : "";
+  console.log(`\u{1F389} ${clientPrefix}Generation completed successfully ${sourceInfo} -> ${config.output}`);
+}
+__name(runGeneration, "runGeneration");
 async function loadConfigFile(configPath) {
   const resolvedPath = path13.resolve(configPath);
   if (!fs4.existsSync(resolvedPath)) {
@@ -3104,32 +3440,38 @@ async function generateFromOptions(options) {
   try {
     if (options.config) {
       const config = await loadConfigFile(options.config);
-      await generateFromConfig(config);
+      await runGeneration(config);
     } else if (options.input) {
       const config = {
         input: options.input,
         output: options.output || "./src/generated",
         options: {
+          // Passed through unchecked on purpose: validateGeneratorConfig
+          // rejects anything but "string" | "Date" with an actionable error
           dateType: options.dateType || "Date",
           enumStyle: "enum",
           generateEnumBasedOnDescription: true,
           generateServices: !options.typesOnly
         }
       };
-      await generateFromConfig(config);
+      await runGeneration(config);
     } else {
       console.error("Error: Either --config or --input option is required");
-      program.help();
-      process.exit(1);
+      program.help({
+        error: true
+      });
     }
     console.log("\u2728 Generation completed successfully!");
   } catch (error) {
     console.error("\u274C Generation failed:", error instanceof Error ? error.message : error);
-    process.exit(1);
+    if (error instanceof SpecLoadError && isUrl(error.source)) {
+      console.error("\u{1F4A1} Tip: Make sure the URL is accessible and returns a valid OpenAPI/Swagger specification");
+      console.error("\u{1F4A1} Alternative: Download the specification file locally and use the file path instead");
+    }
+    process.exitCode = 1;
   } finally {
     const duration = ((/* @__PURE__ */ new Date()).getTime() - timestamp) / 1e3;
     console.log(`\u23F1\uFE0F  Duration: ${duration.toFixed(2)} seconds`);
-    process.exit(0);
   }
 }
 __name(generateFromOptions, "generateFromOptions");