@ng-openapi/http-resource 0.0.34-pr-85-testing-fd2f80a.0 → 0.0.34-pr-103-refactored-d262edf.0

package/index.js

@@ -4,330 +4,6 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
 // src/lib/http-resource.generator.ts
 import { Scope } from "ts-morph";
 
-// ../../shared/src/utils/string.utils.ts
-function camelCase(str2) {
-  return str2.replace(/[-_.\s]+(.)?/g, (_, char) => char ? char.toUpperCase() : "").replace(/^./, (char) => char.toLowerCase());
-}
-__name(camelCase, "camelCase");
-function pascalCase(str2) {
-  return str2.replace(/[-_.\s]+(.)?/g, (_, char) => char ? char.toUpperCase() : "").replace(/^./, (char) => char.toUpperCase());
-}
-__name(pascalCase, "pascalCase");
-function pascalCaseForEnums(str2) {
-  return str2.replace(/[^a-zA-Z0-9]/g, "_").replace(/(?:^|_)([a-z])/g, (_, char) => char.toUpperCase()).replace(/^([0-9])/, "_$1");
-}
-__name(pascalCaseForEnums, "pascalCaseForEnums");
-
-// ../../shared/src/utils/type.utils.ts
-function getTypeScriptType(schemaOrType, config, formatOrNullable, isNullable, context = "type") {
-  let schema2;
-  let nullable;
-  if (typeof schemaOrType === "string" || schemaOrType === void 0) {
-    schema2 = {
-      type: schemaOrType,
-      format: typeof formatOrNullable === "string" ? formatOrNullable : void 0
-    };
-    nullable = typeof formatOrNullable === "boolean" ? formatOrNullable : isNullable;
-  } else {
-    schema2 = schemaOrType;
-    nullable = typeof formatOrNullable === "boolean" ? formatOrNullable : schema2.nullable;
-  }
-  if (!schema2) {
-    return "any";
-  }
-  if (schema2.$ref) {
-    const refName = schema2.$ref.split("/").pop();
-    return nullableType(pascalCaseForEnums(refName), nullable);
-  }
-  if (schema2.type === "array") {
-    const itemType = schema2.items ? getTypeScriptType(schema2.items, config, void 0, void 0, context) : "unknown";
-    return nullable ? `(Array<${itemType}> | null)` : `Array<${itemType}>`;
-  }
-  switch (schema2.type) {
-    case "string":
-      if (schema2.enum) {
-        return schema2.enum.map((value) => typeof value === "string" ? `'${escapeString(value)}'` : String(value)).join(" | ");
-      }
-      if (schema2.format === "date" || schema2.format === "date-time") {
-        const dateType = config.options.dateType === "Date" ? "Date" : "string";
-        return nullableType(dateType, nullable);
-      }
-      if (schema2.format === "binary") {
-        const binaryType = context === "type" ? "Blob" : "File";
-        return nullableType(binaryType, nullable);
-      }
-      if (schema2.format === "uuid" || schema2.format === "email" || schema2.format === "uri" || schema2.format === "hostname" || schema2.format === "ipv4" || schema2.format === "ipv6") {
-        return nullableType("string", nullable);
-      }
-      return nullableType("string", nullable);
-    case "number":
-    case "integer":
-      return nullableType("number", nullable);
-    case "boolean":
-      return nullableType("boolean", nullable);
-    case "object":
-      return nullableType(context === "type" ? "Record<string, any>" : "any", nullable);
-    case "null":
-      return "null";
-    default:
-      if (Array.isArray(schema2.type)) {
-        const types = schema2.type.map((t) => getTypeScriptType(t, config, void 0, void 0, context));
-        return nullableType(types.join(" | "), nullable);
-      }
-      return nullableType("any", nullable);
-  }
-}
-__name(getTypeScriptType, "getTypeScriptType");
-function nullableType(type2, isNullable) {
-  return type2 + (isNullable ? " | null" : "");
-}
-__name(nullableType, "nullableType");
-function escapeString(str2) {
-  return str2.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
-}
-__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");
-
-// ../../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(([path3, pathItem]) => {
-    methods.forEach((method) => {
-      if (pathItem[method]) {
-        const operation = pathItem[method];
-        paths.push({
-          path: path3,
-          method: method.toUpperCase(),
-          operationId: operation.operationId,
-          summary: operation.summary,
-          description: operation.description,
-          tags: operation.tags || [],
-          parameters: parseParameters(operation.parameters || [], pathItem.parameters || []),
-          requestBody: operation.requestBody,
-          responses: operation.responses || {}
-        });
-      }
-    });
-  });
-  return paths;
-}
-__name(extractPaths, "extractPaths");
-function parseParameters(operationParams, pathParams) {
-  const allParams = [
-    ...pathParams,
-    ...operationParams
-  ];
-  return allParams.map((param) => ({
-    name: param.name,
-    in: param.in,
-    required: param.required || param.in === "path",
-    schema: param.schema,
-    type: param.type,
-    format: param.format,
-    description: param.description
-  }));
-}
-__name(parseParameters, "parseParameters");
-
-// ../../shared/src/utils/functions/extract-swagger-response-type.ts
-function getResponseTypeFromResponse(response, responseTypeMapping) {
-  const content = response.content || {};
-  if (Object.keys(content).length === 0) {
-    return "json";
-  }
-  const responseTypes = [];
-  for (const [contentType, mediaType] of Object.entries(content)) {
-    const schema2 = mediaType?.schema;
-    const mapping = responseTypeMapping || {};
-    if (mapping[contentType]) {
-      responseTypes.push({
-        type: mapping[contentType],
-        priority: 1,
-        contentType
-      });
-      continue;
-    }
-    if (schema2?.format === "binary" || schema2?.format === "byte") {
-      responseTypes.push({
-        type: "blob",
-        priority: 2,
-        contentType
-      });
-      continue;
-    }
-    if (schema2?.type === "string" && (schema2?.format === "binary" || schema2?.format === "byte")) {
-      responseTypes.push({
-        type: "blob",
-        priority: 2,
-        contentType
-      });
-      continue;
-    }
-    const isPrimitive = isPrimitiveType(schema2);
-    const inferredType = inferResponseTypeFromContentType(contentType);
-    let priority = 3;
-    let finalType = inferredType;
-    if (inferredType === "json" && isPrimitive) {
-      finalType = "text";
-      priority = 2;
-    } else if (inferredType === "json") {
-      priority = 2;
-    }
-    responseTypes.push({
-      type: finalType,
-      priority,
-      contentType,
-      isPrimitive
-    });
-  }
-  responseTypes.sort((a, b) => a.priority - b.priority);
-  return responseTypes[0]?.type || "json";
-}
-__name(getResponseTypeFromResponse, "getResponseTypeFromResponse");
-function isPrimitiveType(schema2) {
-  if (!schema2) return false;
-  const primitiveTypes = [
-    "string",
-    "number",
-    "integer",
-    "boolean"
-  ];
-  if (primitiveTypes.includes(schema2.type)) {
-    return true;
-  }
-  if (schema2.type === "array") {
-    return false;
-  }
-  if (schema2.type === "object" || schema2.properties) {
-    return false;
-  }
-  if (schema2.$ref) {
-    return false;
-  }
-  if (schema2.allOf || schema2.oneOf || schema2.anyOf) {
-    return false;
-  }
-  return false;
-}
-__name(isPrimitiveType, "isPrimitiveType");
-function inferResponseTypeFromContentType(contentType) {
-  const normalizedType = contentType.split(";")[0].trim().toLowerCase();
-  if (normalizedType.includes("json") || normalizedType === "application/ld+json" || normalizedType === "application/hal+json" || normalizedType === "application/vnd.api+json") {
-    return "json";
-  }
-  if (normalizedType.includes("xml") || normalizedType === "application/soap+xml" || normalizedType === "application/atom+xml" || normalizedType === "application/rss+xml") {
-    return "text";
-  }
-  if (normalizedType.startsWith("text/")) {
-    const binaryTextTypes = [
-      "text/rtf",
-      "text/cache-manifest",
-      "text/vcard",
-      "text/calendar"
-    ];
-    if (binaryTextTypes.includes(normalizedType)) {
-      return "blob";
-    }
-    return "text";
-  }
-  if (normalizedType === "CONTENT_TYPES.FORM_URLENCODED" || normalizedType === "multipart/form-data") {
-    return "text";
-  }
-  if (normalizedType === "application/javascript" || normalizedType === "application/typescript" || normalizedType === "application/css" || normalizedType === "application/yaml" || normalizedType === "application/x-yaml" || normalizedType === "application/toml") {
-    return "text";
-  }
-  if (normalizedType.startsWith("image/") || normalizedType.startsWith("audio/") || normalizedType.startsWith("video/") || normalizedType === "application/pdf" || normalizedType === "application/zip" || normalizedType.includes("octet-stream")) {
-    return "arraybuffer";
-  }
-  return "blob";
-}
-__name(inferResponseTypeFromContentType, "inferResponseTypeFromContentType");
-function getResponseType(response, config) {
-  const responseType = getResponseTypeFromResponse(response);
-  const content = response.content || {};
-  for (const [contentType, mediaType] of Object.entries(content)) {
-    if (mediaType?.schema) {
-      return getTypeScriptType(mediaType.schema, config, mediaType.schema.nullable);
-    }
-  }
-  switch (responseType) {
-    case "blob":
-      return "Blob";
-    case "arraybuffer":
-      return "ArrayBuffer";
-    case "text":
-      return "string";
-    default:
-      return "any";
-  }
-}
-__name(getResponseType, "getResponseType");
-
-// ../../shared/src/config/constants.ts
-var disableLinting = `/* @ts-nocheck */
-/* eslint-disable */
-/* @noformat */
-/* @formatter:off */
-`;
-var authorComment = `/**
-* Generated by ng-openapi
-`;
-var defaultHeaderComment = disableLinting + authorComment;
-var TYPE_GENERATOR_HEADER_COMMENT = defaultHeaderComment + `* Generated TypeScript interfaces from Swagger specification
-* Do not edit this file manually
-*/
-`;
-var SERVICE_INDEX_GENERATOR_HEADER_COMMENT = defaultHeaderComment + `* Generated service exports
-* Do not edit this file manually
-*/
-`;
-var REQUEST_PARAMS_GENERATOR_HEADER_COMMENT = defaultHeaderComment + `* Generated request parameter interfaces
-* Do not edit this file manually
-*/
-`;
-var MAIN_INDEX_GENERATOR_HEADER_COMMENT = defaultHeaderComment + `* Entrypoint for the client
-* Do not edit this file manually
-*/
-`;
-var PROVIDER_GENERATOR_HEADER_COMMENT = defaultHeaderComment + `* Generated provider functions for easy setup
-* Do not edit this file manually
-*/
-`;
-var HTTP_RESOURCE_GENERATOR_HEADER_COMMENT = /* @__PURE__ */ __name((resourceName) => defaultHeaderComment + `* \`httpResource\` is still an experimental feature - NOT PRODUCTION READY
-* Generated Angular service for ${resourceName}
-* Do not edit this file manually
-*/
-`, "HTTP_RESOURCE_GENERATOR_HEADER_COMMENT");
-var ZOD_PLUGIN_INDEX_GENERATOR_HEADER_COMMENT = defaultHeaderComment + `* Generated Zod Schemas exports
-* Do not edit this file manually
-*/
-`;
-
 // ../../../node_modules/js-yaml/dist/js-yaml.mjs
 function isNothing(subject) {
   return typeof subject === "undefined" || subject === null;
@@ -2661,7 +2337,7 @@ function writeScalar(state, string, level, iskey, inblock) {
       case STYLE_FOLDED:
         return ">" + blockHeader(string, state.indent) + dropEndingNewline(indentString(foldString(string, lineWidth), indent));
       case STYLE_DOUBLE:
-        return '"' + escapeString2(string) + '"';
+        return '"' + escapeString(string) + '"';
       default:
         throw new exception("impossible error: invalid scalar style");
     }
@@ -2724,7 +2400,7 @@ function foldLine(line, width) {
   return result.slice(1);
 }
 __name(foldLine, "foldLine");
-function escapeString2(string) {
+function escapeString(string) {
   var result = "";
   var char = 0;
   var escapeSeq;
@@ -2740,7 +2416,7 @@ function escapeString2(string) {
   }
   return result;
 }
-__name(escapeString2, "escapeString");
+__name(escapeString, "escapeString");
 function writeFlowSequence(state, level, object) {
   var _result = "", _tag = state.tag, index, length, value;
   for (index = 0, length = object.length; index < length; index += 1) {
@@ -2965,70 +2641,404 @@ function writeNode(state, level, object, block, compact, iskey, isblockseq) {
       state.dump = tagStr + " " + state.dump;
     }
   }
-  return true;
+  return true;
+}
+__name(writeNode, "writeNode");
+function getDuplicateReferences(object, state) {
+  var objects = [], duplicatesIndexes = [], index, length;
+  inspectNode(object, objects, duplicatesIndexes);
+  for (index = 0, length = duplicatesIndexes.length; index < length; index += 1) {
+    state.duplicates.push(objects[duplicatesIndexes[index]]);
+  }
+  state.usedDuplicates = new Array(length);
+}
+__name(getDuplicateReferences, "getDuplicateReferences");
+function inspectNode(object, objects, duplicatesIndexes) {
+  var objectKeyList, index, length;
+  if (object !== null && typeof object === "object") {
+    index = objects.indexOf(object);
+    if (index !== -1) {
+      if (duplicatesIndexes.indexOf(index) === -1) {
+        duplicatesIndexes.push(index);
+      }
+    } else {
+      objects.push(object);
+      if (Array.isArray(object)) {
+        for (index = 0, length = object.length; index < length; index += 1) {
+          inspectNode(object[index], objects, duplicatesIndexes);
+        }
+      } else {
+        objectKeyList = Object.keys(object);
+        for (index = 0, length = objectKeyList.length; index < length; index += 1) {
+          inspectNode(object[objectKeyList[index]], objects, duplicatesIndexes);
+        }
+      }
+    }
+  }
+}
+__name(inspectNode, "inspectNode");
+function dump$1(input, options) {
+  options = options || {};
+  var state = new State(options);
+  if (!state.noRefs) getDuplicateReferences(input, state);
+  var value = input;
+  if (state.replacer) {
+    value = state.replacer.call({ "": value }, "", value);
+  }
+  if (writeNode(state, 0, value, true, true)) return state.dump + "\n";
+  return "";
+}
+__name(dump$1, "dump$1");
+var dump_1 = dump$1;
+var dumper = {
+  dump: dump_1
+};
+function renamed(from, to) {
+  return function() {
+    throw new Error("Function yaml." + from + " is removed in js-yaml 4. Use yaml." + to + " instead, which is now safe by default.");
+  };
+}
+__name(renamed, "renamed");
+var load = loader.load;
+var loadAll = loader.loadAll;
+var dump = dumper.dump;
+var safeLoad = renamed("safeLoad", "load");
+var safeLoadAll = renamed("safeLoadAll", "loadAll");
+var safeDump = renamed("safeDump", "dump");
+
+// ../../shared/src/utils/string.utils.ts
+function camelCase(str2) {
+  return str2.replace(/[-_.\s]+(.)?/g, (_, char) => char ? char.toUpperCase() : "").replace(/^./, (char) => char.toLowerCase());
+}
+__name(camelCase, "camelCase");
+function pascalCase(str2) {
+  return str2.replace(/[-_.\s]+(.)?/g, (_, char) => char ? char.toUpperCase() : "").replace(/^./, (char) => char.toUpperCase());
+}
+__name(pascalCase, "pascalCase");
+function pascalCaseForEnums(str2) {
+  return str2.replace(/[^a-zA-Z0-9]/g, "_").replace(/(?:^|_)([a-z])/g, (_, char) => char.toUpperCase()).replace(/^([0-9])/, "_$1");
+}
+__name(pascalCaseForEnums, "pascalCaseForEnums");
+
+// ../../shared/src/utils/type.utils.ts
+function getTypeScriptType(schemaOrType, config, formatOrNullable, isNullable, context = "type") {
+  let schema2;
+  let nullable;
+  if (typeof schemaOrType === "string" || schemaOrType === void 0) {
+    schema2 = {
+      type: schemaOrType,
+      format: typeof formatOrNullable === "string" ? formatOrNullable : void 0
+    };
+    nullable = typeof formatOrNullable === "boolean" ? formatOrNullable : isNullable;
+  } else {
+    schema2 = schemaOrType;
+    nullable = typeof formatOrNullable === "boolean" ? formatOrNullable : schema2.nullable;
+  }
+  if (!schema2) {
+    return "any";
+  }
+  if (schema2.$ref) {
+    const refName = schema2.$ref.split("/").pop();
+    return nullableType(pascalCaseForEnums(refName), nullable);
+  }
+  if (schema2.type === "array") {
+    const itemType = schema2.items ? Array.isArray(schema2.items) ? "any" : getTypeScriptType(schema2.items, config, void 0, void 0, context) : "unknown";
+    return nullable ? `(Array<${itemType}> | null)` : `Array<${itemType}>`;
+  }
+  switch (schema2.type) {
+    case "string":
+      if (schema2.enum) {
+        return schema2.enum.map((value) => typeof value === "string" ? `'${escapeString2(value)}'` : String(value)).join(" | ");
+      }
+      if (schema2.format === "date" || schema2.format === "date-time") {
+        const dateType = config.options.dateType === "Date" ? "Date" : "string";
+        return nullableType(dateType, nullable);
+      }
+      if (schema2.format === "binary") {
+        const binaryType = context === "type" ? "Blob" : "File";
+        return nullableType(binaryType, nullable);
+      }
+      if (schema2.format === "uuid" || schema2.format === "email" || schema2.format === "uri" || schema2.format === "hostname" || schema2.format === "ipv4" || schema2.format === "ipv6") {
+        return nullableType("string", nullable);
+      }
+      return nullableType("string", nullable);
+    case "number":
+    case "integer":
+      return nullableType("number", nullable);
+    case "boolean":
+      return nullableType("boolean", nullable);
+    case "object":
+      return nullableType(context === "type" ? "Record<string, any>" : "any", nullable);
+    case "null":
+      return "null";
+    default:
+      if (Array.isArray(schema2.type)) {
+        const types = schema2.type.map((t) => getTypeScriptType(t, config, void 0, void 0, context));
+        return nullableType(types.join(" | "), nullable);
+      }
+      return nullableType("any", nullable);
+  }
+}
+__name(getTypeScriptType, "getTypeScriptType");
+function nullableType(type2, isNullable) {
+  return type2 + (isNullable ? " | null" : "");
+}
+__name(nullableType, "nullableType");
+function escapeString2(str2) {
+  return str2.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+}
+__name(escapeString2, "escapeString");
+
+// ../../shared/src/utils/functions/extract-swagger-response-type.ts
+function getResponseTypeFromResponse(response, responseTypeMapping) {
+  const content = response.content || {};
+  if (Object.keys(content).length === 0) {
+    return "json";
+  }
+  const responseTypes = [];
+  for (const [contentType, mediaType] of Object.entries(content)) {
+    const schema2 = mediaType?.schema;
+    const mapping = responseTypeMapping || {};
+    if (mapping[contentType]) {
+      responseTypes.push({
+        type: mapping[contentType],
+        priority: 1,
+        contentType
+      });
+      continue;
+    }
+    if (schema2?.format === "binary" || schema2?.format === "byte") {
+      responseTypes.push({
+        type: "blob",
+        priority: 2,
+        contentType
+      });
+      continue;
+    }
+    if (schema2?.type === "string" && (schema2?.format === "binary" || schema2?.format === "byte")) {
+      responseTypes.push({
+        type: "blob",
+        priority: 2,
+        contentType
+      });
+      continue;
+    }
+    const isPrimitive = isPrimitiveType(schema2);
+    const inferredType = inferResponseTypeFromContentType(contentType);
+    let priority = 3;
+    let finalType = inferredType;
+    if (inferredType === "json" && isPrimitive) {
+      finalType = "text";
+      priority = 2;
+    } else if (inferredType === "json") {
+      priority = 2;
+    }
+    responseTypes.push({
+      type: finalType,
+      priority,
+      contentType,
+      isPrimitive
+    });
+  }
+  responseTypes.sort((a, b) => a.priority - b.priority);
+  return responseTypes[0]?.type || "json";
 }
-__name(writeNode, "writeNode");
-function getDuplicateReferences(object, state) {
-  var objects = [], duplicatesIndexes = [], index, length;
-  inspectNode(object, objects, duplicatesIndexes);
-  for (index = 0, length = duplicatesIndexes.length; index < length; index += 1) {
-    state.duplicates.push(objects[duplicatesIndexes[index]]);
+__name(getResponseTypeFromResponse, "getResponseTypeFromResponse");
+function isPrimitiveType(schema2) {
+  if (!schema2) return false;
+  const primitiveTypes = [
+    "string",
+    "number",
+    "integer",
+    "boolean"
+  ];
+  if (schema2.type && primitiveTypes.includes(schema2.type)) {
+    return true;
   }
-  state.usedDuplicates = new Array(length);
+  if (schema2.type === "array") {
+    return false;
+  }
+  if (schema2.type === "object" || schema2.properties) {
+    return false;
+  }
+  if (schema2.$ref) {
+    return false;
+  }
+  if (schema2.allOf || schema2.oneOf || schema2.anyOf) {
+    return false;
+  }
+  return false;
 }
-__name(getDuplicateReferences, "getDuplicateReferences");
-function inspectNode(object, objects, duplicatesIndexes) {
-  var objectKeyList, index, length;
-  if (object !== null && typeof object === "object") {
-    index = objects.indexOf(object);
-    if (index !== -1) {
-      if (duplicatesIndexes.indexOf(index) === -1) {
-        duplicatesIndexes.push(index);
-      }
-    } else {
-      objects.push(object);
-      if (Array.isArray(object)) {
-        for (index = 0, length = object.length; index < length; index += 1) {
-          inspectNode(object[index], objects, duplicatesIndexes);
-        }
-      } else {
-        objectKeyList = Object.keys(object);
-        for (index = 0, length = objectKeyList.length; index < length; index += 1) {
-          inspectNode(object[objectKeyList[index]], objects, duplicatesIndexes);
-        }
-      }
+__name(isPrimitiveType, "isPrimitiveType");
+function inferResponseTypeFromContentType(contentType) {
+  const normalizedType = contentType.split(";")[0].trim().toLowerCase();
+  if (normalizedType.includes("json") || normalizedType === "application/ld+json" || normalizedType === "application/hal+json" || normalizedType === "application/vnd.api+json") {
+    return "json";
+  }
+  if (normalizedType.includes("xml") || normalizedType === "application/soap+xml" || normalizedType === "application/atom+xml" || normalizedType === "application/rss+xml") {
+    return "text";
+  }
+  if (normalizedType.startsWith("text/")) {
+    const binaryTextTypes = [
+      "text/rtf",
+      "text/cache-manifest",
+      "text/vcard",
+      "text/calendar"
+    ];
+    if (binaryTextTypes.includes(normalizedType)) {
+      return "blob";
     }
+    return "text";
+  }
+  if (normalizedType === "CONTENT_TYPES.FORM_URLENCODED" || normalizedType === "multipart/form-data") {
+    return "text";
+  }
+  if (normalizedType === "application/javascript" || normalizedType === "application/typescript" || normalizedType === "application/css" || normalizedType === "application/yaml" || normalizedType === "application/x-yaml" || normalizedType === "application/toml") {
+    return "text";
+  }
+  if (normalizedType.startsWith("image/") || normalizedType.startsWith("audio/") || normalizedType.startsWith("video/") || normalizedType === "application/pdf" || normalizedType === "application/zip" || normalizedType.includes("octet-stream")) {
+    return "arraybuffer";
   }
+  return "blob";
 }
-__name(inspectNode, "inspectNode");
-function dump$1(input, options) {
-  options = options || {};
-  var state = new State(options);
-  if (!state.noRefs) getDuplicateReferences(input, state);
-  var value = input;
-  if (state.replacer) {
-    value = state.replacer.call({ "": value }, "", value);
+__name(inferResponseTypeFromContentType, "inferResponseTypeFromContentType");
+function getResponseType(response, config) {
+  const responseType = getResponseTypeFromResponse(response);
+  const content = response.content || {};
+  for (const [contentType, mediaType] of Object.entries(content)) {
+    if (mediaType?.schema) {
+      return getTypeScriptType(mediaType.schema, config, mediaType.schema.nullable);
+    }
+  }
+  switch (responseType) {
+    case "blob":
+      return "Blob";
+    case "arraybuffer":
+      return "ArrayBuffer";
+    case "text":
+      return "string";
+    default:
+      return "any";
   }
-  if (writeNode(state, 0, value, true, true)) return state.dump + "\n";
-  return "";
 }
-__name(dump$1, "dump$1");
-var dump_1 = dump$1;
-var dumper = {
-  dump: dump_1
-};
-function renamed(from, to) {
-  return function() {
-    throw new Error("Function yaml." + from + " is removed in js-yaml 4. Use yaml." + to + " instead, which is now safe by default.");
-  };
+__name(getResponseType, "getResponseType");
+
+// ../../shared/src/emit/headers.emit.ts
+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(renamed, "renamed");
-var load = loader.load;
-var loadAll = loader.loadAll;
-var dump = dumper.dump;
-var safeLoad = renamed("safeLoad", "load");
-var safeLoadAll = renamed("safeLoadAll", "loadAll");
-var safeDump = renamed("safeDump", "dump");
+__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(path3, pathParams, paramValue = plainParamValue) {
+  let urlExpression = `\`\${this.basePath}${path3}\``;
+  pathParams.forEach((param) => {
+    urlExpression = urlExpression.replace(`{${param.name}}`, `\${${paramValue(camelCase(param.name))}}`);
+  });
+  return urlExpression;
+}
+__name(emitUrlExpression, "emitUrlExpression");
+
+// ../../shared/src/emit/query-params.emit.ts
+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 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");
+
+// ../../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/config/constants.ts
+var disableLinting = `/* @ts-nocheck */
+/* eslint-disable */
+/* @noformat */
+/* @formatter:off */
+`;
+var authorComment = `/**
+* Generated by ng-openapi
+`;
+var defaultHeaderComment = disableLinting + authorComment;
+var TYPE_GENERATOR_HEADER_COMMENT = defaultHeaderComment + `* Generated TypeScript interfaces from Swagger specification
+* Do not edit this file manually
+*/
+`;
+var SERVICE_INDEX_GENERATOR_HEADER_COMMENT = defaultHeaderComment + `* Generated service exports
+* Do not edit this file manually
+*/
+`;
+var REQUEST_PARAMS_GENERATOR_HEADER_COMMENT = defaultHeaderComment + `* Generated request parameter interfaces
+* Do not edit this file manually
+*/
+`;
+var MAIN_INDEX_GENERATOR_HEADER_COMMENT = defaultHeaderComment + `* Entrypoint for the client
+* Do not edit this file manually
+*/
+`;
+var PROVIDER_GENERATOR_HEADER_COMMENT = defaultHeaderComment + `* Generated provider functions for easy setup
+* Do not edit this file manually
+*/
+`;
+var HTTP_RESOURCE_GENERATOR_HEADER_COMMENT = /* @__PURE__ */ __name((resourceName) => defaultHeaderComment + `* \`httpResource\` is still an experimental feature - NOT PRODUCTION READY
+* Generated Angular service for ${resourceName}
+* Do not edit this file manually
+*/
+`, "HTTP_RESOURCE_GENERATOR_HEADER_COMMENT");
+var ZOD_PLUGIN_INDEX_GENERATOR_HEADER_COMMENT = defaultHeaderComment + `* Generated Zod Schemas exports
+* Do not edit this file manually
+*/
+`;
 
 // src/lib/http-resource.generator.ts
 import * as path2 from "path";
@@ -3043,83 +3053,46 @@ var HttpResourceMethodBodyGenerator = class {
     this.config = config;
   }
   generateMethodBody(operation) {
-    const context = this.createGenerationContext(operation);
     const bodyParts = [
-      this.generateHeaders(context),
-      this.generateHttpResource(operation, context)
+      this.generateDefaultHeaders(),
+      this.generateHttpResource(operation)
     ];
     return bodyParts.filter(Boolean).join("\n");
   }
-  createGenerationContext(operation) {
-    return {
-      pathParams: operation.parameters?.filter((p) => p.in === "path") || [],
-      queryParams: operation.parameters?.filter((p) => p.in === "query") || [],
-      responseType: this.determineResponseType(operation)
-    };
-  }
-  generateUrl(operation, context) {
-    let urlExpression = `\`\${this.basePath}${operation.path}\``;
-    if (context.pathParams.length > 0) {
-      context.pathParams.forEach((param) => {
-        urlExpression = urlExpression.replace(`{${param.name}}`, `\${typeof ${camelCase(param.name)} === 'function' ? ${camelCase(param.name)}() : ${camelCase(param.name)}}`);
-      });
-    }
-    return urlExpression;
-  }
-  generateQueryParams(context) {
-    if (context.queryParams.length === 0) {
+  /**
+   * Caller headers flow through `...requestOptions` untouched; a headers
+   * merge is only needed when the config declares default headers.
+   */
+  generateDefaultHeaders() {
+    const customHeaders = this.config.options.customHeaders;
+    if (!customHeaders || Object.keys(customHeaders).length === 0) {
       return "";
     }
-    const paramMappings = context.queryParams.map((param) => `const ${camelCase(param.name)}Value = typeof ${camelCase(param.name)} === 'function' ? ${camelCase(param.name)}() : ${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}`;
-  }
-  generateHeaders(context) {
-    const hasCustomHeaders = this.config.options.customHeaders;
-    let headerCode = `
-let headers: HttpHeaders;
-if (requestOptions?.headers instanceof HttpHeaders) {
-  headers = requestOptions.headers;
-} else {
-  headers = new HttpHeaders(requestOptions?.headers as Record<string, string>);
-}`;
-    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")}`;
-    }
-    return headerCode;
+    return emitDefaultHeadersMerge("requestOptions", customHeaders);
   }
-  generateRequestOptions(operation, context) {
-    const options = [];
-    const url = this.generateUrl(operation, context);
-    options.push(`url: ${url}`);
-    options.push(`method: "GET"`);
-    if (context.queryParams.length > 0) {
-      options.push("params");
+  generateRequestOptions(operation) {
+    const entries = [];
+    const url = emitUrlExpression(operation.path, operation.pathParams, signalAwareParamValue);
+    entries.push(`url: ${url}`);
+    entries.push(`method: "GET"`);
+    entries.push("...requestOptions");
+    if (operation.queryParams.length > 0) {
+      entries.push("params");
     }
-    options.push("headers");
-    if (context.responseType !== "json") {
-      options.push(`responseType: '${context.responseType}' as '${context.responseType}'`);
+    if (this.config.options.customHeaders && Object.keys(this.config.options.customHeaders).length > 0) {
+      entries.push("headers");
     }
-    options.push("context: this.createContextWithClientId(requestOptions?.context)");
-    const formattedOptions = options.filter((opt) => opt && !opt.includes("undefined")).join(",\n  ");
+    entries.push("context: this.createContextWithClientId(requestOptions?.context)");
+    const formattedOptions = joinRequestOptionEntries(entries);
     return `return {
-  ${formattedOptions},
-  ...requestOptions
+  ${formattedOptions}
 }`;
   }
-  generateHttpResource(operation, context) {
-    const resourceOptions = this.generateRequestOptions(operation, context);
-    const queryParams = this.generateQueryParams(context);
+  generateHttpResource(operation) {
+    const resourceOptions = this.generateRequestOptions(operation);
+    const queryParams = emitSignalAwareQueryParams(operation.queryParams);
     let httpResource = "httpResource";
-    switch (context.responseType) {
+    switch (operation.responseType) {
       case "blob":
         httpResource += ".blob";
         break;
@@ -3130,24 +3103,9 @@ ${Object.entries(this.config.options.customHeaders || {}).map(([key, value]) =>
         httpResource += ".text";
         break;
     }
-    return `    return ${httpResource}(() => {${queryParams}
-       ${resourceOptions}
-    }, resourceOptions);`;
-  }
-  determineResponseType(operation) {
-    const successResponses = [
-      "200",
-      "201",
-      "202",
-      "204",
-      "206"
-    ];
-    for (const statusCode of successResponses) {
-      const response = operation.responses?.[statusCode];
-      if (!response) continue;
-      return getResponseTypeFromResponse(response);
-    }
-    return "json";
+    return `return ${httpResource}(() => {${queryParams}
+${resourceOptions}
+}, resourceOptions);`;
   }
 };
 
@@ -3180,9 +3138,10 @@ var HttpResourceMethodParamsGenerator = class {
   }
   generateApiParameters(operation) {
     const params = [];
-    const pathParams = operation.parameters?.filter((p) => p.in === "path") || [];
-    pathParams.forEach((param) => {
-      const paramType = getTypeScriptType(param.schema || param, this.config);
+    operation.pathParams.forEach((param) => {
+      const paramType = getTypeScriptType(param.schema || {
+        ...param
+      }, this.config);
       const signalParamType = param.required ? `Signal<${paramType}>` : `Signal<${paramType} | undefined>`;
       params.push({
         name: camelCase(param.name),
@@ -3190,9 +3149,10 @@ var HttpResourceMethodParamsGenerator = class {
         hasQuestionToken: !param.required
       });
     });
-    const queryParams = operation.parameters?.filter((p) => p.in === "query") || [];
-    queryParams.forEach((param) => {
-      const paramType = getTypeScriptType(param.schema || param, this.config);
+    operation.queryParams.forEach((param) => {
+      const paramType = getTypeScriptType(param.schema || {
+        ...param
+      }, this.config);
       const signalParamType = param.required ? `Signal<${paramType}>` : `Signal<${paramType} | undefined>`;
       params.push({
         name: camelCase(param.name),
@@ -3371,30 +3331,24 @@ var HttpResourceGenerator = class {
     __name(this, "HttpResourceGenerator");
   }
   project;
-  parser;
   spec;
   config;
   methodGenerator;
   indexGenerator;
-  constructor(parser, project, config) {
-    this.config = config;
-    this.project = project;
-    this.parser = parser;
-    this.spec = this.parser.getSpec();
-    this.indexGenerator = new HttpResourceIndexGenerator(project);
-    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 HttpResourceMethodGenerator(config);
+  onWarning;
+  constructor(context) {
+    this.config = context.config;
+    this.project = context.project;
+    this.spec = context.spec;
+    this.onWarning = context.onWarning;
+    this.indexGenerator = new HttpResourceIndexGenerator(context.project);
+    this.methodGenerator = new HttpResourceMethodGenerator(context.config);
   }
   async generate(outputRoot) {
     const outputDir = path2.join(outputRoot, "resources");
-    const paths = extractPaths(this.spec.paths, [
-      "get"
-    ]);
+    const paths = this.spec.operations.filter((operation) => operation.method === "GET");
     if (paths.length === 0) {
-      console.warn("No API paths found in the specification");
+      this.onWarning?.("No API paths found in the specification");
       return;
     }
     const controllerGroups = this.groupPathsByController(paths);