ng-openapi 0.2.22 → 0.3.0

package/index.js

@@ -1,7 +1,9 @@
 "use strict";
 var __create = Object.create;
 var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getOwnPropSymbols = Object.getOwnPropertySymbols;
 var __getProtoOf = Object.getPrototypeOf;
@@ -22,6 +24,7 @@ var __spreadValues = (a, b) => {
     }
   return a;
 };
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 var __export = (target, all) => {
   for (var name in all)
@@ -75,17 +78,29 @@ var index_exports = {};
 __export(index_exports, {
   BASE_INTERCEPTOR_HEADER_COMMENT: () => BASE_INTERCEPTOR_HEADER_COMMENT,
   CONTENT_TYPES: () => CONTENT_TYPES,
+  ConfigValidationError: () => ConfigValidationError,
   HTTP_RESOURCE_GENERATOR_HEADER_COMMENT: () => HTTP_RESOURCE_GENERATOR_HEADER_COMMENT,
   MAIN_INDEX_GENERATOR_HEADER_COMMENT: () => MAIN_INDEX_GENERATOR_HEADER_COMMENT,
+  NgOpenApiError: () => NgOpenApiError,
   PROVIDER_GENERATOR_HEADER_COMMENT: () => PROVIDER_GENERATOR_HEADER_COMMENT,
   REQUEST_PARAMS_GENERATOR_HEADER_COMMENT: () => REQUEST_PARAMS_GENERATOR_HEADER_COMMENT,
   SERVICE_GENERATOR_HEADER_COMMENT: () => SERVICE_GENERATOR_HEADER_COMMENT,
   SERVICE_INDEX_GENERATOR_HEADER_COMMENT: () => SERVICE_INDEX_GENERATOR_HEADER_COMMENT,
+  SpecLoadError: () => SpecLoadError,
+  SpecParseError: () => SpecParseError,
   SwaggerParser: () => SwaggerParser,
   TYPE_GENERATOR_HEADER_COMMENT: () => TYPE_GENERATOR_HEADER_COMMENT,
   ZOD_PLUGIN_GENERATOR_HEADER_COMMENT: () => ZOD_PLUGIN_GENERATOR_HEADER_COMMENT,
   ZOD_PLUGIN_INDEX_GENERATOR_HEADER_COMMENT: () => ZOD_PLUGIN_INDEX_GENERATOR_HEADER_COMMENT,
   camelCase: () => camelCase,
+  defineConfig: () => defineConfig,
+  emitDefaultHeadersMerge: () => emitDefaultHeadersMerge,
+  emitHeaders: () => emitHeaders,
+  emitQueryParams: () => emitQueryParams,
+  emitResponseTypeOption: () => emitResponseTypeOption,
+  emitSignalAwareQueryParams: () => emitSignalAwareQueryParams,
+  emitUrlConstruction: () => emitUrlConstruction,
+  emitUrlExpression: () => emitUrlExpression,
   escapeString: () => escapeString,
   extractPaths: () => extractPaths,
   generateFromConfig: () => generateFromConfig,
@@ -101,17 +116,234 @@ __export(index_exports, {
   inferResponseTypeFromContentType: () => inferResponseTypeFromContentType,
   isDataTypeInterface: () => isDataTypeInterface,
   isPrimitiveType: () => isPrimitiveType,
+  isUrl: () => isUrl,
+  joinRequestOptionEntries: () => joinRequestOptionEntries,
   kebabCase: () => kebabCase,
+  normalizeSchema: () => normalizeSchema,
+  normalizeSpec: () => normalizeSpec,
   nullableType: () => nullableType,
   pascalCase: () => pascalCase,
   pascalCaseForEnums: () => pascalCaseForEnums,
+  plainParamValue: () => plainParamValue,
   screamingSnakeCase: () => screamingSnakeCase,
+  signalAwareParamValue: () => signalAwareParamValue,
+  validateGeneratorConfig: () => validateGeneratorConfig,
   validateInput: () => validateInput
 });
 module.exports = __toCommonJS(index_exports);
 
 // src/lib/core/generator.ts
-var import_ts_morph7 = require("ts-morph");
+var import_ts_morph10 = require("ts-morph");
+
+// ../shared/src/core/spec-loader.ts
+var fs = __toESM(require("fs"));
+
+// ../shared/src/utils/functions/is-url.ts
+function isUrl(input) {
+  try {
+    const url = new URL(input);
+    return [
+      "http:",
+      "https:"
+    ].includes(url.protocol);
+  } catch (e) {
+    return false;
+  }
+}
+__name(isUrl, "isUrl");
+
+// ../shared/src/errors.ts
+var _NgOpenApiError = class _NgOpenApiError extends Error {
+  constructor(message, cause) {
+    super(message);
+    /** The underlying error that caused this one, when there is one. */
+    __publicField(this, "cause");
+    this.name = new.target.name;
+    this.cause = cause;
+  }
+};
+__name(_NgOpenApiError, "NgOpenApiError");
+var NgOpenApiError = _NgOpenApiError;
+var _SpecLoadError = class _SpecLoadError extends NgOpenApiError {
+  constructor(message, source, cause) {
+    super(message, cause);
+    /** The file path or URL that failed to load. */
+    __publicField(this, "source");
+    this.source = source;
+  }
+};
+__name(_SpecLoadError, "SpecLoadError");
+var SpecLoadError = _SpecLoadError;
+var _SpecParseError = class _SpecParseError extends NgOpenApiError {
+  constructor(message, source, cause) {
+    super(message, cause);
+    /** The file path or URL the content came from, when known. */
+    __publicField(this, "source");
+    this.source = source;
+  }
+};
+__name(_SpecParseError, "SpecParseError");
+var SpecParseError = _SpecParseError;
+
+// ../shared/src/core/spec-loader.ts
+function loadSpecContent(pathOrUrl) {
+  return __async(this, null, function* () {
+    if (isUrl(pathOrUrl)) {
+      return yield 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");
+function fetchUrlContent(url) {
+  return __async(this, null, function* () {
+    try {
+      const response = yield 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 = yield 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");
+
+// ../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(([path13, pathItem]) => {
+    methods.forEach((method) => {
+      const operation = pathItem[method];
+      if (operation) {
+        paths.push({
+          path: path13,
+          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) {
@@ -157,7 +389,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) {
@@ -204,78 +436,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(([path13, pathItem]) => {
-    methods.forEach((method) => {
-      if (pathItem[method]) {
-        const operation = pathItem[method];
-        paths.push({
-          path: path13,
-          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) {
   var _a;
@@ -340,7 +500,7 @@ function isPrimitiveType(schema) {
     "integer",
     "boolean"
   ];
-  if (primitiveTypes.includes(schema.type)) {
+  if (schema.type && primitiveTypes.includes(schema.type)) {
     return true;
   }
   if (schema.type === "array") {
@@ -411,60 +571,434 @@ 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 == null ? void 0 : jsonContent.schema) {
-    return getTypeScriptType(jsonContent.schema, config, jsonContent.schema.nullable);
+// ../shared/src/core/normalize.ts
+function normalizeSpec(spec) {
+  var _a;
+  const rawDefinitions = spec.definitions || ((_a = spec.components) == null ? void 0 : _a.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 = __spreadValues({}, 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"
-  ];
-  return !invalidTypes.some((invalidType) => type.includes(invalidType));
+__name(normalizeSchema, "normalizeSchema");
+function normalizeOperationSchemas(operation) {
+  var _a;
+  return __spreadProps(__spreadValues({}, operation), {
+    parameters: (_a = operation.parameters) == null ? void 0 : _a.map((parameter) => parameter.schema ? __spreadProps(__spreadValues({}, parameter), {
+      schema: normalizeSchema(parameter.schema)
+    }) : parameter),
+    requestBody: operation.requestBody ? __spreadProps(__spreadValues({}, operation.requestBody), {
+      content: normalizeContentSchemas(operation.requestBody.content)
+    }) : operation.requestBody,
+    responses: operation.responses ? Object.fromEntries(Object.entries(operation.responses).map(([status, response]) => [
+      status,
+      __spreadProps(__spreadValues({}, response), {
+        content: normalizeContentSchemas(response.content)
+      })
+    ])) : operation.responses
+  });
 }
-__name(isDataTypeInterface, "isDataTypeInterface");
-
-// ../shared/src/utils/functions/generate-parse-request-type-params.ts
-function generateParseRequestTypeParams(params) {
-  const bodyParam = params.find((param) => {
-    return typeof param.type === "string" && isDataTypeInterface(param.type);
+__name(normalizeOperationSchemas, "normalizeOperationSchemas");
+function normalizeContentSchemas(content) {
+  if (!content) return content;
+  return Object.fromEntries(Object.entries(content).map(([contentType, mediaType]) => [
+    contentType,
+    (mediaType == null ? void 0 : mediaType.schema) ? __spreadProps(__spreadValues({}, mediaType), {
+      schema: normalizeSchema(mediaType.schema)
+    }) : mediaType
+  ]));
+}
+__name(normalizeContentSchemas, "normalizeContentSchemas");
+function normalizeOperation(operation, resolveRef) {
+  var _a, _b, _c;
+  const content = (_a = operation.requestBody) == null ? void 0 : _a.content;
+  const isMultipart = !!(content == null ? void 0 : content[CONTENT_TYPES.MULTIPART]);
+  const isUrlEncoded = !!(content == null ? void 0 : content[CONTENT_TYPES.FORM_URLENCODED]) && !(content == null ? void 0 : 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 __spreadProps(__spreadValues({}, operation), {
+    pathParams: ((_b = operation.parameters) == null ? void 0 : _b.filter((p) => p.in === "path")) || [],
+    queryParams: ((_c = operation.parameters) == null ? void 0 : _c.filter((p) => p.in === "query")) || [],
+    hasBody: !!operation.requestBody,
+    isMultipart,
+    isUrlEncoded,
+    formDataSchema,
+    formDataFields: Object.keys((formDataSchema == null ? void 0 : formDataSchema.properties) || {}),
+    urlEncodedSchema,
+    urlEncodedFields: Object.keys((urlEncodedSchema == null ? void 0 : urlEncodedSchema.properties) || {}),
+    responseType: determineResponseType(operation)
   });
-  if (bodyParam) {
-    const optional = bodyParam.hasQuestionToken ? " | undefined" : "";
-    return `${bodyParam.type}${optional}`;
+}
+__name(normalizeOperation, "normalizeOperation");
+function resolveBodySchema(requestBody, contentType, resolveRef) {
+  var _a, _b;
+  const schema = (_b = (_a = requestBody == null ? void 0 : requestBody.content) == null ? void 0 : _a[contentType]) == null ? void 0 : _b.schema;
+  return (schema == null ? void 0 : schema.$ref) ? resolveRef(schema.$ref) : schema;
+}
+__name(resolveBodySchema, "resolveBodySchema");
+function determineResponseType(operation) {
+  var _a;
+  const successResponses = [
+    "200",
+    "201",
+    "202",
+    "204",
+    "206"
+  ];
+  for (const statusCode of successResponses) {
+    const response = (_a = operation.responses) == null ? void 0 : _a[statusCode];
+    if (!response) continue;
+    return getResponseTypeFromResponse(response);
   }
-  return "";
+  return "json";
 }
-__name(generateParseRequestTypeParams, "generateParseRequestTypeParams");
+__name(determineResponseType, "determineResponseType");
 
-// ../shared/src/config/constants.ts
-var disableLinting = `/* @ts-nocheck */
-/* eslint-disable */
-/* @noformat */
-/* @formatter:off */
-`;
+// ../shared/src/core/swagger-parser.ts
+var _SwaggerParser = class _SwaggerParser {
+  constructor(spec, config) {
+    __publicField(this, "spec");
+    __publicField(this, "normalized");
+    var _a, _b;
+    const isInputValid = (_b = (_a = config.validateInput) == null ? void 0 : _a.call(config, spec)) != null ? _b : true;
+    if (!isInputValid) {
+      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 create(swaggerPathOrUrl, config) {
+    return __async(this, null, function* () {
+      const swaggerContent = yield loadSpecContent(swaggerPathOrUrl);
+      const spec = parseSpecContent(swaggerContent, swaggerPathOrUrl);
+      return new _SwaggerParser(spec, config);
+    });
+  }
+  /**
+   * 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() {
+    var _a;
+    (_a = this.normalized) != null ? _a : this.normalized = normalizeSpec(this.spec);
+    return this.normalized;
+  }
+  /** Definition map regardless of version: 2.0 `definitions` or 3.x `components.schemas`. */
+  getDefinitions() {
+    var _a;
+    return this.spec.definitions || ((_a = this.spec.components) == null ? void 0 : _a.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];
+    return this.getDefinition(definitionName);
+  }
+  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 {
+        type: "swagger",
+        version: this.spec.swagger
+      };
+    }
+    if (this.spec.openapi) {
+      return {
+        type: "openapi",
+        version: this.spec.openapi
+      };
+    }
+    return null;
+  }
+};
+__name(_SwaggerParser, "SwaggerParser");
+var SwaggerParser = _SwaggerParser;
+
+// ../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 == null ? void 0 : contentType.isMultipart) {
+    headerCode += `
+// Remove Content-Type for multipart (browser will set it with boundary)
+headers = headers.delete('Content-Type');`;
+  } else if (contentType == null ? void 0 : 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 == null ? void 0 : 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 emitDefaultHeadersMerge(optionsExpression, customHeaders) {
+  const defaultsLiteral = Object.entries(customHeaders).map(([key, value]) => `'${key}': '${value}'`).join(", ");
+  return `
+// Add default headers if not already present
+let headers = ${optionsExpression}?.headers;
+if (headers instanceof HttpHeaders) {
+${emitDefaultHeaderGuards(customHeaders)}
+} else {
+  headers = { ${defaultsLiteral}, ...headers };
+}`;
+}
+__name(emitDefaultHeadersMerge, "emitDefaultHeadersMerge");
+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 signalAwareParamValue(identifier) {
+  return `typeof ${identifier} === 'function' ? ${identifier}() : ${identifier}`;
+}
+__name(signalAwareParamValue, "signalAwareParamValue");
+function emitUrlExpression(path13, pathParams, paramValue = plainParamValue) {
+  let urlExpression = `\`\${this.basePath}${path13}\``;
+  pathParams.forEach((param) => {
+    urlExpression = urlExpression.replace(`{${param.name}}`, `\${${paramValue(camelCase(param.name))}}`);
+  });
+  return urlExpression;
+}
+__name(emitUrlExpression, "emitUrlExpression");
+function emitUrlConstruction(path13, pathParams) {
+  return `const url = ${emitUrlExpression(path13, 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");
+function emitSignalAwareQueryParams(queryParams) {
+  if (queryParams.length === 0) {
+    return "";
+  }
+  const paramMappings = queryParams.map((param) => `const ${camelCase(param.name)}Value = ${signalAwareParamValue(camelCase(param.name))};
+                if (${camelCase(param.name)}Value != null) {
+                    params = HttpParamsBuilder.addToHttpParams(params, ${camelCase(param.name)}Value, '${param.name}');
+                }`).join("\n");
+  return `
+let params = new HttpParams();
+${paramMappings}`;
+}
+__name(emitSignalAwareQueryParams, "emitSignalAwareQueryParams");
+
+// ../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 == null ? void 0 : 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/utils/functions/generate-parse-request-type-params.ts
+function generateParseRequestTypeParams(params) {
+  const bodyParam = params.find((param) => {
+    return typeof param.type === "string" && isDataTypeInterface(param.type);
+  });
+  if (bodyParam) {
+    const optional = bodyParam.hasQuestionToken ? " | undefined" : "";
+    return `${bodyParam.type}${optional}`;
+  }
+  return "";
+}
+__name(generateParseRequestTypeParams, "generateParseRequestTypeParams");
+
+// ../shared/src/config/define-config.ts
+function defineConfig(config) {
+  return config;
+}
+__name(defineConfig, "defineConfig");
+
+// ../shared/src/config/constants.ts
+var disableLinting = `/* @ts-nocheck */
+/* eslint-disable */
+/* @noformat */
+/* @formatter:off */
+`;
 var authorComment = `/**
 * Generated by ng-openapi
 `;
@@ -497,8 +1031,7 @@ var BASE_INTERCEPTOR_HEADER_COMMENT = /* @__PURE__ */ __name((clientName) => def
 * Do not edit this file manually
 */
 `, "BASE_INTERCEPTOR_HEADER_COMMENT");
-var HTTP_RESOURCE_GENERATOR_HEADER_COMMENT = /* @__PURE__ */ __name((resourceName) => defaultHeaderComment + `* \`httpResource\` is still an experimental feature - NOT PRODUCTION READY
-* Generated Angular service for ${resourceName}
+var HTTP_RESOURCE_GENERATOR_HEADER_COMMENT = /* @__PURE__ */ __name((resourceName) => defaultHeaderComment + `* Generated Angular \`httpResource\` service for ${resourceName}
 * Do not edit this file manually
 */
 `, "HTTP_RESOURCE_GENERATOR_HEADER_COMMENT");
@@ -511,267 +1044,181 @@ var ZOD_PLUGIN_INDEX_GENERATOR_HEADER_COMMENT = defaultHeaderComment + `* Genera
 */
 `;
 
-// ../shared/src/core/swagger-parser.ts
-var fs = __toESM(require("fs"));
-var path = __toESM(require("path"));
-var yaml = __toESM(require("js-yaml"));
+// src/lib/generators/type/enum-builder.ts
+var import_ts_morph = require("ts-morph");
 
-// ../shared/src/utils/functions/is-url.ts
-function isUrl(input) {
-  try {
-    const url = new URL(input);
-    return [
-      "http:",
-      "https:"
-    ].includes(url.protocol);
-  } catch (e) {
-    return false;
+// 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(isUrl, "isUrl");
-
-// ../shared/src/core/swagger-parser.ts
-var _SwaggerParser = class _SwaggerParser {
-  constructor(spec, config) {
-    __publicField(this, "spec");
-    var _a, _b;
-    const isInputValid = (_b = (_a = config.validateInput) == null ? void 0 : _a.call(config, spec)) != null ? _b : true;
-    if (!isInputValid) {
-      throw new Error("Swagger spec is not valid. Check your `validateInput` condition.");
-    }
-    this.spec = spec;
+__name(sanitizePropertyName, "sanitizePropertyName");
+var _TypeResolver = class _TypeResolver {
+  constructor(config, onWarning) {
+    __publicField(this, "config");
+    __publicField(this, "onWarning");
+    __publicField(this, "resolutionCache", /* @__PURE__ */ new WeakMap());
+    __publicField(this, "pascalCaseCache", /* @__PURE__ */ new Map());
+    __publicField(this, "sanitizedNameCache", /* @__PURE__ */ new Map());
+    this.config = config;
+    this.onWarning = onWarning;
   }
-  static create(swaggerPathOrUrl, config) {
-    return __async(this, null, function* () {
-      const swaggerContent = yield _SwaggerParser.loadContent(swaggerPathOrUrl);
-      const spec = _SwaggerParser.parseSpecContent(swaggerContent, swaggerPathOrUrl);
-      return new _SwaggerParser(spec, config);
-    });
+  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;
   }
-  static loadContent(pathOrUrl) {
-    return __async(this, null, function* () {
-      if (isUrl(pathOrUrl)) {
-        return yield _SwaggerParser.fetchUrlContent(pathOrUrl);
-      } else {
-        return fs.readFileSync(pathOrUrl, "utf8");
-      }
-    });
+  pascalName(str) {
+    if (!this.pascalCaseCache.has(str)) {
+      this.pascalCaseCache.set(str, pascalCaseForEnums(str));
+    }
+    return this.pascalCaseCache.get(str);
   }
-  static fetchUrlContent(url) {
-    return __async(this, null, function* () {
-      try {
-        const response = yield 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 = yield 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);
-      }
-    });
+  sanitizeName(name) {
+    if (!this.sanitizedNameCache.has(name)) {
+      this.sanitizedNameCache.set(name, sanitizePropertyName(name));
+    }
+    return this.sanitizedNameCache.get(name);
   }
-  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);
-      }
+  getArrayItemType(items) {
+    if (Array.isArray(items)) {
+      const types = items.map((item) => this.resolve(item));
+      return `[${types.join(", ")}]`;
     } 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}`);
+      return this.resolve(items);
     }
   }
-  static detectFormat(content) {
-    const trimmed = content.trim();
-    if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
-      return "json";
+  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 (trimmed.includes("openapi:") || trimmed.includes("swagger:") || trimmed.includes("---") || /^[a-zA-Z][a-zA-Z0-9_]*\s*:/.test(trimmed)) {
-      return "yaml";
+    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 "json";
-  }
-  getDefinitions() {
-    var _a;
-    return this.spec.definitions || ((_a = this.spec.components) == null ? void 0 : _a.schemas) || {};
+    return this.mapSwaggerTypeToTypeScript(schema.type, schema.format, schema.nullable);
   }
-  getDefinition(name) {
-    const definitions = this.getDefinitions();
-    return definitions[name];
+  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]) => {
+      var _a, _b;
+      const isRequired = (_b = (_a = definition.required) == null ? void 0 : _a.includes(key)) != null ? _b : false;
+      const questionMark = isRequired ? "" : "?";
+      const sanitizedKey = this.sanitizeName(key);
+      return `${sanitizedKey}${questionMark}: ${this.resolve(prop)}`;
+    }).join("; ");
+    return `{ ${properties} }`;
   }
   resolveReference(ref) {
-    const parts = ref.split("/");
-    const definitionName = parts[parts.length - 1];
-    return this.getDefinition(definitionName);
-  }
-  getAllDefinitionNames() {
-    return Object.keys(this.getDefinitions());
-  }
-  getSpec() {
-    return this.spec;
-  }
-  getPaths() {
-    return this.spec.paths || {};
-  }
-  isValidSpec() {
-    return !!(this.spec.swagger && this.spec.swagger.startsWith("2.") || this.spec.openapi && this.spec.openapi.startsWith("3."));
-  }
-  getSpecVersion() {
-    if (this.spec.swagger) {
-      return {
-        type: "swagger",
-        version: this.spec.swagger
-      };
+    var _a;
+    const refName = ref.split("/").pop();
+    if (!refName) {
+      (_a = this.onWarning) == null ? void 0 : _a.call(this, `Invalid reference format: ${ref}`);
+      return "unknown";
     }
-    if (this.spec.openapi) {
-      return {
-        type: "openapi",
-        version: this.spec.openapi
-      };
+    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);
     }
-    return null;
+  }
+  nullableType(type, isNullable) {
+    return type + (isNullable ? " | null" : "");
   }
 };
-__name(_SwaggerParser, "SwaggerParser");
-var SwaggerParser = _SwaggerParser;
+__name(_TypeResolver, "TypeResolver");
+var TypeResolver = _TypeResolver;
 
-// src/lib/generators/type/type.generator.ts
-var import_ts_morph = require("ts-morph");
-var _TypeGenerator = class _TypeGenerator {
-  constructor(parser, project, config, outputRoot) {
-    __publicField(this, "project");
-    __publicField(this, "parser");
-    __publicField(this, "sourceFile");
-    __publicField(this, "generatedTypes", /* @__PURE__ */ new Set());
+// 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 _EnumBuilder {
+  constructor(config, onWarning) {
     __publicField(this, "config");
-    // Performance caches
-    __publicField(this, "pascalCaseCache", /* @__PURE__ */ new Map());
-    __publicField(this, "sanitizedNameCache", /* @__PURE__ */ new Map());
-    __publicField(this, "typeResolutionCache", /* @__PURE__ */ new Map());
-    // Batch collection for AST operations
-    __publicField(this, "statements", []);
-    __publicField(this, "deferredTypes", /* @__PURE__ */ new Map());
+    __publicField(this, "onWarning");
     this.config = config;
-    this.project = project;
-    this.parser = parser;
-    const outputPath = outputRoot + "/models/index.ts";
-    this.sourceFile = this.project.createSourceFile(outputPath, "", {
-      overwrite: true
-    });
-  }
-  generate() {
-    return __async(this, null, function* () {
-      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();
-        yield this.finalize();
-      } catch (error) {
-        console.error("Error in generate():", error);
-        throw new Error(`Failed to generate types: ${error instanceof Error ? error.message : "Unknown error"}`);
-      }
-    });
-  }
-  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);
-    });
-  }
-  collectTypeStructure(name, definition) {
-    var _a;
-    const interfaceName = (_a = this.getCachedPascalCase(name)) != null ? _a : "";
-    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);
-    } 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
-      });
-    }
+    this.onWarning = onWarning;
   }
-  collectEnumStructure(name, definition) {
+  build(name, definition) {
     var _a;
-    if (!((_a = definition.enum) == null ? void 0 : _a.length)) return;
+    if (!((_a = definition.enum) == null ? void 0 : _a.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) {
@@ -781,7 +1228,7 @@ var _TypeGenerator = class _TypeGenerator {
     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({
@@ -792,7 +1239,7 @@ var _TypeGenerator = class _TypeGenerator {
         members
       });
     } else {
-      const members = this.buildEnumMembers(definition);
+      const members = this.buildEnumMembers(name, definition);
       statements.push({
         kind: import_ts_morph.StructureKind.Enum,
         name,
@@ -809,8 +1256,8 @@ var _TypeGenerator = class _TypeGenerator {
     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(" | ");
@@ -834,8 +1281,8 @@ var _TypeGenerator = class _TypeGenerator {
     });
     return statements;
   }
-  buildEnumMembers(definition) {
-    var _a;
+  buildEnumMembers(name, definition) {
+    var _a, _b;
     if (definition.description && this.config.options.generateEnumBasedOnDescription) {
       try {
         const enumValueObjects = JSON.parse(definition.description);
@@ -844,55 +1291,40 @@ var _TypeGenerator = class _TypeGenerator {
           value: obj.Value
         }));
       } catch (e) {
+        if (/^\s*[[{]/.test(definition.description)) {
+          (_a = this.onWarning) == null ? void 0 : _a.call(this, `Enum "${name}": description looks like JSON (generateEnumBasedOnDescription) but could not be used \u2014 falling back to raw enum values`);
+        }
       }
     }
-    return (_a = definition.enum) == null ? void 0 : _a.map((value) => ({
-      name: this.toEnumKey(value),
+    return (_b = definition.enum) == null ? void 0 : _b.map((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
-    });
-  }
-  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}>`
-    });
+};
+__name(_EnumBuilder, "EnumBuilder");
+var EnumBuilder = _EnumBuilder;
+
+// src/lib/generators/type/interface-builder.ts
+var import_ts_morph2 = require("ts-morph");
+var _InterfaceBuilder = class _InterfaceBuilder {
+  constructor(resolver) {
+    __publicField(this, "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 [];
     }
@@ -900,8 +1332,8 @@ var _TypeGenerator = class _TypeGenerator {
       var _a, _b;
       const isRequired = (_b = (_a = definition.required) == null ? void 0 : _a.includes(propertyName)) != null ? _b : false;
       const isReadOnly = property.readOnly;
-      const propertyType = this.resolveSwaggerTypeCached(property);
-      const sanitizedName = this.getCachedSanitizedName(propertyName);
+      const propertyType = this.resolver.resolve(property);
+      const sanitizedName = this.resolver.sanitizeName(propertyName);
       return {
         name: sanitizedName,
         type: propertyType,
@@ -943,123 +1375,159 @@ var _TypeGenerator = class _TypeGenerator {
     }
     return [];
   }
-  resolveSwaggerTypeCached(schema) {
-    const cacheKey = JSON.stringify(schema);
-    if (this.typeResolutionCache.has(cacheKey)) {
-      return this.typeResolutionCache.get(cacheKey);
+};
+__name(_InterfaceBuilder, "InterfaceBuilder");
+var InterfaceBuilder = _InterfaceBuilder;
+
+// src/lib/generators/type/sdk-types.ts
+var import_ts_morph3 = require("ts-morph");
+function buildSdkTypes(config) {
+  var _a;
+  const { response } = (_a = config.options.validation) != null ? _a : {};
+  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 _TypeGenerator {
+  constructor(parser, project, config, outputRoot, onWarning) {
+    __publicField(this, "parser");
+    __publicField(this, "config");
+    __publicField(this, "sourceFile");
+    __publicField(this, "resolver");
+    __publicField(this, "enumBuilder");
+    __publicField(this, "interfaceBuilder");
+    __publicField(this, "statements", []);
+    __publicField(this, "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);
   }
-  generateInlineObjectType(definition) {
-    if (!definition.properties) {
-      if (definition.additionalProperties) {
-        const additionalType = typeof definition.additionalProperties === "object" ? this.resolveSwaggerTypeCached(definition.additionalProperties) : "unknown";
-        return `Record<string, ${additionalType}>`;
+  generate() {
+    return __async(this, null, function* () {
+      var _a;
+      try {
+        const definitions = this.parser.getNormalizedSpec().definitions;
+        if (!definitions || Object.keys(definitions).length === 0) {
+          (_a = this.onWarning) == null ? void 0 : _a.call(this, "No definitions found in swagger file");
+        }
+        Object.entries(definitions).forEach(([name, definition]) => {
+          this.collectTypeStructure(name, definition);
+        });
+        this.statements.push(...buildSdkTypes(this.config));
+        this.applyBatchUpdates();
+        yield this.finalize();
+      } catch (error) {
+        throw new Error(`Failed to generate types: ${error instanceof Error ? error.message : "Unknown error"}`);
       }
-      return "Record<string, unknown>";
+    });
+  }
+  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)
+      });
     }
-    const properties = Object.entries(definition.properties).map(([key, prop]) => {
-      var _a, _b;
-      const isRequired = (_b = (_a = definition.required) == null ? void 0 : _a.includes(key)) != null ? _b : false;
-      const questionMark = isRequired ? "" : "?";
-      const sanitizedKey = this.getCachedSanitizedName(key);
-      return `${sanitizedKey}${questionMark}: ${this.resolveSwaggerTypeCached(prop)}`;
-    }).join("; ");
-    return `{ ${properties} }`;
   }
-  resolveReference(ref) {
-    const refName = ref.split("/").pop();
-    if (!refName) {
-      console.warn(`Invalid reference format: ${ref}`);
-      return "unknown";
+  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 this.getCachedPascalCase(refName);
+    return {
+      kind: import_ts_morph4.StructureKind.TypeAlias,
+      name,
+      type: typeExpression,
+      isExported: true,
+      docs: definition.description ? [
+        definition.description
+      ] : void 0
+    };
   }
-  collectSdkTypes() {
-    var _a;
-    const { response } = (_a = this.config.options.validation) != null ? _a : {};
-    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
-      });
-      typeParameters.push("TReturnType");
-    }
-    this.statements.push({
-      kind: import_ts_morph.StructureKind.Interface,
-      name: "RequestOptions",
+  buildArrayTypeAlias(name, definition) {
+    const itemType = definition.items ? this.resolver.getArrayItemType(definition.items) : "unknown";
+    return {
+      kind: import_ts_morph4.StructureKind.TypeAlias,
+      name,
       isExported: true,
-      typeParameters,
-      properties,
-      docs: [
-        "Request Options for Angular HttpClient requests"
-      ]
-    });
+      docs: definition.description ? [
+        definition.description
+      ] : void 0,
+      type: `Array<${itemType}>`
+    };
   }
   applyBatchUpdates() {
     this.sourceFile.insertText(0, TYPE_GENERATOR_HEADER_COMMENT);
@@ -1080,83 +1548,12 @@ var _TypeGenerator = class _TypeGenerator {
       yield 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, "\\'");
-  }
 };
 __name(_TypeGenerator, "TypeGenerator");
 var TypeGenerator = _TypeGenerator;
 
 // 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 _TokenGenerator {
   constructor(project, clientName = "default") {
@@ -1191,7 +1588,7 @@ var _TokenGenerator = class _TokenGenerator {
     const clientContextTokenName = this.getClientContextTokenName();
     sourceFile.addVariableStatement({
       isExported: true,
-      declarationKind: import_ts_morph2.VariableDeclarationKind.Const,
+      declarationKind: import_ts_morph5.VariableDeclarationKind.Const,
       declarations: [
         {
           name: basePathTokenName,
@@ -1208,7 +1605,7 @@ var _TokenGenerator = class _TokenGenerator {
     });
     sourceFile.addVariableStatement({
       isExported: true,
-      declarationKind: import_ts_morph2.VariableDeclarationKind.Const,
+      declarationKind: import_ts_morph5.VariableDeclarationKind.Const,
       declarations: [
         {
           name: interceptorsTokenName,
@@ -1225,7 +1622,7 @@ var _TokenGenerator = class _TokenGenerator {
     });
     sourceFile.addVariableStatement({
       isExported: true,
-      declarationKind: import_ts_morph2.VariableDeclarationKind.Const,
+      declarationKind: import_ts_morph5.VariableDeclarationKind.Const,
       declarations: [
         {
           name: clientContextTokenName,
@@ -1240,7 +1637,7 @@ var _TokenGenerator = class _TokenGenerator {
     if (this.clientName === "default") {
       sourceFile.addVariableStatement({
         isExported: true,
-        declarationKind: import_ts_morph2.VariableDeclarationKind.Const,
+        declarationKind: import_ts_morph5.VariableDeclarationKind.Const,
         declarations: [
           {
             name: "BASE_PATH",
@@ -1254,7 +1651,7 @@ var _TokenGenerator = class _TokenGenerator {
       });
       sourceFile.addVariableStatement({
         isExported: true,
-        declarationKind: import_ts_morph2.VariableDeclarationKind.Const,
+        declarationKind: import_ts_morph5.VariableDeclarationKind.Const,
         declarations: [
           {
             name: "CLIENT_CONTEXT_TOKEN",
@@ -1426,7 +1823,7 @@ __name(_FileDownloadGenerator, "FileDownloadGenerator");
 var FileDownloadGenerator = _FileDownloadGenerator;
 
 // 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 _DateTransformerGenerator {
   constructor(project) {
@@ -1466,7 +1863,7 @@ var _DateTransformerGenerator = class _DateTransformerGenerator {
     ]);
     sourceFile.addVariableStatement({
       isExported: true,
-      declarationKind: import_ts_morph3.VariableDeclarationKind.Const,
+      declarationKind: import_ts_morph6.VariableDeclarationKind.Const,
       declarations: [
         {
           name: "ISO_DATE_REGEX",
@@ -1538,7 +1935,7 @@ var _DateTransformerGenerator = class _DateTransformerGenerator {
             {
               name: "dateRegex",
               type: "RegExp",
-              scope: import_ts_morph3.Scope.Private,
+              scope: import_ts_morph6.Scope.Private,
               isReadonly: true,
               initializer: "ISO_DATE_REGEX"
             }
@@ -1836,7 +2233,7 @@ __name(_ProviderGenerator, "ProviderGenerator");
 var ProviderGenerator = _ProviderGenerator;
 
 // 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 _project, _clientName;
 var _BaseInterceptorGenerator = class _BaseInterceptorGenerator {
@@ -1903,14 +2300,14 @@ var _BaseInterceptorGenerator = class _BaseInterceptorGenerator {
         {
           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
         }
@@ -1964,7 +2361,7 @@ var BaseInterceptorGenerator = _BaseInterceptorGenerator;
 
 // 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 _HttpParamsBuilderGenerator {
   constructor(project) {
     __publicField(this, "project");
@@ -1995,7 +2392,7 @@ var _HttpParamsBuilderGenerator = class _HttpParamsBuilderGenerator {
       {
         name: "addToHttpParams",
         isStatic: true,
-        scope: import_ts_morph5.Scope.Public,
+        scope: import_ts_morph8.Scope.Public,
         parameters: [
           {
             name: "httpParams",
@@ -2028,7 +2425,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",
@@ -2067,7 +2464,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",
@@ -2092,7 +2489,7 @@ return httpParams;`
       {
         name: "handleDate",
         isStatic: true,
-        scope: import_ts_morph5.Scope.Private,
+        scope: import_ts_morph8.Scope.Private,
         parameters: [
           {
             name: "httpParams",
@@ -2117,7 +2514,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",
@@ -2143,7 +2540,7 @@ return httpParams;`
       {
         name: "handlePrimitive",
         isStatic: true,
-        scope: import_ts_morph5.Scope.Private,
+        scope: import_ts_morph8.Scope.Private,
         parameters: [
           {
             name: "httpParams",
@@ -2173,144 +2570,37 @@ __name(_HttpParamsBuilderGenerator, "HttpParamsBuilderGenerator");
 var HttpParamsBuilderGenerator = _HttpParamsBuilderGenerator;
 
 // 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
 var _ServiceMethodBodyGenerator = class _ServiceMethodBodyGenerator {
-  constructor(config, parser) {
+  constructor(config) {
     __publicField(this, "config");
-    __publicField(this, "parser");
     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) {
-    var _a, _b;
-    return !!((_b = (_a = operation.requestBody) == null ? void 0 : _a.content) == null ? void 0 : _b[CONTENT_TYPES.MULTIPART]);
-  }
-  isUrlEncodedFormData(operation) {
-    var _a, _b, _c, _d;
-    return !!((_b = (_a = operation.requestBody) == null ? void 0 : _a.content) == null ? void 0 : _b[CONTENT_TYPES.FORM_URLENCODED]) && !((_d = (_c = operation.requestBody) == null ? void 0 : _c.content) == null ? void 0 : _d[CONTENT_TYPES.JSON]);
-  }
-  getFormDataFields(operation) {
-    var _a, _b;
-    if (!this.isMultipartFormData(operation)) {
-      return [];
-    }
-    const schema = (_b = (_a = operation.requestBody) == null ? void 0 : _a.content) == null ? void 0 : _b[CONTENT_TYPES.MULTIPART].schema;
-    let resolvedSchema = schema;
-    if (schema == null ? void 0 : schema.$ref) {
-      resolvedSchema = this.parser.resolveReference(schema.$ref);
-    }
-    const properties = (resolvedSchema == null ? void 0 : resolvedSchema.properties) || {};
-    return Object.keys(properties);
-  }
-  getUrlEncodedFields(operation) {
-    var _a, _b;
-    if (!this.isUrlEncodedFormData(operation)) {
-      return [];
-    }
-    const schema = (_b = (_a = operation.requestBody) == null ? void 0 : _a.content) == null ? void 0 : _b[CONTENT_TYPES.FORM_URLENCODED].schema;
-    let resolvedSchema = schema;
-    if (schema == null ? void 0 : schema.$ref) {
-      resolvedSchema = this.parser.resolveReference(schema.$ref);
-    }
-    const properties = (resolvedSchema == null ? void 0 : resolvedSchema.properties) || {};
-    return Object.keys(properties);
-  }
-  createGenerationContext(operation) {
-    var _a, _b;
-    return {
-      pathParams: ((_a = operation.parameters) == null ? void 0 : _a.filter((p) => p.in === "path")) || [],
-      queryParams: ((_b = operation.parameters) == null ? void 0 : _b.filter((p) => p.in === "query")) || [],
-      hasBody: !!operation.requestBody,
-      isMultipart: this.isMultipartFormData(operation),
-      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) {
-    var _a, _b;
-    if (!context.isMultipart || context.formDataFields.length === 0) {
+  generateMultipartFormData(operation) {
+    var _a;
+    if (!operation.isMultipart || operation.formDataFields.length === 0) {
       return "";
     }
-    const schema = (_b = (_a = operation.requestBody) == null ? void 0 : _a.content) == null ? void 0 : _b[CONTENT_TYPES.MULTIPART].schema;
-    let resolvedSchema = schema;
-    if (schema == null ? void 0 : schema.$ref) {
-      resolvedSchema = this.parser.resolveReference(schema.$ref);
-    }
-    const properties = (resolvedSchema == null ? void 0 : resolvedSchema.properties) || {};
-    const formDataAppends = context.formDataFields.map((field) => {
+    const properties = ((_a = operation.formDataSchema) == null ? void 0 : _a.properties) || {};
+    const formDataAppends = operation.formDataFields.map((field) => {
       const fieldSchema = properties[field];
       const isFile = (fieldSchema == null ? void 0 : fieldSchema.type) === "string" && (fieldSchema == null ? void 0 : fieldSchema.format) === "binary";
       const isArray = (fieldSchema == null ? void 0 : fieldSchema.type) === "array";
@@ -2336,18 +2626,13 @@ if (!headers.has('Content-Type')) {
 const formData = new FormData();
 ${formDataAppends}`;
   }
-  generateUrlEncodedFormData(operation, context) {
-    var _a, _b;
-    if (!context.isUrlEncoded || context.urlEncodedFields.length === 0) {
+  generateUrlEncodedFormData(operation) {
+    var _a;
+    if (!operation.isUrlEncoded || operation.urlEncodedFields.length === 0) {
       return "";
     }
-    const schema = (_b = (_a = operation.requestBody) == null ? void 0 : _a.content) == null ? void 0 : _b[CONTENT_TYPES.FORM_URLENCODED].schema;
-    let resolvedSchema = schema;
-    if (schema == null ? void 0 : schema.$ref) {
-      resolvedSchema = this.parser.resolveReference(schema.$ref);
-    }
-    const properties = (resolvedSchema == null ? void 0 : resolvedSchema.properties) || {};
-    const formBodyAppends = context.urlEncodedFields.map((field) => {
+    const properties = ((_a = operation.urlEncodedSchema) == null ? void 0 : _a.properties) || {};
+    const formBodyAppends = operation.urlEncodedFields.map((field) => {
       const fieldSchema = properties[field];
       const isArray = (fieldSchema == null ? void 0 : fieldSchema.type) === "array";
       if (isArray) {
@@ -2368,33 +2653,14 @@ ${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) {
     var _a, _b, _c;
     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 ((_b = (_a = operation.requestBody) == null ? void 0 : _a.content) == null ? void 0 : _b[CONTENT_TYPES.JSON]) {
         const bodyType = getRequestBodyType(operation.requestBody, this.config);
@@ -2408,29 +2674,23 @@ const requestOptions: any = {
       "patch"
     ];
     const parseResponse = ((_c = this.config.options.validation) == null ? void 0 : _c.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) {
-    var _a;
-    const successResponses = [
-      "200",
-      "201",
-      "202",
-      "204",
-      "206"
-    ];
-    for (const statusCode of successResponses) {
-      const response = (_a = operation.responses) == null ? void 0 : _a[statusCode];
-      if (!response) continue;
-      return 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};`;
   }
 };
 __name(_ServiceMethodBodyGenerator, "ServiceMethodBodyGenerator");
@@ -2504,11 +2764,9 @@ var ServiceMethodRequestObjectGenerator = _ServiceMethodRequestObjectGenerator;
 
 // src/lib/generators/service/service-method/service-method-params.generator.ts
 var _ServiceMethodParamsGenerator = class _ServiceMethodParamsGenerator {
-  constructor(config, parser) {
+  constructor(config) {
     __publicField(this, "config");
-    __publicField(this, "parser");
     this.config = config;
-    this.parser = parser;
   }
   generateMethodParameters(operation) {
     const params = this.generateApiParameters(operation);
@@ -2519,30 +2777,28 @@ var _ServiceMethodParamsGenerator = class _ServiceMethodParamsGenerator {
     ]);
   }
   generateApiParameters(operation) {
-    var _a, _b, _c, _d, _e;
+    var _a;
     const params = [];
-    const pathParams = ((_a = operation.parameters) == null ? void 0 : _a.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 || __spreadValues({}, param), this.config),
         hasQuestionToken: !param.required
       });
     });
     const requestBody = operation.requestBody;
     if (requestBody) {
-      const formDataContent = (_b = requestBody.content) == null ? void 0 : _b[CONTENT_TYPES.MULTIPART];
-      const urlEncodedContent = (_c = requestBody.content) == null ? void 0 : _c[CONTENT_TYPES.FORM_URLENCODED];
-      const jsonContent = (_d = requestBody.content) == null ? void 0 : _d[CONTENT_TYPES.JSON];
-      if (formDataContent) {
-        const formParams = this.convertObjectToSingleParams(formDataContent.schema);
-        params.push(...formParams);
+      const jsonContent = (_a = requestBody.content) == null ? void 0 : _a[CONTENT_TYPES.JSON];
+      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({
@@ -2552,11 +2808,10 @@ var _ServiceMethodParamsGenerator = class _ServiceMethodParamsGenerator {
         });
       }
     }
-    const queryParams = ((_e = operation.parameters) == null ? void 0 : _e.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 || __spreadValues({}, param), this.config),
         hasQuestionToken: !param.required
       });
     });
@@ -2596,19 +2851,16 @@ var _ServiceMethodParamsGenerator = class _ServiceMethodParamsGenerator {
     }
     return "any";
   }
+  /** `schema` arrives ref-resolved from the normalizer (formData/urlEncoded schema). */
   convertObjectToSingleParams(schema) {
     var _a;
     const params = [];
-    let resolvedSchema = schema;
-    if (schema == null ? void 0 : schema.$ref) {
-      resolvedSchema = this.parser.resolveReference(schema.$ref);
-    }
-    Object.entries((_a = resolvedSchema == null ? void 0 : resolvedSchema.properties) != null ? _a : {}).forEach(([key, value]) => {
+    Object.entries((_a = schema == null ? void 0 : schema.properties) != null ? _a : {}).forEach(([key, value]) => {
       var _a2;
       params.push({
         name: key,
         type: getTypeScriptType(value, this.config, value.nullable),
-        hasQuestionToken: !((_a2 = resolvedSchema == null ? void 0 : resolvedSchema.required) == null ? void 0 : _a2.includes(key))
+        hasQuestionToken: !((_a2 = schema == null ? void 0 : schema.required) == null ? void 0 : _a2.includes(key))
       });
     });
     return params;
@@ -2619,12 +2871,12 @@ var ServiceMethodParamsGenerator = _ServiceMethodParamsGenerator;
 
 // src/lib/generators/service/service-method/service-method-overloads.generator.ts
 var _ServiceMethodOverloadsGenerator = class _ServiceMethodOverloadsGenerator {
-  constructor(config, parser) {
+  constructor(config) {
     __publicField(this, "config");
     __publicField(this, "paramsGenerator");
     __publicField(this, "responseDataType", "any");
     this.config = config;
-    this.paramsGenerator = new ServiceMethodParamsGenerator(config, parser);
+    this.paramsGenerator = new ServiceMethodParamsGenerator(config);
   }
   generateMethodOverloads(operation, requestObject) {
     const observeTypes = [
@@ -2633,7 +2885,7 @@ var _ServiceMethodOverloadsGenerator = class _ServiceMethodOverloadsGenerator {
       "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) {
@@ -2711,37 +2963,21 @@ var _ServiceMethodOverloadsGenerator = class _ServiceMethodOverloadsGenerator {
     }
     return `RequestOptions<'${responseType}', ${additionalTypeParameters.join(", ")}>`;
   }
-  determineResponseTypeForOperation(operation) {
-    var _a;
-    const successResponses = [
-      "200",
-      "201",
-      "202",
-      "204",
-      "206"
-    ];
-    for (const statusCode of successResponses) {
-      const response = (_a = operation.responses) == null ? void 0 : _a[statusCode];
-      if (!response) continue;
-      return getResponseTypeFromResponse(response);
-    }
-    return "json";
-  }
 };
 __name(_ServiceMethodOverloadsGenerator, "ServiceMethodOverloadsGenerator");
 var ServiceMethodOverloadsGenerator = _ServiceMethodOverloadsGenerator;
 
 // src/lib/generators/service/service-method.generator.ts
 var _ServiceMethodGenerator = class _ServiceMethodGenerator {
-  constructor(config, parser) {
+  constructor(config) {
     __publicField(this, "config");
     __publicField(this, "bodyGenerator");
     __publicField(this, "overloadsGenerator");
     __publicField(this, "paramsGenerator");
     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);
@@ -2801,13 +3037,13 @@ var ServiceMethodGenerator = _ServiceMethodGenerator;
 // src/lib/generators/service/request-params.generator.ts
 var path9 = __toESM(require("path"));
 var _RequestParamsGenerator = class _RequestParamsGenerator {
-  constructor(parser, project, config) {
+  constructor(project, config) {
     __publicField(this, "project");
     __publicField(this, "paramsGenerator");
     __publicField(this, "registry", /* @__PURE__ */ new Map());
     __publicField(this, "usedInterfaceNames", /* @__PURE__ */ new Set());
     this.project = project;
-    this.paramsGenerator = new ServiceMethodParamsGenerator(config, parser);
+    this.paramsGenerator = new ServiceMethodParamsGenerator(config);
   }
   buildRegistry(controllerGroups, getMethodName) {
     Object.entries(controllerGroups).forEach(([controllerName, operations]) => {
@@ -2908,34 +3144,31 @@ var RequestParamsGenerator = _RequestParamsGenerator;
 
 // src/lib/generators/service/service.generator.ts
 var _ServiceGenerator = class _ServiceGenerator {
-  constructor(parser, project, config) {
+  constructor(parser, project, config, onWarning) {
     __publicField(this, "project");
     __publicField(this, "parser");
-    __publicField(this, "spec");
     __publicField(this, "config");
     __publicField(this, "methodGenerator");
     __publicField(this, "requestObjects");
+    __publicField(this, "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);
   }
   generate(outputRoot) {
     return __async(this, null, function* () {
+      var _a;
       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");
+        (_a = this.onWarning) == null ? void 0 : _a.call(this, "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);
       }
@@ -3034,27 +3267,27 @@ var _ServiceGenerator = class _ServiceGenerator {
     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",
@@ -3109,6 +3342,110 @@ var _ServiceIndexGenerator = class _ServiceIndexGenerator {
 __name(_ServiceIndexGenerator, "ServiceIndexGenerator");
 var ServiceIndexGenerator = _ServiceIndexGenerator;
 
+// src/lib/core/config-validation.ts
+var RESPONSE_TYPES = [
+  "json",
+  "blob",
+  "arraybuffer",
+  "text"
+];
+var _ConfigValidationError = class _ConfigValidationError extends Error {
+  constructor(issues) {
+    super(`Invalid ng-openapi configuration:
+${issues.map((issue) => `  - ${issue}`).join("\n")}`);
+    __publicField(this, "issues");
+    this.name = "ConfigValidationError";
+    this.issues = issues;
+  }
+};
+__name(_ConfigValidationError, "ConfigValidationError");
+var ConfigValidationError = _ConfigValidationError;
+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"));
@@ -3117,7 +3454,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 = [
@@ -3126,85 +3463,88 @@ 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");
-function generateFromConfig(config) {
-  return __async(this, null, function* () {
-    var _a, _b;
+function generateFromConfig(_0) {
+  return __async(this, arguments, function* (config, reporter = {}) {
+    var _a, _b, _c, _d, _e, _f;
+    const startedAt = Date.now();
+    validateGeneratorConfig(config);
     validateInput(config.input);
     const outputPath = config.output;
     const generateServices = (_a = config.options.generateServices) != null ? _a : true;
-    const inputType = isUrl(config.input) ? "URL" : "file";
+    const warnings = [];
+    const onWarning = /* @__PURE__ */ __name((message) => {
+      var _a2;
+      warnings.push(message);
+      (_a2 = reporter.onWarning) == null ? void 0 : _a2.call(reporter, message);
+    }, "onWarning");
     if (!fs3.existsSync(outputPath)) {
       fs3.mkdirSync(outputPath, {
         recursive: true
       });
     }
-    try {
-      const project = new import_ts_morph7.Project({
-        compilerOptions: __spreadValues({
-          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 = yield SwaggerParser.create(config.input, config);
-      const typeGenerator = new TypeGenerator(swaggerParser, project, config, outputPath);
-      yield 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);
-        yield serviceGenerator.generate(outputPath);
-        const indexGenerator = new ServiceIndexGenerator(project);
-        indexGenerator.generateIndex(outputPath);
-        console.log(`\u2705 Angular services generated`);
-      }
-      if ((_b = config.plugins) == null ? void 0 : _b.length) {
-        for (const plugin of config.plugins) {
-          const generatorClass = plugin;
-          const pluginGenerator = new generatorClass(swaggerParser, project, config);
-          yield pluginGenerator.generate(outputPath);
-        }
-        console.log(`\u2705 Plugins are generated`);
+    const project = new import_ts_morph10.Project({
+      compilerOptions: __spreadValues({
+        declaration: true,
+        target: import_ts_morph10.ScriptTarget.ES2022,
+        module: import_ts_morph10.ModuleKind.Preserve,
+        strict: true
+      }, config.compilerOptions)
+    });
+    (_b = reporter.onPhase) == null ? void 0 : _b.call(reporter, "processing-spec");
+    const swaggerParser = yield 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);
+    yield typeGenerator.generate();
+    (_c = reporter.onPhase) == null ? void 0 : _c.call(reporter, "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 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 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);
+      yield serviceGenerator.generate(outputPath);
+      const indexGenerator = new ServiceIndexGenerator(project);
+      indexGenerator.generateIndex(outputPath);
+      (_d = reporter.onPhase) == null ? void 0 : _d.call(reporter, "services-generated");
+    }
+    if ((_e = config.plugins) == null ? void 0 : _e.length) {
+      for (const plugin of config.plugins) {
+        const pluginGenerator = new plugin({
+          spec: normalizedSpec,
+          project,
+          config,
+          onWarning
+        });
+        yield pluginGenerator.generate(outputPath);
       }
-      throw error;
+      (_f = reporter.onPhase) == null ? void 0 : _f.call(reporter, "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");
@@ -3212,17 +3552,29 @@ __name(generateFromConfig, "generateFromConfig");
 0 && (module.exports = {
   BASE_INTERCEPTOR_HEADER_COMMENT,
   CONTENT_TYPES,
+  ConfigValidationError,
   HTTP_RESOURCE_GENERATOR_HEADER_COMMENT,
   MAIN_INDEX_GENERATOR_HEADER_COMMENT,
+  NgOpenApiError,
   PROVIDER_GENERATOR_HEADER_COMMENT,
   REQUEST_PARAMS_GENERATOR_HEADER_COMMENT,
   SERVICE_GENERATOR_HEADER_COMMENT,
   SERVICE_INDEX_GENERATOR_HEADER_COMMENT,
+  SpecLoadError,
+  SpecParseError,
   SwaggerParser,
   TYPE_GENERATOR_HEADER_COMMENT,
   ZOD_PLUGIN_GENERATOR_HEADER_COMMENT,
   ZOD_PLUGIN_INDEX_GENERATOR_HEADER_COMMENT,
   camelCase,
+  defineConfig,
+  emitDefaultHeadersMerge,
+  emitHeaders,
+  emitQueryParams,
+  emitResponseTypeOption,
+  emitSignalAwareQueryParams,
+  emitUrlConstruction,
+  emitUrlExpression,
   escapeString,
   extractPaths,
   generateFromConfig,
@@ -3238,11 +3590,18 @@ __name(generateFromConfig, "generateFromConfig");
   inferResponseTypeFromContentType,
   isDataTypeInterface,
   isPrimitiveType,
+  isUrl,
+  joinRequestOptionEntries,
   kebabCase,
+  normalizeSchema,
+  normalizeSpec,
   nullableType,
   pascalCase,
   pascalCaseForEnums,
+  plainParamValue,
   screamingSnakeCase,
+  signalAwareParamValue,
+  validateGeneratorConfig,
   validateInput
 });
 //# sourceMappingURL=index.js.map