@adsk-platform/httpclient 0.1.0 → 0.1.2

package/_dist/index.umd.js

@@ -1,3787 +0,0 @@
-(function(global2, factory) {
-  typeof exports === "object" && typeof module !== "undefined" ? factory(exports) : typeof define === "function" && define.amd ? define(["exports"], factory) : (global2 = typeof globalThis !== "undefined" ? globalThis : global2 || self, factory(global2.AutodeskCommonHttpClient = {}));
-})(this, (function(exports2) {
-  "use strict";
-  class ParseNodeFactoryRegistry {
-    constructor() {
-      this.jsonContentType = "application/json";
-      this.contentTypeAssociatedFactories = /* @__PURE__ */ new Map();
-    }
-    getValidContentType() {
-      throw new Error("The registry supports multiple content types. Get the registered factory instead.");
-    }
-    /**
-     * Creates a {@link ParseNode} from the given {@link ArrayBuffer} and content type.
-     * @param contentType the content type of the {@link ArrayBuffer}.
-     * @param content the {@link ArrayBuffer} to read from.
-     * @returns a {@link ParseNode} that can deserialize the given {@link ArrayBuffer}.
-     */
-    getRootParseNode(contentType, content) {
-      if (!contentType) {
-        throw new Error("content type cannot be undefined or empty");
-      }
-      if (!content) {
-        throw new Error("content cannot be undefined or empty");
-      }
-      const vendorSpecificContentType = contentType.split(";")[0];
-      let factory = this.contentTypeAssociatedFactories.get(vendorSpecificContentType);
-      if (factory) {
-        return factory.getRootParseNode(vendorSpecificContentType, content);
-      }
-      const cleanedContentType = vendorSpecificContentType.replace(/[^/]+\+/gi, "");
-      factory = this.contentTypeAssociatedFactories.get(cleanedContentType);
-      if (factory) {
-        return factory.getRootParseNode(cleanedContentType, content);
-      }
-      throw new Error(`Content type ${cleanedContentType} does not have a factory registered to be parsed`);
-    }
-    /**
-     * Registers the default deserializer to the registry.
-     * @param type the class of the factory to be registered.
-     * @param backingStoreFactory The backing store factory to use.
-     */
-    registerDefaultDeserializer(type, backingStoreFactory) {
-      if (!type)
-        throw new Error("Type is required");
-      const deserializer = new type(backingStoreFactory);
-      this.contentTypeAssociatedFactories.set(deserializer.getValidContentType(), deserializer);
-    }
-    /**
-     * Deserializes a buffer into a parsable object
-     * @param bufferOrString the value to serialize
-     * @param factory the factory for the model type
-     * @returns the deserialized parsable object
-     */
-    deserializeFromJson(bufferOrString, factory) {
-      return this.deserialize(this.jsonContentType, bufferOrString, factory);
-    }
-    /**
-     * Deserializes a buffer into a collection of parsable object
-     * @param bufferOrString the value to serialize
-     * @param factory the factory for the model type
-     * @returns the deserialized collection of parsable objects
-     */
-    deserializeCollectionFromJson(bufferOrString, factory) {
-      return this.deserializeCollection(this.jsonContentType, bufferOrString, factory);
-    }
-    /**
-     * Deserializes a buffer into a parsable object
-     * @param contentType the content type to serialize to
-     * @param bufferOrString the value to serialize
-     * @param factory the factory for the model type
-     * @returns the deserialized parsable object
-     */
-    deserialize(contentType, bufferOrString, factory) {
-      if (typeof bufferOrString === "string") {
-        bufferOrString = this.getBufferFromString(bufferOrString);
-      }
-      const reader = this.getParseNode(contentType, bufferOrString, factory);
-      return reader.getObjectValue(factory);
-    }
-    /**
-     * Deserializes a buffer into a parsable object
-     * @param contentType the content type to serialize to
-     * @param buffer the value to deserialize
-     * @param factory the factory for the model type
-     * @returns the deserialized parsable object
-     */
-    getParseNode(contentType, buffer, factory) {
-      if (!contentType) {
-        throw new Error("content type cannot be undefined or empty");
-      }
-      if (!buffer) {
-        throw new Error("buffer cannot be undefined");
-      }
-      if (!factory) {
-        throw new Error("factory cannot be undefined");
-      }
-      return this.getRootParseNode(contentType, buffer);
-    }
-    /**
-     * Deserializes a buffer into a collection of parsable object
-     * @param contentType the content type to serialize to
-     * @param bufferOrString the value to serialize
-     * @param factory the factory for the model type
-     * @returns the deserialized collection of parsable objects
-     */
-    deserializeCollection(contentType, bufferOrString, factory) {
-      if (typeof bufferOrString === "string") {
-        bufferOrString = this.getBufferFromString(bufferOrString);
-      }
-      const reader = this.getParseNode(contentType, bufferOrString, factory);
-      return reader.getCollectionOfObjectValues(factory);
-    }
-    /**
-     * Deserializes a buffer into a a collection of parsable object
-     * @param value the string to get a buffer from
-     * @returns the ArrayBuffer representation of the string
-     */
-    getBufferFromString(value) {
-      const encoder = new TextEncoder();
-      return encoder.encode(value).buffer;
-    }
-  }
-  class ParseNodeProxyFactory {
-    getValidContentType() {
-      return this._concrete.getValidContentType();
-    }
-    /**
-     * Creates a new proxy factory that wraps the specified concrete factory while composing the before and after callbacks.
-     * @param _concrete the concrete factory to wrap
-     * @param _onBefore the callback to invoke before the deserialization of any model object.
-     * @param _onAfter the callback to invoke after the deserialization of any model object.
-     */
-    constructor(_concrete, _onBefore, _onAfter) {
-      this._concrete = _concrete;
-      this._onBefore = _onBefore;
-      this._onAfter = _onAfter;
-      if (!_concrete) {
-        throw new Error("_concrete cannot be undefined");
-      }
-    }
-    getRootParseNode(contentType, content) {
-      const node = this._concrete.getRootParseNode(contentType, content);
-      const originalBefore = node.onBeforeAssignFieldValues;
-      const originalAfter = node.onAfterAssignFieldValues;
-      node.onBeforeAssignFieldValues = (value) => {
-        if (this._onBefore)
-          this._onBefore(value);
-        if (originalBefore)
-          originalBefore(value);
-      };
-      node.onAfterAssignFieldValues = (value) => {
-        if (this._onAfter)
-          this._onAfter(value);
-        if (originalAfter)
-          originalAfter(value);
-      };
-      return node;
-    }
-  }
-  class SerializationWriterFactoryRegistry {
-    constructor() {
-      this.jsonContentType = "application/json";
-      this.contentTypeAssociatedFactories = /* @__PURE__ */ new Map();
-    }
-    getValidContentType() {
-      throw new Error("The registry supports multiple content types. Get the registered factory instead.");
-    }
-    getSerializationWriter(contentType) {
-      if (!contentType) {
-        throw new Error("content type cannot be undefined or empty");
-      }
-      const vendorSpecificContentType = contentType.split(";")[0];
-      let factory = this.contentTypeAssociatedFactories.get(vendorSpecificContentType);
-      if (factory) {
-        return factory.getSerializationWriter(vendorSpecificContentType);
-      }
-      const cleanedContentType = vendorSpecificContentType.replace(/[^/]+\+/gi, "");
-      factory = this.contentTypeAssociatedFactories.get(cleanedContentType);
-      if (factory) {
-        return factory.getSerializationWriter(cleanedContentType);
-      }
-      throw new Error(`Content type ${cleanedContentType} does not have a factory registered to be serialized`);
-    }
-    /**
-     * Registers the default serializer to the registry.
-     * @param type the class of the factory to be registered.
-     */
-    registerDefaultSerializer(type) {
-      if (!type)
-        throw new Error("Type is required");
-      const serializer = new type();
-      this.contentTypeAssociatedFactories.set(serializer.getValidContentType(), serializer);
-    }
-    /**
-     * Serializes a parsable object into a buffer
-     * @param value the value to serialize
-     * @param serializationFunction the serialization function for the model type
-     * @returns a buffer containing the serialized value
-     */
-    serializeToJson(value, serializationFunction) {
-      return this.serialize(this.jsonContentType, value, serializationFunction);
-    }
-    /**
-     * Serializes a parsable object into a string representation
-     * @param value the value to serialize
-     * @param serializationFunction the serialization function for the model type
-     * @returns a string representing the serialized value
-     */
-    serializeToJsonAsString(value, serializationFunction) {
-      return this.serializeToString(this.jsonContentType, value, serializationFunction);
-    }
-    /**
-     * Serializes a collection of parsable objects into a buffer
-     * @param values the value to serialize
-     * @param serializationFunction the serialization function for the model type
-     * @returns a string representing the serialized value
-     */
-    serializeCollectionToJson(values, serializationFunction) {
-      return this.serializeCollection(this.jsonContentType, values, serializationFunction);
-    }
-    /**
-     * Serializes a collection of parsable objects into a string representation
-     * @param values the value to serialize
-     * @param serializationFunction the serialization function for the model type
-     * @returns a string representing the serialized value
-     */
-    serializeCollectionToJsonAsString(values, serializationFunction) {
-      return this.serializeCollectionToString(this.jsonContentType, values, serializationFunction);
-    }
-    /**
-     * Serializes a parsable object into a buffer
-     * @param contentType the content type to serialize to
-     * @param value the value to serialize
-     * @param serializationFunction the serialization function for the model type
-     * @returns a buffer containing the serialized value
-     */
-    serialize(contentType, value, serializationFunction) {
-      const writer = this.getSerializationFactoryWriter(contentType, value, serializationFunction);
-      writer.writeObjectValue(void 0, value, serializationFunction);
-      return writer.getSerializedContent();
-    }
-    /**
-     * Serializes a parsable object into a string representation
-     * @param contentType the content type to serialize to
-     * @param value the value to serialize
-     * @param serializationFunction the serialization function for the model type
-     * @returns a string representing the serialized value
-     */
-    serializeToString(contentType, value, serializationFunction) {
-      const buffer = this.serialize(contentType, value, serializationFunction);
-      return this.getStringValueFromBuffer(buffer);
-    }
-    /**
-     * Serializes a collection of parsable objects into a buffer
-     * @param contentType the content type to serialize to
-     * @param values the value to serialize
-     * @param serializationFunction the serialization function for the model type
-     * @returns a string representing the serialized value
-     */
-    serializeCollection(contentType, values, serializationFunction) {
-      const writer = this.getSerializationFactoryWriter(contentType, values, serializationFunction);
-      writer.writeCollectionOfObjectValues(void 0, values, serializationFunction);
-      return writer.getSerializedContent();
-    }
-    /**
-     * Serializes a collection of parsable objects into a string representation
-     * @param contentType the content type to serialize to
-     * @param values the value to serialize
-     * @param serializationFunction the serialization function for the model type
-     * @returns a string representing the serialized value
-     */
-    serializeCollectionToString(contentType, values, serializationFunction) {
-      const buffer = this.serializeCollection(contentType, values, serializationFunction);
-      return this.getStringValueFromBuffer(buffer);
-    }
-    /**
-     * Gets a serialization writer for a given content type
-     * @param contentType the content type to serialize to
-     * @param value the value to serialize
-     * @param serializationFunction the serialization function for the model type
-     * @returns the serialization writer for the given content type
-     */
-    getSerializationFactoryWriter(contentType, value, serializationFunction) {
-      if (!contentType) {
-        throw new Error("content type cannot be undefined or empty");
-      }
-      if (!value) {
-        throw new Error("value cannot be undefined");
-      }
-      if (!serializationFunction) {
-        throw new Error("serializationFunction cannot be undefined");
-      }
-      return this.getSerializationWriter(contentType);
-    }
-    /**
-     * Gets a string value from a buffer
-     * @param buffer the buffer to get a string from
-     * @returns the string representation of the buffer
-     */
-    getStringValueFromBuffer(buffer) {
-      const decoder = new TextDecoder();
-      return decoder.decode(buffer);
-    }
-  }
-  class SerializationWriterProxyFactory {
-    getValidContentType() {
-      return this._concrete.getValidContentType();
-    }
-    /**
-     * Creates a new proxy factory that wraps the specified concrete factory while composing the before and after callbacks.
-     * @param _concrete the concrete factory to wrap
-     * @param _onBefore the callback to invoke before the serialization of any model object.
-     * @param _onAfter the callback to invoke after the serialization of any model object.
-     * @param _onStart the callback to invoke when the serialization of a model object starts
-     */
-    constructor(_concrete, _onBefore, _onAfter, _onStart) {
-      this._concrete = _concrete;
-      this._onBefore = _onBefore;
-      this._onAfter = _onAfter;
-      this._onStart = _onStart;
-      if (!_concrete) {
-        throw new Error("_concrete cannot be undefined");
-      }
-    }
-    getSerializationWriter(contentType) {
-      const writer = this._concrete.getSerializationWriter(contentType);
-      const originalBefore = writer.onBeforeObjectSerialization;
-      const originalAfter = writer.onAfterObjectSerialization;
-      const originalStart = writer.onStartObjectSerialization;
-      writer.onBeforeObjectSerialization = (value) => {
-        if (this._onBefore)
-          this._onBefore(value);
-        if (originalBefore)
-          originalBefore(value);
-      };
-      writer.onAfterObjectSerialization = (value) => {
-        if (this._onAfter)
-          this._onAfter(value);
-        if (originalAfter)
-          originalAfter(value);
-      };
-      writer.onStartObjectSerialization = (value, writer_) => {
-        if (this._onStart)
-          this._onStart(value, writer_);
-        if (originalStart)
-          originalStart(value, writer_);
-      };
-      return writer;
-    }
-  }
-  class BackingStoreParseNodeFactory extends ParseNodeProxyFactory {
-    /**
-     * Initializes a new instance of the BackingStoreParseNodeFactory class given the concrete implementation.
-     * @param concrete the concrete implementation of the ParseNodeFactory
-     */
-    constructor(concrete) {
-      super(concrete, (value) => {
-        const backedModel = value;
-        if (backedModel === null || backedModel === void 0 ? void 0 : backedModel.backingStore) {
-          backedModel.backingStore.initializationCompleted = false;
-        }
-      }, (value) => {
-        const backedModel = value;
-        if (backedModel === null || backedModel === void 0 ? void 0 : backedModel.backingStore) {
-          backedModel.backingStore.initializationCompleted = true;
-        }
-      });
-    }
-  }
-  class BackingStoreSerializationWriterProxyFactory extends SerializationWriterProxyFactory {
-    /**
-     * Initializes a new instance of the BackingStoreSerializationWriterProxyFactory class given a concrete implementation of SerializationWriterFactory.
-     * @param concrete a concrete implementation of SerializationWriterFactory to wrap.
-     */
-    constructor(concrete) {
-      super(concrete, (value) => {
-        const backedModel = value;
-        if (backedModel === null || backedModel === void 0 ? void 0 : backedModel.backingStore) {
-          backedModel.backingStore.returnOnlyChangedValues = true;
-        }
-      }, (value) => {
-        const backedModel = value;
-        if (backedModel === null || backedModel === void 0 ? void 0 : backedModel.backingStore) {
-          backedModel.backingStore.returnOnlyChangedValues = false;
-          backedModel.backingStore.initializationCompleted = true;
-        }
-      }, (value, writer) => {
-        const backedModel = value;
-        if (backedModel === null || backedModel === void 0 ? void 0 : backedModel.backingStore) {
-          const keys = backedModel.backingStore.enumerateKeysForValuesChangedToNull();
-          for (const key of keys) {
-            writer.writeNullValue(key);
-          }
-        }
-      });
-    }
-  }
-  const createGuid = () => [gen(2), gen(1), gen(1), gen(1), gen(3)].join("-");
-  const gen = (count) => {
-    let out = "";
-    for (let i = 0; i < count; i++) {
-      out += ((1 + Math.random()) * 65536 | 0).toString(16).substring(1);
-    }
-    return out;
-  };
-  const inNodeEnv = () => {
-    try {
-      return !!Buffer && !!process;
-    } catch (err) {
-      return !(err instanceof ReferenceError);
-    }
-  };
-  class InMemoryBackingStore {
-    constructor() {
-      this.subscriptions = /* @__PURE__ */ new Map();
-      this.store = /* @__PURE__ */ new Map();
-      this.returnOnlyChangedValues = false;
-      this._initializationCompleted = true;
-    }
-    get(key) {
-      const wrapper = this.store.get(key);
-      if (wrapper && (this.returnOnlyChangedValues && wrapper.changed || !this.returnOnlyChangedValues)) {
-        return wrapper.value;
-      }
-      return void 0;
-    }
-    set(key, value) {
-      const oldValueWrapper = this.store.get(key);
-      const oldValue = oldValueWrapper === null || oldValueWrapper === void 0 ? void 0 : oldValueWrapper.value;
-      if (oldValueWrapper) {
-        oldValueWrapper.value = value;
-        oldValueWrapper.changed = this.initializationCompleted;
-      } else {
-        this.store.set(key, {
-          changed: this.initializationCompleted,
-          value
-        });
-      }
-      this.subscriptions.forEach((sub) => {
-        sub(key, oldValue, value);
-      });
-    }
-    enumerate() {
-      let filterableArray = [...this.store.entries()];
-      if (this.returnOnlyChangedValues) {
-        filterableArray = filterableArray.filter(([_, v]) => v.changed);
-      }
-      return filterableArray.map(([key, value]) => {
-        return { key, value };
-      });
-    }
-    enumerateKeysForValuesChangedToNull() {
-      const keys = [];
-      for (const [key, entry] of this.store) {
-        if (entry.changed && !entry.value) {
-          keys.push(key);
-        }
-      }
-      return keys;
-    }
-    subscribe(callback, subscriptionId) {
-      if (!callback) {
-        throw new Error("callback cannot be undefined");
-      }
-      subscriptionId = subscriptionId !== null && subscriptionId !== void 0 ? subscriptionId : createGuid();
-      this.subscriptions.set(subscriptionId, callback);
-      return subscriptionId;
-    }
-    unsubscribe(subscriptionId) {
-      this.subscriptions.delete(subscriptionId);
-    }
-    clear() {
-      this.store.clear();
-    }
-    set initializationCompleted(value) {
-      this._initializationCompleted = value;
-      this.store.forEach((v) => {
-        v.changed = !value;
-      });
-    }
-    get initializationCompleted() {
-      return this._initializationCompleted;
-    }
-  }
-  class InMemoryBackingStoreFactory {
-    createBackingStore() {
-      return new InMemoryBackingStore();
-    }
-  }
-  function enableBackingStoreForSerializationWriterFactory(serializationWriterFactoryRegistry, parseNodeFactoryRegistry, original) {
-    if (!original)
-      throw new Error("Original must be specified");
-    let result = original;
-    if (original instanceof SerializationWriterFactoryRegistry) {
-      enableBackingStoreForSerializationRegistry(original);
-    } else {
-      result = new BackingStoreSerializationWriterProxyFactory(original);
-    }
-    enableBackingStoreForSerializationRegistry(serializationWriterFactoryRegistry);
-    enableBackingStoreForParseNodeRegistry(parseNodeFactoryRegistry);
-    return result;
-  }
-  function enableBackingStoreForParseNodeFactory(parseNodeFactoryRegistry, original) {
-    if (!original)
-      throw new Error("Original must be specified");
-    let result = original;
-    if (original instanceof ParseNodeFactoryRegistry) {
-      enableBackingStoreForParseNodeRegistry(original);
-    } else {
-      result = new BackingStoreParseNodeFactory(original);
-    }
-    enableBackingStoreForParseNodeRegistry(parseNodeFactoryRegistry);
-    return result;
-  }
-  function enableBackingStoreForParseNodeRegistry(registry) {
-    for (const [k, v] of registry.contentTypeAssociatedFactories) {
-      if (!(v instanceof BackingStoreParseNodeFactory || v instanceof ParseNodeFactoryRegistry)) {
-        registry.contentTypeAssociatedFactories.set(k, new BackingStoreParseNodeFactory(v));
-      }
-    }
-  }
-  function enableBackingStoreForSerializationRegistry(registry) {
-    for (const [k, v] of registry.contentTypeAssociatedFactories) {
-      if (!(v instanceof BackingStoreSerializationWriterProxyFactory || v instanceof SerializationWriterFactoryRegistry)) {
-        registry.contentTypeAssociatedFactories.set(k, new BackingStoreSerializationWriterProxyFactory(v));
-      }
-    }
-  }
-  var _globalThis = typeof globalThis === "object" ? globalThis : typeof self === "object" ? self : typeof window === "object" ? window : typeof global === "object" ? global : {};
-  var VERSION = "1.9.0";
-  var re = /^(\d+)\.(\d+)\.(\d+)(-(.+))?$/;
-  function _makeCompatibilityCheck(ownVersion) {
-    var acceptedVersions = /* @__PURE__ */ new Set([ownVersion]);
-    var rejectedVersions = /* @__PURE__ */ new Set();
-    var myVersionMatch = ownVersion.match(re);
-    if (!myVersionMatch) {
-      return function() {
-        return false;
-      };
-    }
-    var ownVersionParsed = {
-      major: +myVersionMatch[1],
-      minor: +myVersionMatch[2],
-      patch: +myVersionMatch[3],
-      prerelease: myVersionMatch[4]
-    };
-    if (ownVersionParsed.prerelease != null) {
-      return function isExactmatch(globalVersion) {
-        return globalVersion === ownVersion;
-      };
-    }
-    function _reject(v) {
-      rejectedVersions.add(v);
-      return false;
-    }
-    function _accept(v) {
-      acceptedVersions.add(v);
-      return true;
-    }
-    return function isCompatible2(globalVersion) {
-      if (acceptedVersions.has(globalVersion)) {
-        return true;
-      }
-      if (rejectedVersions.has(globalVersion)) {
-        return false;
-      }
-      var globalVersionMatch = globalVersion.match(re);
-      if (!globalVersionMatch) {
-        return _reject(globalVersion);
-      }
-      var globalVersionParsed = {
-        major: +globalVersionMatch[1],
-        minor: +globalVersionMatch[2],
-        patch: +globalVersionMatch[3],
-        prerelease: globalVersionMatch[4]
-      };
-      if (globalVersionParsed.prerelease != null) {
-        return _reject(globalVersion);
-      }
-      if (ownVersionParsed.major !== globalVersionParsed.major) {
-        return _reject(globalVersion);
-      }
-      if (ownVersionParsed.major === 0) {
-        if (ownVersionParsed.minor === globalVersionParsed.minor && ownVersionParsed.patch <= globalVersionParsed.patch) {
-          return _accept(globalVersion);
-        }
-        return _reject(globalVersion);
-      }
-      if (ownVersionParsed.minor <= globalVersionParsed.minor) {
-        return _accept(globalVersion);
-      }
-      return _reject(globalVersion);
-    };
-  }
-  var isCompatible = _makeCompatibilityCheck(VERSION);
-  var major = VERSION.split(".")[0];
-  var GLOBAL_OPENTELEMETRY_API_KEY = Symbol.for("opentelemetry.js.api." + major);
-  var _global = _globalThis;
-  function registerGlobal(type, instance, diag, allowOverride) {
-    var _a;
-    if (allowOverride === void 0) {
-      allowOverride = false;
-    }
-    var api = _global[GLOBAL_OPENTELEMETRY_API_KEY] = (_a = _global[GLOBAL_OPENTELEMETRY_API_KEY]) !== null && _a !== void 0 ? _a : {
-      version: VERSION
-    };
-    if (!allowOverride && api[type]) {
-      var err = new Error("@opentelemetry/api: Attempted duplicate registration of API: " + type);
-      diag.error(err.stack || err.message);
-      return false;
-    }
-    if (api.version !== VERSION) {
-      var err = new Error("@opentelemetry/api: Registration of version v" + api.version + " for " + type + " does not match previously registered API v" + VERSION);
-      diag.error(err.stack || err.message);
-      return false;
-    }
-    api[type] = instance;
-    diag.debug("@opentelemetry/api: Registered a global for " + type + " v" + VERSION + ".");
-    return true;
-  }
-  function getGlobal(type) {
-    var _a, _b;
-    var globalVersion = (_a = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _a === void 0 ? void 0 : _a.version;
-    if (!globalVersion || !isCompatible(globalVersion)) {
-      return;
-    }
-    return (_b = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _b === void 0 ? void 0 : _b[type];
-  }
-  function unregisterGlobal(type, diag) {
-    diag.debug("@opentelemetry/api: Unregistering a global for " + type + " v" + VERSION + ".");
-    var api = _global[GLOBAL_OPENTELEMETRY_API_KEY];
-    if (api) {
-      delete api[type];
-    }
-  }
-  var __read$4 = function(o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-      while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    } catch (error) {
-      e = { error };
-    } finally {
-      try {
-        if (r && !r.done && (m = i["return"])) m.call(i);
-      } finally {
-        if (e) throw e.error;
-      }
-    }
-    return ar;
-  };
-  var __spreadArray$3 = function(to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-      if (ar || !(i in from)) {
-        if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-        ar[i] = from[i];
-      }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-  };
-  var DiagComponentLogger = (
-    /** @class */
-    (function() {
-      function DiagComponentLogger2(props) {
-        this._namespace = props.namespace || "DiagComponentLogger";
-      }
-      DiagComponentLogger2.prototype.debug = function() {
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-          args[_i] = arguments[_i];
-        }
-        return logProxy("debug", this._namespace, args);
-      };
-      DiagComponentLogger2.prototype.error = function() {
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-          args[_i] = arguments[_i];
-        }
-        return logProxy("error", this._namespace, args);
-      };
-      DiagComponentLogger2.prototype.info = function() {
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-          args[_i] = arguments[_i];
-        }
-        return logProxy("info", this._namespace, args);
-      };
-      DiagComponentLogger2.prototype.warn = function() {
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-          args[_i] = arguments[_i];
-        }
-        return logProxy("warn", this._namespace, args);
-      };
-      DiagComponentLogger2.prototype.verbose = function() {
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-          args[_i] = arguments[_i];
-        }
-        return logProxy("verbose", this._namespace, args);
-      };
-      return DiagComponentLogger2;
-    })()
-  );
-  function logProxy(funcName, namespace, args) {
-    var logger = getGlobal("diag");
-    if (!logger) {
-      return;
-    }
-    args.unshift(namespace);
-    return logger[funcName].apply(logger, __spreadArray$3([], __read$4(args), false));
-  }
-  var DiagLogLevel;
-  (function(DiagLogLevel2) {
-    DiagLogLevel2[DiagLogLevel2["NONE"] = 0] = "NONE";
-    DiagLogLevel2[DiagLogLevel2["ERROR"] = 30] = "ERROR";
-    DiagLogLevel2[DiagLogLevel2["WARN"] = 50] = "WARN";
-    DiagLogLevel2[DiagLogLevel2["INFO"] = 60] = "INFO";
-    DiagLogLevel2[DiagLogLevel2["DEBUG"] = 70] = "DEBUG";
-    DiagLogLevel2[DiagLogLevel2["VERBOSE"] = 80] = "VERBOSE";
-    DiagLogLevel2[DiagLogLevel2["ALL"] = 9999] = "ALL";
-  })(DiagLogLevel || (DiagLogLevel = {}));
-  function createLogLevelDiagLogger(maxLevel, logger) {
-    if (maxLevel < DiagLogLevel.NONE) {
-      maxLevel = DiagLogLevel.NONE;
-    } else if (maxLevel > DiagLogLevel.ALL) {
-      maxLevel = DiagLogLevel.ALL;
-    }
-    logger = logger || {};
-    function _filterFunc(funcName, theLevel) {
-      var theFunc = logger[funcName];
-      if (typeof theFunc === "function" && maxLevel >= theLevel) {
-        return theFunc.bind(logger);
-      }
-      return function() {
-      };
-    }
-    return {
-      error: _filterFunc("error", DiagLogLevel.ERROR),
-      warn: _filterFunc("warn", DiagLogLevel.WARN),
-      info: _filterFunc("info", DiagLogLevel.INFO),
-      debug: _filterFunc("debug", DiagLogLevel.DEBUG),
-      verbose: _filterFunc("verbose", DiagLogLevel.VERBOSE)
-    };
-  }
-  var __read$3 = function(o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-      while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    } catch (error) {
-      e = { error };
-    } finally {
-      try {
-        if (r && !r.done && (m = i["return"])) m.call(i);
-      } finally {
-        if (e) throw e.error;
-      }
-    }
-    return ar;
-  };
-  var __spreadArray$2 = function(to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-      if (ar || !(i in from)) {
-        if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-        ar[i] = from[i];
-      }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-  };
-  var API_NAME$4 = "diag";
-  var DiagAPI = (
-    /** @class */
-    (function() {
-      function DiagAPI2() {
-        function _logProxy(funcName) {
-          return function() {
-            var args = [];
-            for (var _i = 0; _i < arguments.length; _i++) {
-              args[_i] = arguments[_i];
-            }
-            var logger = getGlobal("diag");
-            if (!logger)
-              return;
-            return logger[funcName].apply(logger, __spreadArray$2([], __read$3(args), false));
-          };
-        }
-        var self2 = this;
-        var setLogger = function(logger, optionsOrLogLevel) {
-          var _a, _b, _c;
-          if (optionsOrLogLevel === void 0) {
-            optionsOrLogLevel = { logLevel: DiagLogLevel.INFO };
-          }
-          if (logger === self2) {
-            var err = new Error("Cannot use diag as the logger for itself. Please use a DiagLogger implementation like ConsoleDiagLogger or a custom implementation");
-            self2.error((_a = err.stack) !== null && _a !== void 0 ? _a : err.message);
-            return false;
-          }
-          if (typeof optionsOrLogLevel === "number") {
-            optionsOrLogLevel = {
-              logLevel: optionsOrLogLevel
-            };
-          }
-          var oldLogger = getGlobal("diag");
-          var newLogger = createLogLevelDiagLogger((_b = optionsOrLogLevel.logLevel) !== null && _b !== void 0 ? _b : DiagLogLevel.INFO, logger);
-          if (oldLogger && !optionsOrLogLevel.suppressOverrideMessage) {
-            var stack = (_c = new Error().stack) !== null && _c !== void 0 ? _c : "<failed to generate stacktrace>";
-            oldLogger.warn("Current logger will be overwritten from " + stack);
-            newLogger.warn("Current logger will overwrite one already registered from " + stack);
-          }
-          return registerGlobal("diag", newLogger, self2, true);
-        };
-        self2.setLogger = setLogger;
-        self2.disable = function() {
-          unregisterGlobal(API_NAME$4, self2);
-        };
-        self2.createComponentLogger = function(options) {
-          return new DiagComponentLogger(options);
-        };
-        self2.verbose = _logProxy("verbose");
-        self2.debug = _logProxy("debug");
-        self2.info = _logProxy("info");
-        self2.warn = _logProxy("warn");
-        self2.error = _logProxy("error");
-      }
-      DiagAPI2.instance = function() {
-        if (!this._instance) {
-          this._instance = new DiagAPI2();
-        }
-        return this._instance;
-      };
-      return DiagAPI2;
-    })()
-  );
-  var __read$2 = function(o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-      while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    } catch (error) {
-      e = { error };
-    } finally {
-      try {
-        if (r && !r.done && (m = i["return"])) m.call(i);
-      } finally {
-        if (e) throw e.error;
-      }
-    }
-    return ar;
-  };
-  var __values = function(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-    if (m) return m.call(o);
-    if (o && typeof o.length === "number") return {
-      next: function() {
-        if (o && i >= o.length) o = void 0;
-        return { value: o && o[i++], done: !o };
-      }
-    };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-  };
-  var BaggageImpl = (
-    /** @class */
-    (function() {
-      function BaggageImpl2(entries) {
-        this._entries = entries ? new Map(entries) : /* @__PURE__ */ new Map();
-      }
-      BaggageImpl2.prototype.getEntry = function(key) {
-        var entry = this._entries.get(key);
-        if (!entry) {
-          return void 0;
-        }
-        return Object.assign({}, entry);
-      };
-      BaggageImpl2.prototype.getAllEntries = function() {
-        return Array.from(this._entries.entries()).map(function(_a) {
-          var _b = __read$2(_a, 2), k = _b[0], v = _b[1];
-          return [k, v];
-        });
-      };
-      BaggageImpl2.prototype.setEntry = function(key, entry) {
-        var newBaggage = new BaggageImpl2(this._entries);
-        newBaggage._entries.set(key, entry);
-        return newBaggage;
-      };
-      BaggageImpl2.prototype.removeEntry = function(key) {
-        var newBaggage = new BaggageImpl2(this._entries);
-        newBaggage._entries.delete(key);
-        return newBaggage;
-      };
-      BaggageImpl2.prototype.removeEntries = function() {
-        var e_1, _a;
-        var keys = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-          keys[_i] = arguments[_i];
-        }
-        var newBaggage = new BaggageImpl2(this._entries);
-        try {
-          for (var keys_1 = __values(keys), keys_1_1 = keys_1.next(); !keys_1_1.done; keys_1_1 = keys_1.next()) {
-            var key = keys_1_1.value;
-            newBaggage._entries.delete(key);
-          }
-        } catch (e_1_1) {
-          e_1 = { error: e_1_1 };
-        } finally {
-          try {
-            if (keys_1_1 && !keys_1_1.done && (_a = keys_1.return)) _a.call(keys_1);
-          } finally {
-            if (e_1) throw e_1.error;
-          }
-        }
-        return newBaggage;
-      };
-      BaggageImpl2.prototype.clear = function() {
-        return new BaggageImpl2();
-      };
-      return BaggageImpl2;
-    })()
-  );
-  DiagAPI.instance();
-  function createBaggage(entries) {
-    if (entries === void 0) {
-      entries = {};
-    }
-    return new BaggageImpl(new Map(Object.entries(entries)));
-  }
-  function createContextKey(description) {
-    return Symbol.for(description);
-  }
-  var BaseContext = (
-    /** @class */
-    /* @__PURE__ */ (function() {
-      function BaseContext2(parentContext) {
-        var self2 = this;
-        self2._currentContext = parentContext ? new Map(parentContext) : /* @__PURE__ */ new Map();
-        self2.getValue = function(key) {
-          return self2._currentContext.get(key);
-        };
-        self2.setValue = function(key, value) {
-          var context = new BaseContext2(self2._currentContext);
-          context._currentContext.set(key, value);
-          return context;
-        };
-        self2.deleteValue = function(key) {
-          var context = new BaseContext2(self2._currentContext);
-          context._currentContext.delete(key);
-          return context;
-        };
-      }
-      return BaseContext2;
-    })()
-  );
-  var ROOT_CONTEXT = new BaseContext();
-  var __extends = /* @__PURE__ */ (function() {
-    var extendStatics = function(d, b) {
-      extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
-        d2.__proto__ = b2;
-      } || function(d2, b2) {
-        for (var p in b2) if (Object.prototype.hasOwnProperty.call(b2, p)) d2[p] = b2[p];
-      };
-      return extendStatics(d, b);
-    };
-    return function(d, b) {
-      if (typeof b !== "function" && b !== null)
-        throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-      extendStatics(d, b);
-      function __() {
-        this.constructor = d;
-      }
-      d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-  })();
-  var NoopMeter = (
-    /** @class */
-    (function() {
-      function NoopMeter2() {
-      }
-      NoopMeter2.prototype.createGauge = function(_name, _options) {
-        return NOOP_GAUGE_METRIC;
-      };
-      NoopMeter2.prototype.createHistogram = function(_name, _options) {
-        return NOOP_HISTOGRAM_METRIC;
-      };
-      NoopMeter2.prototype.createCounter = function(_name, _options) {
-        return NOOP_COUNTER_METRIC;
-      };
-      NoopMeter2.prototype.createUpDownCounter = function(_name, _options) {
-        return NOOP_UP_DOWN_COUNTER_METRIC;
-      };
-      NoopMeter2.prototype.createObservableGauge = function(_name, _options) {
-        return NOOP_OBSERVABLE_GAUGE_METRIC;
-      };
-      NoopMeter2.prototype.createObservableCounter = function(_name, _options) {
-        return NOOP_OBSERVABLE_COUNTER_METRIC;
-      };
-      NoopMeter2.prototype.createObservableUpDownCounter = function(_name, _options) {
-        return NOOP_OBSERVABLE_UP_DOWN_COUNTER_METRIC;
-      };
-      NoopMeter2.prototype.addBatchObservableCallback = function(_callback, _observables) {
-      };
-      NoopMeter2.prototype.removeBatchObservableCallback = function(_callback) {
-      };
-      return NoopMeter2;
-    })()
-  );
-  var NoopMetric = (
-    /** @class */
-    /* @__PURE__ */ (function() {
-      function NoopMetric2() {
-      }
-      return NoopMetric2;
-    })()
-  );
-  var NoopCounterMetric = (
-    /** @class */
-    (function(_super) {
-      __extends(NoopCounterMetric2, _super);
-      function NoopCounterMetric2() {
-        return _super !== null && _super.apply(this, arguments) || this;
-      }
-      NoopCounterMetric2.prototype.add = function(_value, _attributes) {
-      };
-      return NoopCounterMetric2;
-    })(NoopMetric)
-  );
-  var NoopUpDownCounterMetric = (
-    /** @class */
-    (function(_super) {
-      __extends(NoopUpDownCounterMetric2, _super);
-      function NoopUpDownCounterMetric2() {
-        return _super !== null && _super.apply(this, arguments) || this;
-      }
-      NoopUpDownCounterMetric2.prototype.add = function(_value, _attributes) {
-      };
-      return NoopUpDownCounterMetric2;
-    })(NoopMetric)
-  );
-  var NoopGaugeMetric = (
-    /** @class */
-    (function(_super) {
-      __extends(NoopGaugeMetric2, _super);
-      function NoopGaugeMetric2() {
-        return _super !== null && _super.apply(this, arguments) || this;
-      }
-      NoopGaugeMetric2.prototype.record = function(_value, _attributes) {
-      };
-      return NoopGaugeMetric2;
-    })(NoopMetric)
-  );
-  var NoopHistogramMetric = (
-    /** @class */
-    (function(_super) {
-      __extends(NoopHistogramMetric2, _super);
-      function NoopHistogramMetric2() {
-        return _super !== null && _super.apply(this, arguments) || this;
-      }
-      NoopHistogramMetric2.prototype.record = function(_value, _attributes) {
-      };
-      return NoopHistogramMetric2;
-    })(NoopMetric)
-  );
-  var NoopObservableMetric = (
-    /** @class */
-    (function() {
-      function NoopObservableMetric2() {
-      }
-      NoopObservableMetric2.prototype.addCallback = function(_callback) {
-      };
-      NoopObservableMetric2.prototype.removeCallback = function(_callback) {
-      };
-      return NoopObservableMetric2;
-    })()
-  );
-  var NoopObservableCounterMetric = (
-    /** @class */
-    (function(_super) {
-      __extends(NoopObservableCounterMetric2, _super);
-      function NoopObservableCounterMetric2() {
-        return _super !== null && _super.apply(this, arguments) || this;
-      }
-      return NoopObservableCounterMetric2;
-    })(NoopObservableMetric)
-  );
-  var NoopObservableGaugeMetric = (
-    /** @class */
-    (function(_super) {
-      __extends(NoopObservableGaugeMetric2, _super);
-      function NoopObservableGaugeMetric2() {
-        return _super !== null && _super.apply(this, arguments) || this;
-      }
-      return NoopObservableGaugeMetric2;
-    })(NoopObservableMetric)
-  );
-  var NoopObservableUpDownCounterMetric = (
-    /** @class */
-    (function(_super) {
-      __extends(NoopObservableUpDownCounterMetric2, _super);
-      function NoopObservableUpDownCounterMetric2() {
-        return _super !== null && _super.apply(this, arguments) || this;
-      }
-      return NoopObservableUpDownCounterMetric2;
-    })(NoopObservableMetric)
-  );
-  var NOOP_METER = new NoopMeter();
-  var NOOP_COUNTER_METRIC = new NoopCounterMetric();
-  var NOOP_GAUGE_METRIC = new NoopGaugeMetric();
-  var NOOP_HISTOGRAM_METRIC = new NoopHistogramMetric();
-  var NOOP_UP_DOWN_COUNTER_METRIC = new NoopUpDownCounterMetric();
-  var NOOP_OBSERVABLE_COUNTER_METRIC = new NoopObservableCounterMetric();
-  var NOOP_OBSERVABLE_GAUGE_METRIC = new NoopObservableGaugeMetric();
-  var NOOP_OBSERVABLE_UP_DOWN_COUNTER_METRIC = new NoopObservableUpDownCounterMetric();
-  var defaultTextMapGetter = {
-    get: function(carrier, key) {
-      if (carrier == null) {
-        return void 0;
-      }
-      return carrier[key];
-    },
-    keys: function(carrier) {
-      if (carrier == null) {
-        return [];
-      }
-      return Object.keys(carrier);
-    }
-  };
-  var defaultTextMapSetter = {
-    set: function(carrier, key, value) {
-      if (carrier == null) {
-        return;
-      }
-      carrier[key] = value;
-    }
-  };
-  var __read$1 = function(o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-      while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    } catch (error) {
-      e = { error };
-    } finally {
-      try {
-        if (r && !r.done && (m = i["return"])) m.call(i);
-      } finally {
-        if (e) throw e.error;
-      }
-    }
-    return ar;
-  };
-  var __spreadArray$1 = function(to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-      if (ar || !(i in from)) {
-        if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-        ar[i] = from[i];
-      }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-  };
-  var NoopContextManager = (
-    /** @class */
-    (function() {
-      function NoopContextManager2() {
-      }
-      NoopContextManager2.prototype.active = function() {
-        return ROOT_CONTEXT;
-      };
-      NoopContextManager2.prototype.with = function(_context, fn, thisArg) {
-        var args = [];
-        for (var _i = 3; _i < arguments.length; _i++) {
-          args[_i - 3] = arguments[_i];
-        }
-        return fn.call.apply(fn, __spreadArray$1([thisArg], __read$1(args), false));
-      };
-      NoopContextManager2.prototype.bind = function(_context, target) {
-        return target;
-      };
-      NoopContextManager2.prototype.enable = function() {
-        return this;
-      };
-      NoopContextManager2.prototype.disable = function() {
-        return this;
-      };
-      return NoopContextManager2;
-    })()
-  );
-  var __read = function(o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-      while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    } catch (error) {
-      e = { error };
-    } finally {
-      try {
-        if (r && !r.done && (m = i["return"])) m.call(i);
-      } finally {
-        if (e) throw e.error;
-      }
-    }
-    return ar;
-  };
-  var __spreadArray = function(to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-      if (ar || !(i in from)) {
-        if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-        ar[i] = from[i];
-      }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-  };
-  var API_NAME$3 = "context";
-  var NOOP_CONTEXT_MANAGER = new NoopContextManager();
-  var ContextAPI = (
-    /** @class */
-    (function() {
-      function ContextAPI2() {
-      }
-      ContextAPI2.getInstance = function() {
-        if (!this._instance) {
-          this._instance = new ContextAPI2();
-        }
-        return this._instance;
-      };
-      ContextAPI2.prototype.setGlobalContextManager = function(contextManager) {
-        return registerGlobal(API_NAME$3, contextManager, DiagAPI.instance());
-      };
-      ContextAPI2.prototype.active = function() {
-        return this._getContextManager().active();
-      };
-      ContextAPI2.prototype.with = function(context, fn, thisArg) {
-        var _a;
-        var args = [];
-        for (var _i = 3; _i < arguments.length; _i++) {
-          args[_i - 3] = arguments[_i];
-        }
-        return (_a = this._getContextManager()).with.apply(_a, __spreadArray([context, fn, thisArg], __read(args), false));
-      };
-      ContextAPI2.prototype.bind = function(context, target) {
-        return this._getContextManager().bind(context, target);
-      };
-      ContextAPI2.prototype._getContextManager = function() {
-        return getGlobal(API_NAME$3) || NOOP_CONTEXT_MANAGER;
-      };
-      ContextAPI2.prototype.disable = function() {
-        this._getContextManager().disable();
-        unregisterGlobal(API_NAME$3, DiagAPI.instance());
-      };
-      return ContextAPI2;
-    })()
-  );
-  var TraceFlags;
-  (function(TraceFlags2) {
-    TraceFlags2[TraceFlags2["NONE"] = 0] = "NONE";
-    TraceFlags2[TraceFlags2["SAMPLED"] = 1] = "SAMPLED";
-  })(TraceFlags || (TraceFlags = {}));
-  var INVALID_SPANID = "0000000000000000";
-  var INVALID_TRACEID = "00000000000000000000000000000000";
-  var INVALID_SPAN_CONTEXT = {
-    traceId: INVALID_TRACEID,
-    spanId: INVALID_SPANID,
-    traceFlags: TraceFlags.NONE
-  };
-  var NonRecordingSpan = (
-    /** @class */
-    (function() {
-      function NonRecordingSpan2(_spanContext) {
-        if (_spanContext === void 0) {
-          _spanContext = INVALID_SPAN_CONTEXT;
-        }
-        this._spanContext = _spanContext;
-      }
-      NonRecordingSpan2.prototype.spanContext = function() {
-        return this._spanContext;
-      };
-      NonRecordingSpan2.prototype.setAttribute = function(_key, _value) {
-        return this;
-      };
-      NonRecordingSpan2.prototype.setAttributes = function(_attributes) {
-        return this;
-      };
-      NonRecordingSpan2.prototype.addEvent = function(_name, _attributes) {
-        return this;
-      };
-      NonRecordingSpan2.prototype.addLink = function(_link) {
-        return this;
-      };
-      NonRecordingSpan2.prototype.addLinks = function(_links) {
-        return this;
-      };
-      NonRecordingSpan2.prototype.setStatus = function(_status) {
-        return this;
-      };
-      NonRecordingSpan2.prototype.updateName = function(_name) {
-        return this;
-      };
-      NonRecordingSpan2.prototype.end = function(_endTime) {
-      };
-      NonRecordingSpan2.prototype.isRecording = function() {
-        return false;
-      };
-      NonRecordingSpan2.prototype.recordException = function(_exception, _time) {
-      };
-      return NonRecordingSpan2;
-    })()
-  );
-  var SPAN_KEY = createContextKey("OpenTelemetry Context Key SPAN");
-  function getSpan(context) {
-    return context.getValue(SPAN_KEY) || void 0;
-  }
-  function getActiveSpan() {
-    return getSpan(ContextAPI.getInstance().active());
-  }
-  function setSpan(context, span) {
-    return context.setValue(SPAN_KEY, span);
-  }
-  function deleteSpan(context) {
-    return context.deleteValue(SPAN_KEY);
-  }
-  function setSpanContext(context, spanContext) {
-    return setSpan(context, new NonRecordingSpan(spanContext));
-  }
-  function getSpanContext(context) {
-    var _a;
-    return (_a = getSpan(context)) === null || _a === void 0 ? void 0 : _a.spanContext();
-  }
-  var VALID_TRACEID_REGEX = /^([0-9a-f]{32})$/i;
-  var VALID_SPANID_REGEX = /^[0-9a-f]{16}$/i;
-  function isValidTraceId(traceId) {
-    return VALID_TRACEID_REGEX.test(traceId) && traceId !== INVALID_TRACEID;
-  }
-  function isValidSpanId(spanId) {
-    return VALID_SPANID_REGEX.test(spanId) && spanId !== INVALID_SPANID;
-  }
-  function isSpanContextValid(spanContext) {
-    return isValidTraceId(spanContext.traceId) && isValidSpanId(spanContext.spanId);
-  }
-  function wrapSpanContext(spanContext) {
-    return new NonRecordingSpan(spanContext);
-  }
-  var contextApi = ContextAPI.getInstance();
-  var NoopTracer = (
-    /** @class */
-    (function() {
-      function NoopTracer2() {
-      }
-      NoopTracer2.prototype.startSpan = function(name, options, context) {
-        if (context === void 0) {
-          context = contextApi.active();
-        }
-        var root = Boolean(options === null || options === void 0 ? void 0 : options.root);
-        if (root) {
-          return new NonRecordingSpan();
-        }
-        var parentFromContext = context && getSpanContext(context);
-        if (isSpanContext(parentFromContext) && isSpanContextValid(parentFromContext)) {
-          return new NonRecordingSpan(parentFromContext);
-        } else {
-          return new NonRecordingSpan();
-        }
-      };
-      NoopTracer2.prototype.startActiveSpan = function(name, arg2, arg3, arg4) {
-        var opts;
-        var ctx;
-        var fn;
-        if (arguments.length < 2) {
-          return;
-        } else if (arguments.length === 2) {
-          fn = arg2;
-        } else if (arguments.length === 3) {
-          opts = arg2;
-          fn = arg3;
-        } else {
-          opts = arg2;
-          ctx = arg3;
-          fn = arg4;
-        }
-        var parentContext = ctx !== null && ctx !== void 0 ? ctx : contextApi.active();
-        var span = this.startSpan(name, opts, parentContext);
-        var contextWithSpanSet = setSpan(parentContext, span);
-        return contextApi.with(contextWithSpanSet, fn, void 0, span);
-      };
-      return NoopTracer2;
-    })()
-  );
-  function isSpanContext(spanContext) {
-    return typeof spanContext === "object" && typeof spanContext["spanId"] === "string" && typeof spanContext["traceId"] === "string" && typeof spanContext["traceFlags"] === "number";
-  }
-  var NOOP_TRACER = new NoopTracer();
-  var ProxyTracer = (
-    /** @class */
-    (function() {
-      function ProxyTracer2(_provider, name, version, options) {
-        this._provider = _provider;
-        this.name = name;
-        this.version = version;
-        this.options = options;
-      }
-      ProxyTracer2.prototype.startSpan = function(name, options, context) {
-        return this._getTracer().startSpan(name, options, context);
-      };
-      ProxyTracer2.prototype.startActiveSpan = function(_name, _options, _context, _fn) {
-        var tracer = this._getTracer();
-        return Reflect.apply(tracer.startActiveSpan, tracer, arguments);
-      };
-      ProxyTracer2.prototype._getTracer = function() {
-        if (this._delegate) {
-          return this._delegate;
-        }
-        var tracer = this._provider.getDelegateTracer(this.name, this.version, this.options);
-        if (!tracer) {
-          return NOOP_TRACER;
-        }
-        this._delegate = tracer;
-        return this._delegate;
-      };
-      return ProxyTracer2;
-    })()
-  );
-  var NoopTracerProvider = (
-    /** @class */
-    (function() {
-      function NoopTracerProvider2() {
-      }
-      NoopTracerProvider2.prototype.getTracer = function(_name, _version, _options) {
-        return new NoopTracer();
-      };
-      return NoopTracerProvider2;
-    })()
-  );
-  var NOOP_TRACER_PROVIDER = new NoopTracerProvider();
-  var ProxyTracerProvider = (
-    /** @class */
-    (function() {
-      function ProxyTracerProvider2() {
-      }
-      ProxyTracerProvider2.prototype.getTracer = function(name, version, options) {
-        var _a;
-        return (_a = this.getDelegateTracer(name, version, options)) !== null && _a !== void 0 ? _a : new ProxyTracer(this, name, version, options);
-      };
-      ProxyTracerProvider2.prototype.getDelegate = function() {
-        var _a;
-        return (_a = this._delegate) !== null && _a !== void 0 ? _a : NOOP_TRACER_PROVIDER;
-      };
-      ProxyTracerProvider2.prototype.setDelegate = function(delegate) {
-        this._delegate = delegate;
-      };
-      ProxyTracerProvider2.prototype.getDelegateTracer = function(name, version, options) {
-        var _a;
-        return (_a = this._delegate) === null || _a === void 0 ? void 0 : _a.getTracer(name, version, options);
-      };
-      return ProxyTracerProvider2;
-    })()
-  );
-  var SpanStatusCode;
-  (function(SpanStatusCode2) {
-    SpanStatusCode2[SpanStatusCode2["UNSET"] = 0] = "UNSET";
-    SpanStatusCode2[SpanStatusCode2["OK"] = 1] = "OK";
-    SpanStatusCode2[SpanStatusCode2["ERROR"] = 2] = "ERROR";
-  })(SpanStatusCode || (SpanStatusCode = {}));
-  ContextAPI.getInstance();
-  DiagAPI.instance();
-  var NoopMeterProvider = (
-    /** @class */
-    (function() {
-      function NoopMeterProvider2() {
-      }
-      NoopMeterProvider2.prototype.getMeter = function(_name, _version, _options) {
-        return NOOP_METER;
-      };
-      return NoopMeterProvider2;
-    })()
-  );
-  var NOOP_METER_PROVIDER = new NoopMeterProvider();
-  var API_NAME$2 = "metrics";
-  var MetricsAPI = (
-    /** @class */
-    (function() {
-      function MetricsAPI2() {
-      }
-      MetricsAPI2.getInstance = function() {
-        if (!this._instance) {
-          this._instance = new MetricsAPI2();
-        }
-        return this._instance;
-      };
-      MetricsAPI2.prototype.setGlobalMeterProvider = function(provider) {
-        return registerGlobal(API_NAME$2, provider, DiagAPI.instance());
-      };
-      MetricsAPI2.prototype.getMeterProvider = function() {
-        return getGlobal(API_NAME$2) || NOOP_METER_PROVIDER;
-      };
-      MetricsAPI2.prototype.getMeter = function(name, version, options) {
-        return this.getMeterProvider().getMeter(name, version, options);
-      };
-      MetricsAPI2.prototype.disable = function() {
-        unregisterGlobal(API_NAME$2, DiagAPI.instance());
-      };
-      return MetricsAPI2;
-    })()
-  );
-  MetricsAPI.getInstance();
-  var NoopTextMapPropagator = (
-    /** @class */
-    (function() {
-      function NoopTextMapPropagator2() {
-      }
-      NoopTextMapPropagator2.prototype.inject = function(_context, _carrier) {
-      };
-      NoopTextMapPropagator2.prototype.extract = function(context, _carrier) {
-        return context;
-      };
-      NoopTextMapPropagator2.prototype.fields = function() {
-        return [];
-      };
-      return NoopTextMapPropagator2;
-    })()
-  );
-  var BAGGAGE_KEY = createContextKey("OpenTelemetry Baggage Key");
-  function getBaggage(context) {
-    return context.getValue(BAGGAGE_KEY) || void 0;
-  }
-  function getActiveBaggage() {
-    return getBaggage(ContextAPI.getInstance().active());
-  }
-  function setBaggage(context, baggage) {
-    return context.setValue(BAGGAGE_KEY, baggage);
-  }
-  function deleteBaggage(context) {
-    return context.deleteValue(BAGGAGE_KEY);
-  }
-  var API_NAME$1 = "propagation";
-  var NOOP_TEXT_MAP_PROPAGATOR = new NoopTextMapPropagator();
-  var PropagationAPI = (
-    /** @class */
-    (function() {
-      function PropagationAPI2() {
-        this.createBaggage = createBaggage;
-        this.getBaggage = getBaggage;
-        this.getActiveBaggage = getActiveBaggage;
-        this.setBaggage = setBaggage;
-        this.deleteBaggage = deleteBaggage;
-      }
-      PropagationAPI2.getInstance = function() {
-        if (!this._instance) {
-          this._instance = new PropagationAPI2();
-        }
-        return this._instance;
-      };
-      PropagationAPI2.prototype.setGlobalPropagator = function(propagator) {
-        return registerGlobal(API_NAME$1, propagator, DiagAPI.instance());
-      };
-      PropagationAPI2.prototype.inject = function(context, carrier, setter) {
-        if (setter === void 0) {
-          setter = defaultTextMapSetter;
-        }
-        return this._getGlobalPropagator().inject(context, carrier, setter);
-      };
-      PropagationAPI2.prototype.extract = function(context, carrier, getter) {
-        if (getter === void 0) {
-          getter = defaultTextMapGetter;
-        }
-        return this._getGlobalPropagator().extract(context, carrier, getter);
-      };
-      PropagationAPI2.prototype.fields = function() {
-        return this._getGlobalPropagator().fields();
-      };
-      PropagationAPI2.prototype.disable = function() {
-        unregisterGlobal(API_NAME$1, DiagAPI.instance());
-      };
-      PropagationAPI2.prototype._getGlobalPropagator = function() {
-        return getGlobal(API_NAME$1) || NOOP_TEXT_MAP_PROPAGATOR;
-      };
-      return PropagationAPI2;
-    })()
-  );
-  PropagationAPI.getInstance();
-  var API_NAME = "trace";
-  var TraceAPI = (
-    /** @class */
-    (function() {
-      function TraceAPI2() {
-        this._proxyTracerProvider = new ProxyTracerProvider();
-        this.wrapSpanContext = wrapSpanContext;
-        this.isSpanContextValid = isSpanContextValid;
-        this.deleteSpan = deleteSpan;
-        this.getSpan = getSpan;
-        this.getActiveSpan = getActiveSpan;
-        this.getSpanContext = getSpanContext;
-        this.setSpan = setSpan;
-        this.setSpanContext = setSpanContext;
-      }
-      TraceAPI2.getInstance = function() {
-        if (!this._instance) {
-          this._instance = new TraceAPI2();
-        }
-        return this._instance;
-      };
-      TraceAPI2.prototype.setGlobalTracerProvider = function(provider) {
-        var success = registerGlobal(API_NAME, this._proxyTracerProvider, DiagAPI.instance());
-        if (success) {
-          this._proxyTracerProvider.setDelegate(provider);
-        }
-        return success;
-      };
-      TraceAPI2.prototype.getTracerProvider = function() {
-        return getGlobal(API_NAME) || this._proxyTracerProvider;
-      };
-      TraceAPI2.prototype.getTracer = function(name, version) {
-        return this.getTracerProvider().getTracer(name, version);
-      };
-      TraceAPI2.prototype.disable = function() {
-        unregisterGlobal(API_NAME, DiagAPI.instance());
-        this._proxyTracerProvider = new ProxyTracerProvider();
-      };
-      return TraceAPI2;
-    })()
-  );
-  var trace = TraceAPI.getInstance();
-  var dist = {};
-  var hasRequiredDist;
-  function requireDist() {
-    if (hasRequiredDist) return dist;
-    hasRequiredDist = 1;
-    (function(exports3) {
-      Object.defineProperty(exports3, "__esModule", { value: true });
-      exports3.serialize = exports3.parse = exports3.MultipleFractionsError = exports3.InvalidDurationError = void 0;
-      const DEFAULT_PARSE_CONFIG = {
-        allowMultipleFractions: true
-      };
-      const units = [
-        { unit: "years", symbol: "Y" },
-        { unit: "months", symbol: "M" },
-        { unit: "weeks", symbol: "W" },
-        { unit: "days", symbol: "D" },
-        { unit: "hours", symbol: "H" },
-        { unit: "minutes", symbol: "M" },
-        { unit: "seconds", symbol: "S" }
-      ];
-      const r = (name, unit) => `((?<${name}>-?\\d*[\\.,]?\\d+)${unit})?`;
-      const durationRegex = new RegExp([
-        "(?<negative>-)?P",
-        r("years", "Y"),
-        r("months", "M"),
-        r("weeks", "W"),
-        r("days", "D"),
-        "(T",
-        r("hours", "H"),
-        r("minutes", "M"),
-        r("seconds", "S"),
-        ")?"
-        // end optional time
-      ].join(""));
-      function parseNum(s2) {
-        if (s2 === "" || s2 === void 0 || s2 === null) {
-          return void 0;
-        }
-        return parseFloat(s2.replace(",", "."));
-      }
-      exports3.InvalidDurationError = new Error("Invalid duration");
-      exports3.MultipleFractionsError = new Error("Multiple fractions specified");
-      function parse(durationStr, config = DEFAULT_PARSE_CONFIG) {
-        const match = durationRegex.exec(durationStr);
-        if (!match || !match.groups) {
-          throw exports3.InvalidDurationError;
-        }
-        let empty = true;
-        let decimalFractionCount = 0;
-        const values = {};
-        for (const { unit } of units) {
-          if (match.groups[unit]) {
-            empty = false;
-            values[unit] = parseNum(match.groups[unit]);
-            if (!config.allowMultipleFractions && !Number.isInteger(values[unit])) {
-              decimalFractionCount++;
-              if (decimalFractionCount > 1) {
-                throw exports3.MultipleFractionsError;
-              }
-            }
-          }
-        }
-        if (empty) {
-          throw exports3.InvalidDurationError;
-        }
-        const duration = values;
-        if (match.groups.negative) {
-          duration.negative = true;
-        }
-        return duration;
-      }
-      exports3.parse = parse;
-      const s = (number, component) => {
-        if (!number) {
-          return void 0;
-        }
-        let numberAsString = number.toString();
-        const exponentIndex = numberAsString.indexOf("e");
-        if (exponentIndex > -1) {
-          const magnitude = parseInt(numberAsString.slice(exponentIndex + 2), 10);
-          numberAsString = number.toFixed(magnitude + exponentIndex - 2);
-        }
-        return numberAsString + component;
-      };
-      function serialize(duration) {
-        if (!duration.years && !duration.months && !duration.weeks && !duration.days && !duration.hours && !duration.minutes && !duration.seconds) {
-          return "PT0S";
-        }
-        return [
-          duration.negative && "-",
-          "P",
-          s(duration.years, "Y"),
-          s(duration.months, "M"),
-          s(duration.weeks, "W"),
-          s(duration.days, "D"),
-          (duration.hours || duration.minutes || duration.seconds) && "T",
-          s(duration.hours, "H"),
-          s(duration.minutes, "M"),
-          s(duration.seconds, "S")
-        ].filter(Boolean).join("");
-      }
-      exports3.serialize = serialize;
-    })(dist);
-    return dist;
-  }
-  requireDist();
-  function dictionaryWithCanonicalKeys(canon) {
-    const keysNormalizationMap = /* @__PURE__ */ new Map();
-    return new Proxy({}, {
-      /**
-       * Intercept the get operation on the dictionary object and forward it to the target object using Reflect.get.
-       * @param target The target object.
-       * @param prop The property to get.
-       * @returns The value of the property.
-       */
-      get(target, prop) {
-        const normalKey = canon(prop);
-        return Reflect.get(target, normalKey);
-      },
-      /**
-       * Intercept the set operation on the dictionary object and forward it to the target object using Reflect.set.
-       * @param target The target object.
-       * @param prop The property to set.
-       * @param value The value to set.
-       * @returns A boolean indicating whether the property was set.
-       */
-      set(target, prop, value) {
-        const nonNormalKey = prop.toString();
-        const normalKey = canon(prop);
-        keysNormalizationMap.set(normalKey, nonNormalKey);
-        return Reflect.set(target, normalKey, value);
-      },
-      /**
-       * Intercept the has operation on the dictionary object and forward it to the target object using Reflect.has.
-       * @param _ the target object.
-       * @param prop The property to check.
-       * @returns A boolean indicating whether the property exists.
-       */
-      has(_, prop) {
-        const normalKey = canon(prop);
-        return keysNormalizationMap.has(normalKey);
-      },
-      /**
-       * Intercept the defineProperty operation on the dictionary object and forward it to the target object using Reflect.defineProperty.
-       * @param target The target object.
-       * @param prop The property to define.
-       * @param attribs The attributes of the property.
-       * @returns A boolean indicating whether the property was defined.
-       */
-      defineProperty(target, prop, attribs) {
-        const nonNormalKey = prop.toString();
-        const normalKey = canon(prop);
-        keysNormalizationMap.set(normalKey, nonNormalKey);
-        return Reflect.defineProperty(target, normalKey, attribs);
-      },
-      /**
-       * Intercept the deleteProperty operation on the dictionary object and forward it to the target object using Reflect.deleteProperty.
-       * @param target The target object.
-       * @param prop The property to delete.
-       * @returns A boolean indicating whether the property was deleted.
-       */
-      deleteProperty(target, prop) {
-        const normalKey = canon(prop);
-        keysNormalizationMap.delete(normalKey);
-        return Reflect.deleteProperty(target, normalKey);
-      },
-      /**
-       * Intercept the getOwnPropertyDescriptor operation on the dictionary object and forward it to the target object using Reflect.getOwnPropertyDescriptor.
-       * @param target The target object.
-       * @param prop The property to gets its descriptor.
-       * @returns The property descriptor.
-       */
-      getOwnPropertyDescriptor(target, prop) {
-        return Reflect.getOwnPropertyDescriptor(target, canon(prop));
-      },
-      ownKeys() {
-        return [...keysNormalizationMap.values()];
-      }
-    });
-  }
-  function createRecordWithCaseInsensitiveKeys() {
-    const record = dictionaryWithCanonicalKeys((p) => typeof p === "string" ? p.toLowerCase() : p.toString().toLowerCase());
-    return record;
-  }
-  class Headers extends Map {
-    /**
-     * Creates a new Headers object.
-     * @param entries An iterable object that contains key-value pairs. Each key-value pair must be an array with two elements: the key of the header, and the value of the header.
-     * @example
-     * ```typescript
-     *  const entries: [string, Set<string>][] = [
-     *    ['header1', new Set(['value1'])],
-     *    ['header2', new Set(['value2', 'value3'])]
-     *  ];
-     *  const headers = new Headers(entries);
-     * ```
-     */
-    constructor(entries) {
-      super();
-      this.headers = createRecordWithCaseInsensitiveKeys();
-      this.singleValueHeaders = /* @__PURE__ */ new Set(["Content-Type", "Content-Encoding", "Content-Length"]);
-      if (entries) {
-        entries.forEach(([key, value]) => {
-          this.headers[key] = value;
-        });
-      }
-    }
-    /**
-     * Sets a header with the specified name and value. If a header with the same name already exists, its value is appended with the specified value.
-     * @param headerName the name of the header to set
-     * @param headerValue the value of the header to set
-     * @returns Headers object
-     */
-    set(headerName, headerValue) {
-      this.add(headerName, ...headerValue);
-      return this;
-    }
-    /**
-     * Gets the values for the header with the specified name.
-     * @param headerName The name of the header to get the values for.
-     * @returns The values for the header with the specified name.
-     * @throws Error if headerName is null or empty
-     */
-    get(headerName) {
-      if (!headerName) {
-        throw new Error("headerName cannot be null or empty");
-      }
-      return this.headers[headerName];
-    }
-    /**
-     * Checks if a header exists.
-     * @param key The name of the header to check for.
-     * @returns whether or not a header with the given name/key exists.
-     */
-    has(key) {
-      return !!key && !!this.headers[key];
-    }
-    /**
-     * Delete the header with the specified name.
-     * @param headerName The name of the header to delete.
-     * @returns Whether or not the header existed and was deleted.
-     * @throws Error if headerName is null or empty
-     */
-    delete(headerName) {
-      if (!headerName) {
-        throw new Error("headerName cannot be null or empty");
-      }
-      if (this.headers[headerName]) {
-        delete this.headers[headerName];
-        return true;
-      }
-      return false;
-    }
-    /**
-     * clear the headers collection
-     */
-    clear() {
-      for (const header in this.headers) {
-        if (Object.prototype.hasOwnProperty.call(this.headers, header)) {
-          delete this.headers[header];
-        }
-      }
-    }
-    /**
-     * execute a provided function once per each header
-     * @param callbackfn A function that accepts up to three arguments. forEach calls the callbackfn function one time for each header in the dictionary.
-     * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.
-     */
-    forEach(callbackfn, thisArg) {
-      for (const header in this.headers) {
-        if (Object.prototype.hasOwnProperty.call(this.headers, header)) {
-          callbackfn.call(thisArg, this.headers[header], header, this);
-        }
-      }
-    }
-    /**
-     * Adds values to the header with the specified name.
-     * @param headerName The name of the header to add values to.
-     * @param headerValues The values to add to the header.
-     * @returns Whether or not the values were added to the header.
-     */
-    add(headerName, ...headerValues) {
-      if (!headerName) {
-        console.error("headerName cannot be null or empty");
-        return false;
-      }
-      if (!headerValues) {
-        console.error("headerValues cannot be null");
-        return false;
-      }
-      if (headerValues.length === 0) {
-        return false;
-      }
-      if (this.singleValueHeaders.has(headerName)) {
-        this.headers[headerName] = /* @__PURE__ */ new Set([headerValues[0]]);
-      } else if (this.headers[headerName]) {
-        headerValues.forEach((headerValue) => this.headers[headerName].add(headerValue));
-      } else {
-        this.headers[headerName] = new Set(headerValues);
-      }
-      return true;
-    }
-    /**
-     * Adds values to the header with the specified name if it's not already present
-     * @param headerName The name of the header to add values to.
-     * @param headerValue The values to add to the header.
-     * @returns If the headerValue have been added to the Dictionary.
-     */
-    tryAdd(headerName, headerValue) {
-      if (!headerName) {
-        throw new Error("headerName cannot be null or empty");
-      }
-      if (!headerValue) {
-        throw new Error("headerValue cannot be null");
-      }
-      if (!this.headers[headerName]) {
-        this.headers[headerName] = /* @__PURE__ */ new Set([headerValue]);
-        return true;
-      }
-      return false;
-    }
-    /**
-     * Removes the specified value from the header with the specified name.
-     * @param headerName The name of the header to remove the value from.
-     * @param headerValue The value to remove from the header.
-     * @returns Whether or not the header existed and was removed.
-     * @throws Error if headerName is null or empty
-     * @throws Error if headerValue is null
-     */
-    remove(headerName, headerValue) {
-      if (!headerName) {
-        throw new Error("headerName cannot be null or empty");
-      }
-      if (!headerValue) {
-        throw new Error("headerValue cannot be null");
-      }
-      if (this.headers[headerName]) {
-        const result = this.headers[headerName].delete(headerValue);
-        if (this.headers[headerName].size === 0) {
-          delete this.headers[headerName];
-        }
-        return result;
-      }
-      return false;
-    }
-    /**
-     * Adds all the headers values from the specified headers collection.
-     * @param headers The headers to update the current headers with.
-     * @throws Error if headers is null
-     */
-    addAll(headers) {
-      if (!headers) {
-        throw new Error("headers cannot be null");
-      }
-      for (const header in headers.headers) {
-        if (Object.prototype.hasOwnProperty.call(headers.headers, header)) {
-          headers.headers[header].forEach((value) => this.add(header, value));
-        }
-      }
-    }
-    /**
-     * Adds all headers from the request configuration value to the current headers collection.
-     * Replaces any existing headers with the same key.
-     * @param headers The headers to update the current headers with.
-     * @throws Error if headers is null
-     */
-    addAllRaw(headers) {
-      if (!headers) {
-        throw new Error("headers cannot be null");
-      }
-      for (const header in headers) {
-        if (Object.prototype.hasOwnProperty.call(headers, header)) {
-          const headerValues = headers[header];
-          if (Array.isArray(headerValues)) {
-            this.add(header, ...headerValues);
-          } else {
-            this.add(header, headerValues);
-          }
-        }
-      }
-    }
-    /**
-     * Gets the values for the header with the specified name.
-     * @param key The name of the header to get the values for.
-     * @returns The values for the header with the specified name.
-     * @throws Error if key is null or empty
-     */
-    tryGetValue(key) {
-      if (!key) {
-        throw new Error("key cannot be null or empty");
-      }
-      return this.headers[key] ? Array.from(this.headers[key]) : null;
-    }
-    /**
-     * Override toString method for the headers collection
-     * @returns a string representation of the headers collection
-     */
-    toString() {
-      return JSON.stringify(this.headers, (_key, value) => value instanceof Set ? [...value] : value);
-    }
-    /**
-     * check if the headers collection is empty
-     * @returns a boolean indicating if the headers collection is empty
-     */
-    isEmpty() {
-      return Object.keys(this.headers).length === 0;
-    }
-    /**
-     * get keys of the headers collection
-     * @returns an iterator of keys
-     */
-    keys() {
-      return Object.keys(this.headers)[Symbol.iterator]();
-    }
-    /**
-     * get entries
-     * @returns an iterator of entries
-     */
-    entries() {
-      return Object.entries(this.headers)[Symbol.iterator]();
-    }
-  }
-  var HttpMethod;
-  (function(HttpMethod2) {
-    HttpMethod2["GET"] = "GET";
-    HttpMethod2["POST"] = "POST";
-    HttpMethod2["PATCH"] = "PATCH";
-    HttpMethod2["DELETE"] = "DELETE";
-    HttpMethod2["OPTIONS"] = "OPTIONS";
-    HttpMethod2["CONNECT"] = "CONNECT";
-    HttpMethod2["TRACE"] = "TRACE";
-    HttpMethod2["HEAD"] = "HEAD";
-    HttpMethod2["PUT"] = "PUT";
-  })(HttpMethod || (HttpMethod = {}));
-  class DefaultApiError extends Error {
-    constructor(message) {
-      super(message);
-      this.responseHeaders = {};
-    }
-  }
-  var ApiKeyLocation;
-  (function(ApiKeyLocation2) {
-    ApiKeyLocation2[ApiKeyLocation2["QueryParameter"] = 0] = "QueryParameter";
-    ApiKeyLocation2[ApiKeyLocation2["Header"] = 1] = "Header";
-  })(ApiKeyLocation || (ApiKeyLocation = {}));
-  class BaseBearerTokenAuthenticationProvider {
-    /**
-     * The constructor for the BaseBearerTokenAuthenticationProvider
-     * @param accessTokenProvider The AccessTokenProvider instance that this provider will use to authenticate requests.
-     */
-    constructor(accessTokenProvider) {
-      this.accessTokenProvider = accessTokenProvider;
-      this.authenticateRequest = async (request, additionalAuthenticationContext) => {
-        var _a;
-        if (!request) {
-          throw new Error("request info cannot be null");
-        }
-        if ((additionalAuthenticationContext === null || additionalAuthenticationContext === void 0 ? void 0 : additionalAuthenticationContext.claims) && request.headers.has(BaseBearerTokenAuthenticationProvider.authorizationHeaderKey)) {
-          request.headers.delete(BaseBearerTokenAuthenticationProvider.authorizationHeaderKey);
-        }
-        if (!((_a = request.headers) === null || _a === void 0 ? void 0 : _a.has(BaseBearerTokenAuthenticationProvider.authorizationHeaderKey))) {
-          const token = await this.accessTokenProvider.getAuthorizationToken(request.URL, additionalAuthenticationContext);
-          if (!request.headers) {
-            request.headers = new Headers();
-          }
-          if (token) {
-            request.headers.add(BaseBearerTokenAuthenticationProvider.authorizationHeaderKey, `Bearer ${token}`);
-          }
-        }
-      };
-    }
-  }
-  BaseBearerTokenAuthenticationProvider.authorizationHeaderKey = "Authorization";
-  class NativeResponseHandler {
-    handleResponse(response, errorMappings) {
-      this.value = response;
-      this.errorMappings = errorMappings;
-      return Promise.resolve(void 0);
-    }
-  }
-  class NativeResponseWrapper {
-  }
-  NativeResponseWrapper.CallAndGetNative = async (originalCall, q, h, o) => {
-    const responseHandler = new NativeResponseHandler();
-    await originalCall(q, h, o, responseHandler);
-    return responseHandler.value;
-  };
-  NativeResponseWrapper.CallAndGetNativeWithBody = async (originalCall, requestBody, q, h, o) => {
-    const responseHandler = new NativeResponseHandler();
-    await originalCall(requestBody, q, h, o, responseHandler);
-    return responseHandler.value;
-  };
-  const ResponseHandlerOptionKey = "ResponseHandlerOptionKey";
-  class CustomFetchHandler {
-    constructor(customFetch) {
-      this.customFetch = customFetch;
-    }
-    /**
-     * @inheritdoc
-     */
-    async execute(url, requestInit) {
-      return await this.customFetch(url, requestInit);
-    }
-  }
-  class HttpClient {
-    /**
-     *
-     * Creates an instance of a HttpClient which contains the middlewares and fetch implementation for request execution.
-     * @param customFetch - custom fetch function - a Fetch API implementation
-     * @param middlewares - an array of Middleware handlers
-     */
-    constructor(customFetch, ...middlewares) {
-      this.customFetch = customFetch;
-      middlewares = (middlewares === null || middlewares === void 0 ? void 0 : middlewares.length) && middlewares[0] ? middlewares : MiddlewareFactory.getDefaultMiddlewares(customFetch);
-      if (this.customFetch) {
-        middlewares.push(new CustomFetchHandler(customFetch));
-      }
-      this.setMiddleware(...middlewares);
-    }
-    /**
-     * Processes the middleware parameter passed to set this.middleware property
-     * The calling function should validate if middleware is not undefined or not empty.
-     * @param middleware - The middleware passed
-     */
-    setMiddleware(...middleware) {
-      for (let i = 0; i < middleware.length - 1; i++) {
-        middleware[i].next = middleware[i + 1];
-      }
-      this.middleware = middleware[0];
-    }
-    /**
-     * Executes a request and returns a promise resolving the response.
-     * @param url the request url.
-     * @param requestInit the RequestInit object.
-     * @param requestOptions the request options.
-     * @returns the promise resolving the response.
-     */
-    async executeFetch(url, requestInit, requestOptions) {
-      if (this.middleware) {
-        return await this.middleware.execute(url, requestInit, requestOptions);
-      } else if (this.customFetch) {
-        return this.customFetch(url, requestInit);
-      }
-      throw new Error("Please provide middlewares or a custom fetch function to execute the request");
-    }
-  }
-  const ObservabilityOptionKey = "ObservabilityOptionKey";
-  class ObservabilityOptionsImpl {
-    constructor(originalOptions) {
-      this._originalOptions = originalOptions !== null && originalOptions !== void 0 ? originalOptions : {};
-    }
-    getKey() {
-      return ObservabilityOptionKey;
-    }
-    get includeEUIIAttributes() {
-      return this._originalOptions.includeEUIIAttributes;
-    }
-    set includeEUIIAttributes(value) {
-      this._originalOptions.includeEUIIAttributes = value;
-    }
-    getTracerInstrumentationName() {
-      return "@microsoft/kiota-http-fetchlibrary";
-    }
-  }
-  function getObservabilityOptionsFromRequest(requestOptions) {
-    if (requestOptions) {
-      const observabilityOptions = requestOptions[ObservabilityOptionKey];
-      if (observabilityOptions instanceof ObservabilityOptionsImpl) {
-        return observabilityOptions;
-      }
-    }
-    return void 0;
-  }
-  class FetchRequestAdapter {
-    getSerializationWriterFactory() {
-      return this.serializationWriterFactory;
-    }
-    getParseNodeFactory() {
-      return this.parseNodeFactory;
-    }
-    getBackingStoreFactory() {
-      return this.backingStoreFactory;
-    }
-    /**
-     * Instantiates a new request adapter.
-     * @param authenticationProvider the authentication provider to use.
-     * @param parseNodeFactory the parse node factory to deserialize responses.
-     * @param serializationWriterFactory the serialization writer factory to use to serialize request bodies.
-     * @param httpClient the http client to use to execute requests.
-     * @param observabilityOptions the observability options to use.
-     * @param backingStoreFactory the backing store factory to use.
-     */
-    constructor(authenticationProvider, parseNodeFactory = new ParseNodeFactoryRegistry(), serializationWriterFactory = new SerializationWriterFactoryRegistry(), httpClient = new HttpClient(), observabilityOptions = new ObservabilityOptionsImpl(), backingStoreFactory = new InMemoryBackingStoreFactory()) {
-      this.authenticationProvider = authenticationProvider;
-      this.parseNodeFactory = parseNodeFactory;
-      this.serializationWriterFactory = serializationWriterFactory;
-      this.httpClient = httpClient;
-      this.backingStoreFactory = backingStoreFactory;
-      this.baseUrl = "";
-      this.getResponseContentType = (response) => {
-        var _a;
-        const header = (_a = response.headers.get("content-type")) === null || _a === void 0 ? void 0 : _a.toLowerCase();
-        if (!header)
-          return void 0;
-        const segments = header.split(";");
-        if (segments.length === 0)
-          return void 0;
-        else
-          return segments[0];
-      };
-      this.getResponseHandler = (response) => {
-        const options = response.getRequestOptions();
-        const responseHandlerOption = options[ResponseHandlerOptionKey];
-        return responseHandlerOption === null || responseHandlerOption === void 0 ? void 0 : responseHandlerOption.responseHandler;
-      };
-      this.sendCollectionOfPrimitive = (requestInfo, responseType, errorMappings) => {
-        if (!requestInfo) {
-          throw new Error("requestInfo cannot be null");
-        }
-        return this.startTracingSpan(requestInfo, "sendCollectionOfPrimitive", async (span) => {
-          const response = await this.getHttpResponseMessage(requestInfo, span);
-          const responseHandler = this.getResponseHandler(requestInfo);
-          if (responseHandler) {
-            span.addEvent(FetchRequestAdapter.eventResponseHandlerInvokedKey);
-            return await responseHandler.handleResponse(response, errorMappings);
-          } else {
-            try {
-              await this.throwIfFailedResponse(response, errorMappings, span);
-              if (this.shouldReturnUndefined(response))
-                return void 0;
-              switch (responseType) {
-                case "string":
-                case "number":
-                case "boolean":
-                case "Date":
-                  const rootNode = await this.getRootParseNode(response);
-                  return trace.getTracer(this.observabilityOptions.getTracerInstrumentationName()).startActiveSpan(`getCollectionOf${responseType}Value`, (deserializeSpan) => {
-                    try {
-                      span.setAttribute(FetchRequestAdapter.responseTypeAttributeKey, responseType);
-                      if (responseType === "string") {
-                        return rootNode.getCollectionOfPrimitiveValues();
-                      } else if (responseType === "number") {
-                        return rootNode.getCollectionOfPrimitiveValues();
-                      } else if (responseType === "boolean") {
-                        return rootNode.getCollectionOfPrimitiveValues();
-                      } else if (responseType === "Date") {
-                        return rootNode.getCollectionOfPrimitiveValues();
-                      } else if (responseType === "Duration") {
-                        return rootNode.getCollectionOfPrimitiveValues();
-                      } else if (responseType === "DateOnly") {
-                        return rootNode.getCollectionOfPrimitiveValues();
-                      } else if (responseType === "TimeOnly") {
-                        return rootNode.getCollectionOfPrimitiveValues();
-                      } else {
-                        throw new Error("unexpected type to deserialize");
-                      }
-                    } finally {
-                      deserializeSpan.end();
-                    }
-                  });
-              }
-            } finally {
-              await this.purgeResponseBody(response);
-            }
-          }
-        });
-      };
-      this.sendCollection = (requestInfo, deserialization, errorMappings) => {
-        if (!requestInfo) {
-          throw new Error("requestInfo cannot be null");
-        }
-        return this.startTracingSpan(requestInfo, "sendCollection", async (span) => {
-          const response = await this.getHttpResponseMessage(requestInfo, span);
-          const responseHandler = this.getResponseHandler(requestInfo);
-          if (responseHandler) {
-            span.addEvent(FetchRequestAdapter.eventResponseHandlerInvokedKey);
-            return await responseHandler.handleResponse(response, errorMappings);
-          } else {
-            try {
-              await this.throwIfFailedResponse(response, errorMappings, span);
-              if (this.shouldReturnUndefined(response))
-                return void 0;
-              const rootNode = await this.getRootParseNode(response);
-              return trace.getTracer(this.observabilityOptions.getTracerInstrumentationName()).startActiveSpan("getCollectionOfObjectValues", (deserializeSpan) => {
-                try {
-                  const result = rootNode.getCollectionOfObjectValues(deserialization);
-                  span.setAttribute(FetchRequestAdapter.responseTypeAttributeKey, "object[]");
-                  return result;
-                } finally {
-                  deserializeSpan.end();
-                }
-              });
-            } finally {
-              await this.purgeResponseBody(response);
-            }
-          }
-        });
-      };
-      this.startTracingSpan = (requestInfo, methodName, callback) => {
-        var _a;
-        const urlTemplate = decodeURIComponent((_a = requestInfo.urlTemplate) !== null && _a !== void 0 ? _a : "");
-        const telemetryPathValue = urlTemplate.replace(/\{\?[^}]+\}/gi, "");
-        return trace.getTracer(this.observabilityOptions.getTracerInstrumentationName()).startActiveSpan(`${methodName} - ${telemetryPathValue}`, async (span) => {
-          try {
-            span.setAttribute("url.uri_template", urlTemplate);
-            return await callback(span);
-          } finally {
-            span.end();
-          }
-        });
-      };
-      this.send = (requestInfo, deserializer, errorMappings) => {
-        if (!requestInfo) {
-          throw new Error("requestInfo cannot be null");
-        }
-        return this.startTracingSpan(requestInfo, "send", async (span) => {
-          const response = await this.getHttpResponseMessage(requestInfo, span);
-          const responseHandler = this.getResponseHandler(requestInfo);
-          if (responseHandler) {
-            span.addEvent(FetchRequestAdapter.eventResponseHandlerInvokedKey);
-            return await responseHandler.handleResponse(response, errorMappings);
-          } else {
-            try {
-              await this.throwIfFailedResponse(response, errorMappings, span);
-              if (this.shouldReturnUndefined(response))
-                return void 0;
-              const rootNode = await this.getRootParseNode(response);
-              return trace.getTracer(this.observabilityOptions.getTracerInstrumentationName()).startActiveSpan("getObjectValue", (deserializeSpan) => {
-                try {
-                  span.setAttribute(FetchRequestAdapter.responseTypeAttributeKey, "object");
-                  const result = rootNode.getObjectValue(deserializer);
-                  return result;
-                } finally {
-                  deserializeSpan.end();
-                }
-              });
-            } finally {
-              await this.purgeResponseBody(response);
-            }
-          }
-        });
-      };
-      this.sendPrimitive = (requestInfo, responseType, errorMappings) => {
-        if (!requestInfo) {
-          throw new Error("requestInfo cannot be null");
-        }
-        return this.startTracingSpan(requestInfo, "sendPrimitive", async (span) => {
-          const response = await this.getHttpResponseMessage(requestInfo, span);
-          const responseHandler = this.getResponseHandler(requestInfo);
-          if (responseHandler) {
-            span.addEvent(FetchRequestAdapter.eventResponseHandlerInvokedKey);
-            return await responseHandler.handleResponse(response, errorMappings);
-          } else {
-            try {
-              await this.throwIfFailedResponse(response, errorMappings, span);
-              if (this.shouldReturnUndefined(response))
-                return void 0;
-              switch (responseType) {
-                case "ArrayBuffer":
-                  if (!response.body) {
-                    return void 0;
-                  }
-                  return await response.arrayBuffer();
-                case "string":
-                case "number":
-                case "boolean":
-                case "Date":
-                  const rootNode = await this.getRootParseNode(response);
-                  span.setAttribute(FetchRequestAdapter.responseTypeAttributeKey, responseType);
-                  return trace.getTracer(this.observabilityOptions.getTracerInstrumentationName()).startActiveSpan(`get${responseType}Value`, (deserializeSpan) => {
-                    try {
-                      if (responseType === "string") {
-                        return rootNode.getStringValue();
-                      } else if (responseType === "number") {
-                        return rootNode.getNumberValue();
-                      } else if (responseType === "boolean") {
-                        return rootNode.getBooleanValue();
-                      } else if (responseType === "Date") {
-                        return rootNode.getDateValue();
-                      } else if (responseType === "Duration") {
-                        return rootNode.getDurationValue();
-                      } else if (responseType === "DateOnly") {
-                        return rootNode.getDateOnlyValue();
-                      } else if (responseType === "TimeOnly") {
-                        return rootNode.getTimeOnlyValue();
-                      } else {
-                        throw new Error("unexpected type to deserialize");
-                      }
-                    } finally {
-                      deserializeSpan.end();
-                    }
-                  });
-              }
-            } finally {
-              await this.purgeResponseBody(response);
-            }
-          }
-        });
-      };
-      this.sendNoResponseContent = (requestInfo, errorMappings) => {
-        if (!requestInfo) {
-          throw new Error("requestInfo cannot be null");
-        }
-        return this.startTracingSpan(requestInfo, "sendNoResponseContent", async (span) => {
-          const response = await this.getHttpResponseMessage(requestInfo, span);
-          const responseHandler = this.getResponseHandler(requestInfo);
-          if (responseHandler) {
-            span.addEvent(FetchRequestAdapter.eventResponseHandlerInvokedKey);
-            return await responseHandler.handleResponse(response, errorMappings);
-          }
-          try {
-            await this.throwIfFailedResponse(response, errorMappings, span);
-          } finally {
-            await this.purgeResponseBody(response);
-          }
-        });
-      };
-      this.sendEnum = (requestInfo, enumObject, errorMappings) => {
-        if (!requestInfo) {
-          throw new Error("requestInfo cannot be null");
-        }
-        return this.startTracingSpan(requestInfo, "sendEnum", async (span) => {
-          const response = await this.getHttpResponseMessage(requestInfo, span);
-          const responseHandler = this.getResponseHandler(requestInfo);
-          if (responseHandler) {
-            span.addEvent(FetchRequestAdapter.eventResponseHandlerInvokedKey);
-            return await responseHandler.handleResponse(response, errorMappings);
-          } else {
-            try {
-              await this.throwIfFailedResponse(response, errorMappings, span);
-              if (this.shouldReturnUndefined(response))
-                return void 0;
-              const rootNode = await this.getRootParseNode(response);
-              return trace.getTracer(this.observabilityOptions.getTracerInstrumentationName()).startActiveSpan("getEnumValue", (deserializeSpan) => {
-                try {
-                  span.setAttribute(FetchRequestAdapter.responseTypeAttributeKey, "enum");
-                  const result = rootNode.getEnumValue(enumObject);
-                  return result;
-                } finally {
-                  deserializeSpan.end();
-                }
-              });
-            } finally {
-              await this.purgeResponseBody(response);
-            }
-          }
-        });
-      };
-      this.sendCollectionOfEnum = (requestInfo, enumObject, errorMappings) => {
-        if (!requestInfo) {
-          throw new Error("requestInfo cannot be null");
-        }
-        return this.startTracingSpan(requestInfo, "sendCollectionOfEnum", async (span) => {
-          const response = await this.getHttpResponseMessage(requestInfo, span);
-          const responseHandler = this.getResponseHandler(requestInfo);
-          if (responseHandler) {
-            span.addEvent(FetchRequestAdapter.eventResponseHandlerInvokedKey);
-            return await responseHandler.handleResponse(response, errorMappings);
-          } else {
-            try {
-              await this.throwIfFailedResponse(response, errorMappings, span);
-              if (this.shouldReturnUndefined(response))
-                return void 0;
-              const rootNode = await this.getRootParseNode(response);
-              return trace.getTracer(this.observabilityOptions.getTracerInstrumentationName()).startActiveSpan("getCollectionOfEnumValues", (deserializeSpan) => {
-                try {
-                  const result = rootNode.getCollectionOfEnumValues(enumObject);
-                  span.setAttribute(FetchRequestAdapter.responseTypeAttributeKey, "enum[]");
-                  return result;
-                } finally {
-                  deserializeSpan.end();
-                }
-              });
-            } finally {
-              await this.purgeResponseBody(response);
-            }
-          }
-        });
-      };
-      this.enableBackingStore = (backingStoreFactory2) => {
-        if (this.parseNodeFactory instanceof ParseNodeFactoryRegistry) {
-          this.parseNodeFactory = enableBackingStoreForParseNodeFactory(this.parseNodeFactory, this.parseNodeFactory);
-        } else {
-          throw new Error("parseNodeFactory is not a ParseNodeFactoryRegistry");
-        }
-        if (this.serializationWriterFactory instanceof SerializationWriterFactoryRegistry && this.parseNodeFactory instanceof ParseNodeFactoryRegistry) {
-          this.serializationWriterFactory = enableBackingStoreForSerializationWriterFactory(this.serializationWriterFactory, this.parseNodeFactory, this.serializationWriterFactory);
-        } else {
-          throw new Error("serializationWriterFactory is not a SerializationWriterFactoryRegistry or parseNodeFactory is not a ParseNodeFactoryRegistry");
-        }
-        if (!this.serializationWriterFactory || !this.parseNodeFactory)
-          throw new Error("unable to enable backing store");
-        if (backingStoreFactory2) {
-          this.backingStoreFactory = backingStoreFactory2;
-        }
-      };
-      this.getRootParseNode = (response) => {
-        return trace.getTracer(this.observabilityOptions.getTracerInstrumentationName()).startActiveSpan("getRootParseNode", async (span) => {
-          try {
-            const payload = await response.arrayBuffer();
-            const responseContentType = this.getResponseContentType(response);
-            if (!responseContentType)
-              throw new Error("no response content type found for deserialization");
-            return this.parseNodeFactory.getRootParseNode(responseContentType, payload);
-          } finally {
-            span.end();
-          }
-        });
-      };
-      this.shouldReturnUndefined = (response) => {
-        return response.status === 204 || response.status === 304 || !response.body;
-      };
-      this.purgeResponseBody = async (response) => {
-        if (!response.bodyUsed && response.body) {
-          await response.arrayBuffer();
-        }
-      };
-      this.throwIfFailedResponse = (response, errorMappings, spanForAttributes) => {
-        return trace.getTracer(this.observabilityOptions.getTracerInstrumentationName()).startActiveSpan("throwIfFailedResponse", async (span) => {
-          var _a, _b, _c;
-          try {
-            if (response.ok || response.status >= 300 && response.status < 400 && !response.headers.has(FetchRequestAdapter.locationHeaderName))
-              return;
-            spanForAttributes.setStatus({
-              code: SpanStatusCode.ERROR,
-              message: "received_error_response"
-            });
-            const statusCode = response.status;
-            const responseHeaders = {};
-            response.headers.forEach((value, key) => {
-              responseHeaders[key] = value.split(",");
-            });
-            const factory = errorMappings ? (_c = (_b = (_a = errorMappings[statusCode]) !== null && _a !== void 0 ? _a : statusCode >= 400 && statusCode < 500 ? errorMappings._4XX : void 0) !== null && _b !== void 0 ? _b : statusCode >= 500 && statusCode < 600 ? errorMappings._5XX : void 0) !== null && _c !== void 0 ? _c : errorMappings.XXX : void 0;
-            if (!factory) {
-              spanForAttributes.setAttribute(FetchRequestAdapter.errorMappingFoundAttributeName, false);
-              const error = new DefaultApiError("the server returned an unexpected status code and no error class is registered for this code " + statusCode);
-              error.responseStatusCode = statusCode;
-              error.responseHeaders = responseHeaders;
-              spanForAttributes.recordException(error);
-              throw error;
-            }
-            spanForAttributes.setAttribute(FetchRequestAdapter.errorMappingFoundAttributeName, true);
-            const rootNode = await this.getRootParseNode(response);
-            let deserializedError = trace.getTracer(this.observabilityOptions.getTracerInstrumentationName()).startActiveSpan("getObjectValue", (deserializeSpan) => {
-              try {
-                return rootNode.getObjectValue(factory);
-              } finally {
-                deserializeSpan.end();
-              }
-            });
-            spanForAttributes.setAttribute(FetchRequestAdapter.errorBodyFoundAttributeName, !!deserializedError);
-            if (!deserializedError)
-              deserializedError = new DefaultApiError("unexpected error type" + typeof deserializedError);
-            const errorObject = deserializedError;
-            errorObject.responseStatusCode = statusCode;
-            errorObject.responseHeaders = responseHeaders;
-            spanForAttributes.recordException(errorObject);
-            throw errorObject;
-          } finally {
-            span.end();
-          }
-        });
-      };
-      this.getHttpResponseMessage = (requestInfo, spanForAttributes, claims) => {
-        return trace.getTracer(this.observabilityOptions.getTracerInstrumentationName()).startActiveSpan("getHttpResponseMessage", async (span) => {
-          try {
-            if (!requestInfo) {
-              throw new Error("requestInfo cannot be null");
-            }
-            this.setBaseUrlForRequestInformation(requestInfo);
-            const additionalContext = {};
-            if (claims) {
-              additionalContext.claims = claims;
-            }
-            await this.authenticationProvider.authenticateRequest(requestInfo, additionalContext);
-            const request = await this.getRequestFromRequestInformation(requestInfo, spanForAttributes);
-            if (this.observabilityOptions) {
-              requestInfo.addRequestOptions([this.observabilityOptions]);
-            }
-            let response = await this.httpClient.executeFetch(requestInfo.URL, request, requestInfo.getRequestOptions());
-            response = await this.retryCAEResponseIfRequired(requestInfo, response, spanForAttributes, claims);
-            if (response) {
-              const responseContentLength = response.headers.get("Content-Length");
-              if (responseContentLength) {
-                spanForAttributes.setAttribute("http.response.body.size", parseInt(responseContentLength, 10));
-              }
-              const responseContentType = response.headers.get("Content-Type");
-              if (responseContentType) {
-                spanForAttributes.setAttribute("http.response.header.content-type", responseContentType);
-              }
-              spanForAttributes.setAttribute("http.response.status_code", response.status);
-            }
-            return response;
-          } finally {
-            span.end();
-          }
-        });
-      };
-      this.retryCAEResponseIfRequired = async (requestInfo, response, spanForAttributes, claims) => {
-        return trace.getTracer(this.observabilityOptions.getTracerInstrumentationName()).startActiveSpan("retryCAEResponseIfRequired", async (span) => {
-          try {
-            const responseClaims = this.getClaimsFromResponse(response, claims);
-            if (responseClaims) {
-              span.addEvent(FetchRequestAdapter.authenticateChallengedEventKey);
-              spanForAttributes.setAttribute("http.request.resend_count", 1);
-              await this.purgeResponseBody(response);
-              return await this.getHttpResponseMessage(requestInfo, spanForAttributes, responseClaims);
-            }
-            return response;
-          } finally {
-            span.end();
-          }
-        });
-      };
-      this.getClaimsFromResponse = (response, claims) => {
-        if (response.status === 401 && !claims) {
-          const rawAuthenticateHeader = response.headers.get("WWW-Authenticate");
-          if (rawAuthenticateHeader && /^Bearer /gi.test(rawAuthenticateHeader)) {
-            const rawParameters = rawAuthenticateHeader.replace(/^Bearer /gi, "").split(",");
-            for (const rawParameter of rawParameters) {
-              const trimmedParameter = rawParameter.trim();
-              if (/claims="[^"]+"/gi.test(trimmedParameter)) {
-                return trimmedParameter.replace(/claims="([^"]+)"/gi, "$1");
-              }
-            }
-          }
-        }
-        return void 0;
-      };
-      this.setBaseUrlForRequestInformation = (requestInfo) => {
-        requestInfo.pathParameters.baseurl = this.baseUrl;
-      };
-      this.getRequestFromRequestInformation = (requestInfo, spanForAttributes) => {
-        return trace.getTracer(this.observabilityOptions.getTracerInstrumentationName()).startActiveSpan("getRequestFromRequestInformation", async (span) => {
-          var _a, _b;
-          try {
-            const method = (_a = requestInfo.httpMethod) === null || _a === void 0 ? void 0 : _a.toString();
-            const uri = requestInfo.URL;
-            spanForAttributes.setAttribute("http.request.method", method !== null && method !== void 0 ? method : "");
-            const uriContainsScheme = uri.includes("://");
-            const schemeSplatUri = uri.split("://");
-            if (uriContainsScheme) {
-              spanForAttributes.setAttribute("server.address", schemeSplatUri[0]);
-            }
-            const uriWithoutScheme = uriContainsScheme ? schemeSplatUri[1] : uri;
-            spanForAttributes.setAttribute("url.scheme", uriWithoutScheme.split("/")[0]);
-            if (this.observabilityOptions.includeEUIIAttributes) {
-              spanForAttributes.setAttribute("url.full", decodeURIComponent(uri));
-            }
-            const requestContentLength = requestInfo.headers.tryGetValue("Content-Length");
-            if (requestContentLength) {
-              spanForAttributes.setAttribute("http.response.body.size", parseInt(requestContentLength[0], 10));
-            }
-            const requestContentType = requestInfo.headers.tryGetValue("Content-Type");
-            if (requestContentType) {
-              spanForAttributes.setAttribute("http.request.header.content-type", requestContentType);
-            }
-            const headers = {};
-            (_b = requestInfo.headers) === null || _b === void 0 ? void 0 : _b.forEach((_, key) => {
-              headers[key.toString().toLocaleLowerCase()] = this.foldHeaderValue(requestInfo.headers.tryGetValue(key));
-            });
-            const request = {
-              method,
-              headers,
-              body: requestInfo.content
-            };
-            return request;
-          } finally {
-            span.end();
-          }
-        });
-      };
-      this.foldHeaderValue = (value) => {
-        if (!value || value.length < 1) {
-          return "";
-        } else if (value.length === 1) {
-          return value[0];
-        } else {
-          return value.reduce((acc, val) => acc + val, ",");
-        }
-      };
-      this.convertToNativeRequest = async (requestInfo) => {
-        if (!requestInfo) {
-          throw new Error("requestInfo cannot be null");
-        }
-        await this.authenticationProvider.authenticateRequest(requestInfo, void 0);
-        return this.startTracingSpan(requestInfo, "convertToNativeRequest", async (span) => {
-          const request = await this.getRequestFromRequestInformation(requestInfo, span);
-          return request;
-        });
-      };
-      if (!authenticationProvider) {
-        throw new Error("authentication provider cannot be null");
-      }
-      if (!parseNodeFactory) {
-        throw new Error("parse node factory cannot be null");
-      }
-      if (!serializationWriterFactory) {
-        throw new Error("serialization writer factory cannot be null");
-      }
-      if (!httpClient) {
-        throw new Error("http client cannot be null");
-      }
-      if (!observabilityOptions) {
-        throw new Error("observability options cannot be null");
-      } else {
-        this.observabilityOptions = new ObservabilityOptionsImpl(observabilityOptions);
-      }
-    }
-  }
-  FetchRequestAdapter.responseTypeAttributeKey = "com.microsoft.kiota.response.type";
-  FetchRequestAdapter.eventResponseHandlerInvokedKey = "com.microsoft.kiota.response_handler_invoked";
-  FetchRequestAdapter.errorMappingFoundAttributeName = "com.microsoft.kiota.error.mapping_found";
-  FetchRequestAdapter.errorBodyFoundAttributeName = "com.microsoft.kiota.error.body_found";
-  FetchRequestAdapter.locationHeaderName = "Location";
-  FetchRequestAdapter.authenticateChallengedEventKey = "com.microsoft.kiota.authenticate_challenge_received";
-  const getRequestHeader = (options, key) => {
-    if (options && options.headers) {
-      return options.headers[key];
-    }
-    return void 0;
-  };
-  const setRequestHeader = (options, key, value) => {
-    if (options) {
-      if (!options.headers) {
-        options.headers = {};
-      }
-      options.headers[key] = value;
-    }
-  };
-  const deleteRequestHeader = (options, key) => {
-    if (options) {
-      if (!options.headers) {
-        options.headers = {};
-      }
-      delete options.headers[key];
-    }
-  };
-  const appendRequestHeader = (options, key, value, separator = ", ") => {
-    if (options) {
-      if (!options.headers) {
-        options.headers = {};
-      }
-      if (!options.headers[key]) {
-        options.headers[key] = value;
-      } else {
-        options.headers[key] += `${separator}${value}`;
-      }
-    }
-  };
-  var ChaosStrategy;
-  (function(ChaosStrategy2) {
-    ChaosStrategy2[ChaosStrategy2["MANUAL"] = 0] = "MANUAL";
-    ChaosStrategy2[ChaosStrategy2["RANDOM"] = 1] = "RANDOM";
-  })(ChaosStrategy || (ChaosStrategy = {}));
-  const CompressionHandlerOptionsKey = "CompressionHandlerOptionsKey";
-  class CompressionHandlerOptions {
-    /**
-     * Create a new instance of the CompressionHandlerOptions class
-     * @param config the configuration to apply to the compression handler options.
-     */
-    constructor(config) {
-      var _a;
-      this._enableCompression = (_a = config === null || config === void 0 ? void 0 : config.enableCompression) !== null && _a !== void 0 ? _a : true;
-    }
-    /**
-     * @inheritdoc
-     */
-    getKey() {
-      return CompressionHandlerOptionsKey;
-    }
-    /**
-     * Returns whether the compression handler is enabled or not.
-     * @returns whether the compression handler is enabled or not.
-     */
-    get ShouldCompress() {
-      return this._enableCompression;
-    }
-  }
-  class CompressionHandler {
-    /**
-     * Creates a new instance of the CompressionHandler class
-     * @param handlerOptions The options for the compression handler.
-     * @returns An instance of the CompressionHandler class
-     */
-    constructor(handlerOptions = new CompressionHandlerOptions()) {
-      this.handlerOptions = handlerOptions;
-      if (!handlerOptions) {
-        throw new Error("handlerOptions cannot be undefined");
-      }
-    }
-    /**
-     * @inheritdoc
-     */
-    execute(url, requestInit, requestOptions) {
-      let currentOptions = this.handlerOptions;
-      if (requestOptions === null || requestOptions === void 0 ? void 0 : requestOptions[CompressionHandlerOptionsKey]) {
-        currentOptions = requestOptions[CompressionHandlerOptionsKey];
-      }
-      const obsOptions = getObservabilityOptionsFromRequest(requestOptions);
-      if (obsOptions) {
-        return trace.getTracer(obsOptions.getTracerInstrumentationName()).startActiveSpan("compressionHandler - execute", (span) => {
-          try {
-            span.setAttribute("com.microsoft.kiota.handler.compression.enable", currentOptions.ShouldCompress);
-            return this.executeInternal(currentOptions, url, requestInit, requestOptions, span);
-          } finally {
-            span.end();
-          }
-        });
-      }
-      return this.executeInternal(currentOptions, url, requestInit, requestOptions);
-    }
-    async executeInternal(options, url, requestInit, requestOptions, span) {
-      var _a, _b, _c, _d;
-      if (!options.ShouldCompress || this.contentRangeBytesIsPresent(requestInit.headers) || this.contentEncodingIsPresent(requestInit.headers) || requestInit.body === null || requestInit.body === void 0) {
-        return (_b = (_a = this.next) === null || _a === void 0 ? void 0 : _a.execute(url, requestInit, requestOptions)) !== null && _b !== void 0 ? _b : Promise.reject(new Error("Response is undefined"));
-      }
-      span === null || span === void 0 ? void 0 : span.setAttribute("http.request.body.compressed", true);
-      const unCompressedBody = requestInit.body;
-      const unCompressedBodySize = this.getRequestBodySize(unCompressedBody);
-      const compressedBody = await this.compressRequestBody(unCompressedBody);
-      setRequestHeader(requestInit, CompressionHandler.CONTENT_ENCODING_HEADER, "gzip");
-      requestInit.body = compressedBody.compressedBody;
-      span === null || span === void 0 ? void 0 : span.setAttribute("http.request.body.size", compressedBody.size);
-      let response = await ((_c = this.next) === null || _c === void 0 ? void 0 : _c.execute(url, requestInit, requestOptions));
-      if (!response) {
-        throw new Error("Response is undefined");
-      }
-      if (response.status === 415) {
-        deleteRequestHeader(requestInit, CompressionHandler.CONTENT_ENCODING_HEADER);
-        requestInit.body = unCompressedBody;
-        span === null || span === void 0 ? void 0 : span.setAttribute("http.request.body.compressed", false);
-        span === null || span === void 0 ? void 0 : span.setAttribute("http.request.body.size", unCompressedBodySize);
-        response = await ((_d = this.next) === null || _d === void 0 ? void 0 : _d.execute(url, requestInit, requestOptions));
-      }
-      return response !== void 0 && response !== null ? Promise.resolve(response) : Promise.reject(new Error("Response is undefined"));
-    }
-    contentRangeBytesIsPresent(header) {
-      var _a;
-      if (!header) {
-        return false;
-      }
-      const contentRange = getRequestHeader(header, CompressionHandler.CONTENT_RANGE_HEADER);
-      return (_a = contentRange === null || contentRange === void 0 ? void 0 : contentRange.toLowerCase().includes("bytes")) !== null && _a !== void 0 ? _a : false;
-    }
-    contentEncodingIsPresent(header) {
-      if (!header) {
-        return false;
-      }
-      return getRequestHeader(header, CompressionHandler.CONTENT_ENCODING_HEADER) !== void 0;
-    }
-    getRequestBodySize(body) {
-      if (!body) {
-        return 0;
-      }
-      if (typeof body === "string") {
-        return body.length;
-      }
-      if (body instanceof Blob) {
-        return body.size;
-      }
-      if (body instanceof ArrayBuffer) {
-        return body.byteLength;
-      }
-      if (ArrayBuffer.isView(body)) {
-        return body.byteLength;
-      }
-      if (inNodeEnv() && Buffer.isBuffer(body)) {
-        return body.byteLength;
-      }
-      throw new Error("Unsupported body type");
-    }
-    readBodyAsBytes(body) {
-      if (!body) {
-        return { stream: new ReadableStream(), size: 0 };
-      }
-      const uint8ArrayToStream = (uint8Array) => {
-        return new ReadableStream({
-          start(controller) {
-            controller.enqueue(uint8Array);
-            controller.close();
-          }
-        });
-      };
-      if (typeof body === "string") {
-        return { stream: uint8ArrayToStream(new TextEncoder().encode(body)), size: body.length };
-      }
-      if (body instanceof Blob) {
-        return { stream: body.stream(), size: body.size };
-      }
-      if (body instanceof ArrayBuffer) {
-        return { stream: uint8ArrayToStream(new Uint8Array(body)), size: body.byteLength };
-      }
-      if (ArrayBuffer.isView(body)) {
-        return { stream: uint8ArrayToStream(new Uint8Array(body.buffer, body.byteOffset, body.byteLength)), size: body.byteLength };
-      }
-      throw new Error("Unsupported body type");
-    }
-    async compressRequestBody(body) {
-      const compressionData = this.readBodyAsBytes(body);
-      const compressedBody = await this.compressUsingCompressionStream(compressionData.stream);
-      return {
-        compressedBody: compressedBody.body,
-        size: compressedBody.size
-      };
-    }
-    async compressUsingCompressionStream(uint8ArrayStream) {
-      const compressionStream = new CompressionStream("gzip");
-      const compressedStream = uint8ArrayStream.pipeThrough(compressionStream);
-      const reader = compressedStream.getReader();
-      const compressedChunks = [];
-      let totalLength = 0;
-      let result = await reader.read();
-      while (!result.done) {
-        const chunk = result.value;
-        compressedChunks.push(chunk);
-        totalLength += chunk.length;
-        result = await reader.read();
-      }
-      const compressedArray = new Uint8Array(totalLength);
-      let offset = 0;
-      for (const chunk of compressedChunks) {
-        compressedArray.set(chunk, offset);
-        offset += chunk.length;
-      }
-      return {
-        body: compressedArray.buffer,
-        size: compressedArray.length
-      };
-    }
-  }
-  CompressionHandler.CONTENT_RANGE_HEADER = "Content-Range";
-  CompressionHandler.CONTENT_ENCODING_HEADER = "Content-Encoding";
-  const HeadersInspectionOptionsKey = "HeadersInspectionOptionsKey";
-  class HeadersInspectionOptions {
-    /**
-     * Gets the request headers
-     * @returns the request headers
-     */
-    getRequestHeaders() {
-      return this.requestHeaders;
-    }
-    /**
-     * Gets the response headers
-     * @returns the response headers
-     */
-    getResponseHeaders() {
-      return this.responseHeaders;
-    }
-    /**
-     *
-     * To create an instance of HeadersInspectionOptions
-     * @param [options] - The headers inspection options value
-     * @returns An instance of HeadersInspectionOptions
-     * @example const options = new HeadersInspectionOptions({ inspectRequestHeaders: true, inspectResponseHeaders: true });
-     */
-    constructor(options = {}) {
-      var _a, _b;
-      this.requestHeaders = new Headers();
-      this.responseHeaders = new Headers();
-      this.inspectRequestHeaders = (_a = options.inspectRequestHeaders) !== null && _a !== void 0 ? _a : false;
-      this.inspectResponseHeaders = (_b = options.inspectResponseHeaders) !== null && _b !== void 0 ? _b : false;
-    }
-    getKey() {
-      return HeadersInspectionOptionsKey;
-    }
-  }
-  class HeadersInspectionHandler {
-    /**
-     *
-     * Creates new instance of HeadersInspectionHandler
-     * @param _options The options for inspecting the headers
-     */
-    constructor(_options = new HeadersInspectionOptions()) {
-      this._options = _options;
-    }
-    execute(url, requestInit, requestOptions) {
-      let currentOptions = this._options;
-      if (requestOptions === null || requestOptions === void 0 ? void 0 : requestOptions[HeadersInspectionOptionsKey]) {
-        currentOptions = requestOptions[HeadersInspectionOptionsKey];
-      }
-      const obsOptions = getObservabilityOptionsFromRequest(requestOptions);
-      if (obsOptions) {
-        return trace.getTracer(obsOptions.getTracerInstrumentationName()).startActiveSpan("retryHandler - execute", (span) => {
-          try {
-            span.setAttribute("com.microsoft.kiota.handler.headersInspection.enable", true);
-            return this.executeInternal(url, requestInit, requestOptions, currentOptions);
-          } finally {
-            span.end();
-          }
-        });
-      }
-      return this.executeInternal(url, requestInit, requestOptions, currentOptions);
-    }
-    async executeInternal(url, requestInit, requestOptions, currentOptions) {
-      if (!this.next) {
-        throw new Error("next middleware is undefined.");
-      }
-      if (currentOptions.inspectRequestHeaders && requestInit.headers) {
-        for (const [key, value] of requestInit.headers) {
-          currentOptions.getRequestHeaders().add(key, value);
-        }
-      }
-      const response = await this.next.execute(url, requestInit, requestOptions);
-      if (currentOptions.inspectResponseHeaders && response.headers) {
-        for (const [key, value] of response.headers.entries()) {
-          currentOptions.getResponseHeaders().add(key, value);
-        }
-      }
-      return response;
-    }
-  }
-  const ParametersNameDecodingHandlerOptionsKey = "RetryHandlerOptionKey";
-  class ParametersNameDecodingHandlerOptions {
-    getKey() {
-      return ParametersNameDecodingHandlerOptionsKey;
-    }
-    /**
-     *
-     * To create an instance of ParametersNameDecodingHandlerOptions
-     * @param [options] - The optional parameters
-     * @returns An instance of ParametersNameDecodingHandlerOptions
-     * @example ParametersNameDecodingHandlerOptions({ enable: true, charactersToDecode: [".", "-", "~", "$"] });
-     */
-    constructor(options = {}) {
-      var _a, _b;
-      this.enable = (_a = options.enable) !== null && _a !== void 0 ? _a : true;
-      this.charactersToDecode = (_b = options.charactersToDecode) !== null && _b !== void 0 ? _b : [".", "-", "~", "$"];
-    }
-  }
-  class ParametersNameDecodingHandler {
-    /**
-     *
-     * To create an instance of ParametersNameDecodingHandler
-     * @param [options] - The parameters name decoding handler options value
-     */
-    constructor(options = new ParametersNameDecodingHandlerOptions()) {
-      this.options = options;
-      if (!options) {
-        throw new Error("The options parameter is required.");
-      }
-    }
-    /**
-     * To execute the current middleware
-     * @param url - The url to be fetched
-     * @param requestInit - The request init object
-     * @param requestOptions - The request options
-     * @returns A Promise that resolves to nothing
-     */
-    execute(url, requestInit, requestOptions) {
-      let currentOptions = this.options;
-      if (requestOptions === null || requestOptions === void 0 ? void 0 : requestOptions[ParametersNameDecodingHandlerOptionsKey]) {
-        currentOptions = requestOptions[ParametersNameDecodingHandlerOptionsKey];
-      }
-      const obsOptions = getObservabilityOptionsFromRequest(requestOptions);
-      if (obsOptions) {
-        return trace.getTracer(obsOptions.getTracerInstrumentationName()).startActiveSpan("parametersNameDecodingHandler - execute", (span) => {
-          try {
-            span.setAttribute("com.microsoft.kiota.handler.parameters_name_decoding.enable", currentOptions.enable);
-            return this.decodeParameters(url, requestInit, currentOptions, requestOptions);
-          } finally {
-            span.end();
-          }
-        });
-      }
-      return this.decodeParameters(url, requestInit, currentOptions, requestOptions);
-    }
-    decodeParameters(url, requestInit, currentOptions, requestOptions) {
-      var _a, _b;
-      let updatedUrl = url;
-      if (currentOptions && currentOptions.enable && url.includes("%") && currentOptions.charactersToDecode && currentOptions.charactersToDecode.length > 0) {
-        currentOptions.charactersToDecode.forEach((character) => {
-          updatedUrl = updatedUrl.replace(new RegExp(`%${character.charCodeAt(0).toString(16)}`, "gi"), character);
-        });
-      }
-      return (_b = (_a = this.next) === null || _a === void 0 ? void 0 : _a.execute(updatedUrl, requestInit, requestOptions)) !== null && _b !== void 0 ? _b : Promise.reject(new Error("The next middleware is not set."));
-    }
-  }
-  const RedirectHandlerOptionKey = "RedirectHandlerOption";
-  class RedirectHandlerOptions {
-    /**
-     *
-     * To create an instance of RedirectHandlerOptions
-     * @param [options] - The redirect handler options instance
-     * @returns An instance of RedirectHandlerOptions
-     * @throws Error if maxRedirects is more than 20 or less than 0
-     * @example	const options = new RedirectHandlerOptions({ maxRedirects: 5 });
-     */
-    constructor(options = {}) {
-      var _a, _b;
-      if (options.maxRedirects && options.maxRedirects > RedirectHandlerOptions.MAX_MAX_REDIRECTS) {
-        const error = new Error(`MaxRedirects should not be more than ${RedirectHandlerOptions.MAX_MAX_REDIRECTS}`);
-        error.name = "MaxLimitExceeded";
-        throw error;
-      }
-      if (options.maxRedirects !== void 0 && options.maxRedirects < 0) {
-        const error = new Error(`MaxRedirects should not be negative`);
-        error.name = "MinExpectationNotMet";
-        throw error;
-      }
-      this.maxRedirects = (_a = options.maxRedirects) !== null && _a !== void 0 ? _a : RedirectHandlerOptions.DEFAULT_MAX_REDIRECTS;
-      this.shouldRedirect = (_b = options.shouldRedirect) !== null && _b !== void 0 ? _b : RedirectHandlerOptions.defaultShouldRetry;
-    }
-    getKey() {
-      return RedirectHandlerOptionKey;
-    }
-  }
-  RedirectHandlerOptions.DEFAULT_MAX_REDIRECTS = 5;
-  RedirectHandlerOptions.MAX_MAX_REDIRECTS = 20;
-  RedirectHandlerOptions.defaultShouldRetry = () => true;
-  class RedirectHandler {
-    /**
-     *
-     *
-     * To create an instance of RedirectHandler
-     * @param [options] - The redirect handler options instance
-     * @returns An instance of RedirectHandler
-     */
-    constructor(options = new RedirectHandlerOptions()) {
-      this.options = options;
-      if (!options) {
-        throw new Error("The options parameter is required.");
-      }
-    }
-    /**
-     *
-     * To check whether the response has the redirect status code or not
-     * @param response - The response object
-     * @returns A boolean representing whether the response contains the redirect status code or not
-     */
-    isRedirect(response) {
-      return RedirectHandler.REDIRECT_STATUS_CODES.has(response.status);
-    }
-    /**
-     *
-     * To check whether the response has location header or not
-     * @param response - The response object
-     * @returns A boolean representing the whether the response has location header or not
-     */
-    hasLocationHeader(response) {
-      return response.headers.has(RedirectHandler.LOCATION_HEADER);
-    }
-    /**
-     *
-     * To get the redirect url from location header in response object
-     * @param response - The response object
-     * @returns A redirect url from location header
-     */
-    getLocationHeader(response) {
-      return response.headers.get(RedirectHandler.LOCATION_HEADER);
-    }
-    /**
-     *
-     * To check whether the given url is a relative url or not
-     * @param url - The url string value
-     * @returns A boolean representing whether the given url is a relative url or not
-     */
-    isRelativeURL(url) {
-      return !url.includes("://");
-    }
-    /**
-     *
-     * To check whether the authorization header in the request should be dropped for consequent redirected requests
-     * @param requestUrl - The request url value
-     * @param redirectUrl - The redirect url value
-     * @returns A boolean representing whether the authorization header in the request should be dropped for consequent redirected requests
-     */
-    shouldDropAuthorizationHeader(requestUrl, redirectUrl) {
-      const schemeHostRegex = /^[A-Za-z].+?:\/\/.+?(?=\/|$)/;
-      const requestMatches = schemeHostRegex.exec(requestUrl);
-      let requestAuthority;
-      let redirectAuthority;
-      if (requestMatches !== null) {
-        requestAuthority = requestMatches[0];
-      }
-      const redirectMatches = schemeHostRegex.exec(redirectUrl);
-      if (redirectMatches !== null) {
-        redirectAuthority = redirectMatches[0];
-      }
-      return typeof requestAuthority !== "undefined" && typeof redirectAuthority !== "undefined" && requestAuthority !== redirectAuthority;
-    }
-    /**
-     * To execute the next middleware and to handle in case of redirect response returned by the server
-     * @param url - The url string value
-     * @param fetchRequestInit - The Fetch RequestInit object
-     * @param redirectCount - The redirect count value
-     * @param currentOptions - The redirect handler options instance
-     * @param requestOptions - The request options
-     * @param tracerName - The name to use for the tracer
-     * @returns A promise that resolves to nothing
-     */
-    async executeWithRedirect(url, fetchRequestInit, redirectCount, currentOptions, requestOptions, tracerName) {
-      var _a;
-      const response = await ((_a = this.next) === null || _a === void 0 ? void 0 : _a.execute(url, fetchRequestInit, requestOptions));
-      if (!response) {
-        throw new Error("Response is undefined");
-      }
-      if (redirectCount < currentOptions.maxRedirects && this.isRedirect(response) && this.hasLocationHeader(response) && currentOptions.shouldRedirect(response)) {
-        ++redirectCount;
-        if (response.status === RedirectHandler.STATUS_CODE_SEE_OTHER) {
-          fetchRequestInit.method = HttpMethod.GET;
-          delete fetchRequestInit.body;
-        } else {
-          const redirectUrl = this.getLocationHeader(response);
-          if (redirectUrl) {
-            if (fetchRequestInit.headers && !this.isRelativeURL(redirectUrl) && this.shouldDropAuthorizationHeader(url, redirectUrl)) {
-              delete fetchRequestInit.headers[RedirectHandler.AUTHORIZATION_HEADER];
-            }
-            url = redirectUrl;
-          }
-        }
-        if (tracerName) {
-          return trace.getTracer(tracerName).startActiveSpan(`redirectHandler - redirect ${redirectCount}`, (span) => {
-            try {
-              span.setAttribute("com.microsoft.kiota.handler.redirect.count", redirectCount);
-              span.setAttribute("http.response.status_code", response.status);
-              return this.executeWithRedirect(url, fetchRequestInit, redirectCount, currentOptions, requestOptions);
-            } finally {
-              span.end();
-            }
-          });
-        }
-        return await this.executeWithRedirect(url, fetchRequestInit, redirectCount, currentOptions, requestOptions);
-      } else {
-        return response;
-      }
-    }
-    /**
-     * Executes the request and returns a promise resolving the response.
-     * @param url - The url for the request
-     * @param requestInit - The Fetch RequestInit object.
-     * @param requestOptions - The request options.
-     * @returns A Promise that resolves to the response.
-     */
-    execute(url, requestInit, requestOptions) {
-      const redirectCount = 0;
-      let currentOptions = this.options;
-      if (requestOptions === null || requestOptions === void 0 ? void 0 : requestOptions[RedirectHandlerOptionKey]) {
-        currentOptions = requestOptions[RedirectHandlerOptionKey];
-      }
-      requestInit.redirect = RedirectHandler.MANUAL_REDIRECT;
-      const obsOptions = getObservabilityOptionsFromRequest(requestOptions);
-      if (obsOptions) {
-        return trace.getTracer(obsOptions.getTracerInstrumentationName()).startActiveSpan("redirectHandler - execute", (span) => {
-          try {
-            span.setAttribute("com.microsoft.kiota.handler.redirect.enable", true);
-            return this.executeWithRedirect(url, requestInit, redirectCount, currentOptions, requestOptions, obsOptions.getTracerInstrumentationName());
-          } finally {
-            span.end();
-          }
-        });
-      }
-      return this.executeWithRedirect(url, requestInit, redirectCount, currentOptions, requestOptions);
-    }
-  }
-  RedirectHandler.REDIRECT_STATUS_CODES = /* @__PURE__ */ new Set([
-    301,
-    // Moved Permanently
-    302,
-    // Found
-    303,
-    // See Other
-    307,
-    // Temporary Permanently
-    308
-    // Moved Permanently
-  ]);
-  RedirectHandler.STATUS_CODE_SEE_OTHER = 303;
-  RedirectHandler.LOCATION_HEADER = "Location";
-  RedirectHandler.AUTHORIZATION_HEADER = "Authorization";
-  RedirectHandler.MANUAL_REDIRECT = "manual";
-  const RetryHandlerOptionKey = "RetryHandlerOptionKey";
-  class RetryHandlerOptions {
-    /**
-     *
-     * To create an instance of RetryHandlerOptions
-     * @param options - The RetryHandlerOptionsParams object
-     * @returns An instance of RetryHandlerOptions
-     * @example	const options = new RetryHandlerOptions({ maxRetries: 4 });
-     */
-    constructor(options = {}) {
-      var _a, _b, _c;
-      if (options.delay !== void 0 && options.delay > RetryHandlerOptions.MAX_DELAY) {
-        throw this.createError(`Delay should not be more than ${RetryHandlerOptions.MAX_DELAY}`, "MaxLimitExceeded");
-      }
-      if (options.maxRetries !== void 0 && options.maxRetries > RetryHandlerOptions.MAX_MAX_RETRIES) {
-        throw this.createError(`MaxRetries should not be more than ${RetryHandlerOptions.MAX_MAX_RETRIES}`, "MaxLimitExceeded");
-      }
-      if (options.delay !== void 0 && options.delay < 0) {
-        throw this.createError(`Delay should not be negative`, "MinExpectationNotMet");
-      }
-      if (options.maxRetries !== void 0 && options.maxRetries < 0) {
-        throw this.createError(`MaxRetries should not be negative`, "MinExpectationNotMet");
-      }
-      this.delay = Math.min((_a = options.delay) !== null && _a !== void 0 ? _a : RetryHandlerOptions.DEFAULT_DELAY, RetryHandlerOptions.MAX_DELAY);
-      this.maxRetries = Math.min((_b = options.maxRetries) !== null && _b !== void 0 ? _b : RetryHandlerOptions.DEFAULT_MAX_RETRIES, RetryHandlerOptions.MAX_MAX_RETRIES);
-      this.shouldRetry = (_c = options.shouldRetry) !== null && _c !== void 0 ? _c : RetryHandlerOptions.defaultShouldRetry;
-    }
-    /**
-     *
-     * Creates an error object with a message and name
-     * @param message - The error message
-     * @param name - The error name
-     * @returns An error object
-     */
-    createError(message, name) {
-      const error = new Error(message);
-      error.name = name;
-      return error;
-    }
-    /**
-     *
-     * To get the maximum delay
-     * @returns A maximum delay
-     */
-    getMaxDelay() {
-      return RetryHandlerOptions.MAX_DELAY;
-    }
-    getKey() {
-      return RetryHandlerOptionKey;
-    }
-  }
-  RetryHandlerOptions.DEFAULT_DELAY = 3;
-  RetryHandlerOptions.DEFAULT_MAX_RETRIES = 3;
-  RetryHandlerOptions.MAX_DELAY = 180;
-  RetryHandlerOptions.MAX_MAX_RETRIES = 10;
-  RetryHandlerOptions.defaultShouldRetry = () => true;
-  class RetryHandler {
-    /**
-     *
-     * To create an instance of RetryHandler
-     * @param [options] - The retry handler options value
-     * @returns An instance of RetryHandler
-     */
-    constructor(options = new RetryHandlerOptions()) {
-      this.options = options;
-      if (!options) {
-        throw new Error("The options parameter is required.");
-      }
-    }
-    /**
-     *
-     *
-     * To check whether the response has the retry status code
-     * @param response - The response object
-     * @returns Whether the response has retry status code or not
-     */
-    isRetry(response) {
-      return RetryHandler.RETRY_STATUS_CODES.has(response.status);
-    }
-    /**
-     *
-     * To check whether the payload is buffered or not
-     * @param options - The options of a request
-     * @returns Whether the payload is buffered or not
-     */
-    isBuffered(options) {
-      var _a;
-      const method = options.method;
-      const isPutPatchOrPost = method === HttpMethod.PUT || method === HttpMethod.PATCH || method === HttpMethod.POST;
-      if (isPutPatchOrPost) {
-        const isStream = ((_a = getRequestHeader(options, "content-type")) === null || _a === void 0 ? void 0 : _a.toLowerCase()) === "application/octet-stream";
-        if (isStream) {
-          return false;
-        }
-      }
-      return true;
-    }
-    /**
-     *
-     * To get the delay for a retry
-     * @param response - The response object
-     * @param retryAttempts - The current attempt count
-     * @param delay - The delay value in seconds
-     * @returns A delay for a retry
-     */
-    getDelay(response, retryAttempts, delay) {
-      const getRandomness = () => Number(Math.random().toFixed(3));
-      const retryAfter = response.headers !== void 0 ? response.headers.get(RetryHandler.RETRY_AFTER_HEADER) : null;
-      let newDelay;
-      if (retryAfter !== null) {
-        if (Number.isNaN(Number(retryAfter))) {
-          newDelay = Math.round((new Date(retryAfter).getTime() - Date.now()) / 1e3);
-        } else {
-          newDelay = Number(retryAfter);
-        }
-      } else {
-        newDelay = retryAttempts >= 2 ? this.getExponentialBackOffTime(retryAttempts) + delay + getRandomness() : delay + getRandomness();
-      }
-      return Math.min(newDelay, this.options.getMaxDelay() + getRandomness());
-    }
-    /**
-     *
-     * To get an exponential back off value
-     * @param attempts - The current attempt count
-     * @returns An exponential back off value
-     */
-    getExponentialBackOffTime(attempts) {
-      return Math.round(1 / 2 * (2 ** attempts - 1));
-    }
-    /**
-     * To add delay for the execution
-     * @param delaySeconds - The delay value in seconds
-     * @returns A Promise that resolves to nothing
-     */
-    async sleep(delaySeconds) {
-      const delayMilliseconds = delaySeconds * 1e3;
-      return new Promise((resolve) => setTimeout(resolve, delayMilliseconds));
-    }
-    /**
-     * To execute the middleware with retries
-     * @param url - The request url
-     * @param fetchRequestInit - The request options
-     * @param retryAttempts - The current attempt count
-     * @param currentOptions - The current request options for the retry handler.
-     * @param requestOptions - The retry middleware options instance
-     * @param tracerName - The name to use for the tracer
-     * @returns A Promise that resolves to nothing
-     */
-    async executeWithRetry(url, fetchRequestInit, retryAttempts, currentOptions, requestOptions, tracerName) {
-      var _a;
-      const response = await ((_a = this.next) === null || _a === void 0 ? void 0 : _a.execute(url, fetchRequestInit, requestOptions));
-      if (!response) {
-        throw new Error("Response is undefined");
-      }
-      if (retryAttempts < currentOptions.maxRetries && this.isRetry(response) && this.isBuffered(fetchRequestInit) && currentOptions.shouldRetry(currentOptions.delay, retryAttempts, url, fetchRequestInit, response)) {
-        ++retryAttempts;
-        setRequestHeader(fetchRequestInit, RetryHandler.RETRY_ATTEMPT_HEADER, retryAttempts.toString());
-        let delay = null;
-        if (response) {
-          delay = this.getDelay(response, retryAttempts, currentOptions.delay);
-          await this.sleep(delay);
-        }
-        if (tracerName) {
-          return await trace.getTracer(tracerName).startActiveSpan(`retryHandler - attempt ${retryAttempts}`, (span) => {
-            try {
-              span.setAttribute("http.request.resend_count", retryAttempts);
-              if (delay) {
-                span.setAttribute("http.request.resend_delay", delay);
-              }
-              span.setAttribute("http.response.status_code", response.status);
-              return this.executeWithRetry(url, fetchRequestInit, retryAttempts, currentOptions, requestOptions);
-            } finally {
-              span.end();
-            }
-          });
-        }
-        return await this.executeWithRetry(url, fetchRequestInit, retryAttempts, currentOptions, requestOptions);
-      } else {
-        return response;
-      }
-    }
-    /**
-     * To execute the current middleware
-     * @param url - The request url
-     * @param requestInit - The request options
-     * @param requestOptions - The request options
-     * @returns A Promise that resolves to nothing
-     */
-    execute(url, requestInit, requestOptions) {
-      const retryAttempts = 0;
-      let currentOptions = this.options;
-      if (requestOptions === null || requestOptions === void 0 ? void 0 : requestOptions[RetryHandlerOptionKey]) {
-        currentOptions = requestOptions[RetryHandlerOptionKey];
-      }
-      const obsOptions = getObservabilityOptionsFromRequest(requestOptions);
-      if (obsOptions) {
-        return trace.getTracer(obsOptions.getTracerInstrumentationName()).startActiveSpan("retryHandler - execute", (span) => {
-          try {
-            span.setAttribute("com.microsoft.kiota.handler.retry.enable", true);
-            return this.executeWithRetry(url, requestInit, retryAttempts, currentOptions, requestOptions, obsOptions.getTracerInstrumentationName());
-          } finally {
-            span.end();
-          }
-        });
-      }
-      return this.executeWithRetry(url, requestInit, retryAttempts, currentOptions, requestOptions);
-    }
-  }
-  RetryHandler.RETRY_STATUS_CODES = /* @__PURE__ */ new Set([
-    429,
-    // Too many requests
-    503,
-    // Service unavailable
-    504
-    // Gateway timeout
-  ]);
-  RetryHandler.RETRY_ATTEMPT_HEADER = "Retry-Attempt";
-  RetryHandler.RETRY_AFTER_HEADER = "Retry-After";
-  const libraryVersion = "1.0.0-preview.24";
-  const UserAgentHandlerOptionsKey = "UserAgentHandlerOptionKey";
-  class UserAgentHandlerOptions {
-    getKey() {
-      return UserAgentHandlerOptionsKey;
-    }
-    /**
-     *
-     * To create an instance of UserAgentHandlerOptions
-     * @param [options] - The options for the UserAgentHandler
-     * @example	const options = new UserAgentHandlerOptions({ enable: false });
-     */
-    constructor(options = {}) {
-      var _a, _b, _c;
-      this.enable = (_a = options.enable) !== null && _a !== void 0 ? _a : true;
-      this.productName = (_b = options.productName) !== null && _b !== void 0 ? _b : "kiota-typescript";
-      this.productVersion = (_c = options.productVersion) !== null && _c !== void 0 ? _c : libraryVersion;
-    }
-  }
-  const USER_AGENT_HEADER_KEY = "User-Agent";
-  class UserAgentHandler {
-    /**
-     * To create an instance of UserAgentHandler
-     * @param _options - The options for the middleware
-     */
-    constructor(_options = new UserAgentHandlerOptions()) {
-      this._options = _options;
-    }
-    /** @inheritdoc */
-    execute(url, requestInit, requestOptions) {
-      const obsOptions = getObservabilityOptionsFromRequest(requestOptions);
-      if (obsOptions) {
-        return trace.getTracer(obsOptions.getTracerInstrumentationName()).startActiveSpan("userAgentHandler - execute", (span) => {
-          try {
-            span.setAttribute("com.microsoft.kiota.handler.useragent.enable", true);
-            return this.addValue(url, requestInit, requestOptions);
-          } finally {
-            span.end();
-          }
-        });
-      } else {
-        return this.addValue(url, requestInit, requestOptions);
-      }
-    }
-    async addValue(url, requestInit, requestOptions) {
-      var _a;
-      let currentOptions = this._options;
-      if (requestOptions === null || requestOptions === void 0 ? void 0 : requestOptions[UserAgentHandlerOptionsKey]) {
-        currentOptions = requestOptions[UserAgentHandlerOptionsKey];
-      }
-      if (currentOptions.enable) {
-        const additionalValue = `${currentOptions.productName}/${currentOptions.productVersion}`;
-        const currentValue = getRequestHeader(requestInit, USER_AGENT_HEADER_KEY);
-        if (!(currentValue === null || currentValue === void 0 ? void 0 : currentValue.includes(additionalValue))) {
-          appendRequestHeader(requestInit, USER_AGENT_HEADER_KEY, additionalValue, " ");
-        }
-      }
-      const response = await ((_a = this.next) === null || _a === void 0 ? void 0 : _a.execute(url, requestInit, requestOptions));
-      if (!response)
-        throw new Error("No response returned by the next middleware");
-      return response;
-    }
-  }
-  const UrlReplaceHandlerOptionsKey = "UrlReplaceHandlerOptionsKey";
-  class UrlReplaceHandlerOptions {
-    /**
-     * Create a new instance of the UrlReplaceHandlerOptions class
-     * @param config the configuration to apply to the url replace handler options.
-     */
-    constructor(config) {
-      var _a, _b;
-      if (config) {
-        this._urlReplacements = (_a = config.urlReplacements) !== null && _a !== void 0 ? _a : {};
-        this._enabled = (_b = config.enabled) !== null && _b !== void 0 ? _b : true;
-      } else {
-        this._urlReplacements = {};
-        this._enabled = true;
-      }
-    }
-    /**
-     * @inheritdoc
-     */
-    getKey() {
-      return UrlReplaceHandlerOptionsKey;
-    }
-    /**
-     * Returns whether the url replace handler is enabled or not.
-     * @returns whether the url replace handler is enabled or not.
-     */
-    get enabled() {
-      return this._enabled;
-    }
-    /**
-     * Returns the url replacements combinations.
-     * @returns the url replacements combinations.
-     */
-    get urlReplacements() {
-      return this._urlReplacements;
-    }
-  }
-  class UrlReplaceHandler {
-    /**
-     *
-     * Creates a new instance of the UrlReplaceHandler class
-     * @param handlerOptions The options for the url replace handler.
-     * @returns An instance of the UrlReplaceHandler class
-     */
-    constructor(handlerOptions = new UrlReplaceHandlerOptions()) {
-      this.handlerOptions = handlerOptions;
-      if (!handlerOptions) {
-        throw new Error("handlerOptions cannot be undefined");
-      }
-    }
-    /**
-     * @inheritdoc
-     */
-    execute(url, requestInit, requestOptions) {
-      let currentOptions = this.handlerOptions;
-      if (requestOptions === null || requestOptions === void 0 ? void 0 : requestOptions[UrlReplaceHandlerOptionsKey]) {
-        currentOptions = requestOptions[UrlReplaceHandlerOptionsKey];
-      }
-      const obsOptions = getObservabilityOptionsFromRequest(requestOptions);
-      if (obsOptions) {
-        return trace.getTracer(obsOptions.getTracerInstrumentationName()).startActiveSpan("urlReplaceHandler - execute", (span) => {
-          try {
-            span.setAttribute("com.microsoft.kiota.handler.urlReplace.enable", currentOptions.enabled);
-            return this.replaceTokensInUrl(currentOptions, url, requestInit, requestOptions);
-          } finally {
-            span.end();
-          }
-        });
-      }
-      return this.replaceTokensInUrl(currentOptions, url, requestInit, requestOptions);
-    }
-    replaceTokensInUrl(options, url, requestInit, requestOptions) {
-      var _a;
-      if (options.enabled) {
-        Object.keys(options.urlReplacements).forEach((replacementKey) => {
-          url = url.replace(replacementKey, options.urlReplacements[replacementKey]);
-        });
-      }
-      const response = (_a = this.next) === null || _a === void 0 ? void 0 : _a.execute(url, requestInit, requestOptions);
-      if (!response) {
-        throw new Error("Response is undefined");
-      }
-      return response;
-    }
-  }
-  class MiddlewareFactory {
-    /**
-     * @param customFetch - The custom fetch implementation
-     * Returns the default middleware chain an array with the  middleware handlers
-     * @returns an array of the middleware handlers of the default middleware chain
-     */
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-    static getDefaultMiddlewares(customFetch = (...args) => fetch(...args)) {
-      return [new RetryHandler(), new RedirectHandler(), new ParametersNameDecodingHandler(), new UserAgentHandler(), new HeadersInspectionHandler(), new UrlReplaceHandler(), new CustomFetchHandler(customFetch)];
-    }
-    /**
-     * @param customFetch - The custom fetch implementation
-     * Returns the default middleware chain + performance middleware
-     * @returns an array of the middleware handlers of the default + performance middleware chain
-     */
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-    static getPerformanceMiddlewares(customFetch = (...args) => fetch(...args)) {
-      const middlewares = MiddlewareFactory.getDefaultMiddlewares(customFetch);
-      middlewares.splice(middlewares.length - 3, 0, new CompressionHandler());
-      return middlewares;
-    }
-  }
-  const ErrorHandlerOptionKey = "ErrorHandlerOptionKey";
-  class ErrorHandlerOptions {
-    constructor(enabled = true) {
-      this.enabled = enabled;
-    }
-    getKey() {
-      return ErrorHandlerOptionKey;
-    }
-  }
-  class ErrorHandler {
-    /**
-     *
-     * To create an instance of ErrorHandler
-     * @param [options] - The error handler options value
-     * @returns An instance of ErrorHandler
-     */
-    constructor(options = new ErrorHandlerOptions()) {
-      this.options = options;
-    }
-    /**
-     *
-     * The next middleware in the middleware chain
-     */
-    next;
-    /**
-     * To execute the current middleware
-     * @param url - The request url
-     * @param requestInit - The request options
-     * @param requestOptions - The request options
-     * @returns A Promise that resolves to nothing
-     */
-    async execute(url, requestInit, requestOptions) {
-      const response = await this.next?.execute(url, requestInit, requestOptions);
-      if (!response) {
-        throw new Error("Response is undefined");
-      }
-      let currentOptions = this.options;
-      if (requestOptions?.[ErrorHandlerOptionKey]) {
-        currentOptions = requestOptions[ErrorHandlerOptionKey];
-      }
-      if (currentOptions.enabled === false || this.isSuccessStatusCode(response)) {
-        return response;
-      }
-      const obsOptions = getObservabilityOptionsFromRequest(requestOptions);
-      if (obsOptions) {
-        trace.getTracer(obsOptions.getTracerInstrumentationName()).startActiveSpan("retryHandler - execute", (span) => {
-          span.setAttribute("com.microsoft.kiota.handler.error.enable", true);
-          span.setAttribute("http.response.status_code", response.status);
-          span.setAttribute("http.response.status_text", response.statusText);
-          span.setAttribute("http.response.url", response.url);
-          span.end();
-        });
-      }
-      const err = new HttpRequestError(
-        `Request to ${url} failed with status code ${response.status}`,
-        response.status,
-        { url, request: requestInit, response }
-      );
-      throw err;
-    }
-    isSuccessStatusCode(response) {
-      return response.status >= 200 && response.status < 300;
-    }
-  }
-  class HttpRequestError extends Error {
-    constructor(message, statusCode, context) {
-      super(message);
-      this.statusCode = statusCode;
-      this.name = "HttpRequestError";
-      if (Error.captureStackTrace) {
-        Error.captureStackTrace(this, HttpRequestError);
-      }
-    }
-  }
-  class AccessTokenProvider {
-    constructor(getAccessToken) {
-      this.getAccessToken = getAccessToken;
-    }
-    async getAuthorizationToken(url, additionalAuthenticationContext) {
-      return await this.getAccessToken();
-    }
-    getAllowedHostsValidator() {
-      throw new Error("Method not implemented.");
-    }
-  }
-  class HttpClientFactory {
-    static create(customFetch) {
-      const middlewares = [new ErrorHandler(), ...MiddlewareFactory.getDefaultMiddlewares(customFetch)];
-      return new HttpClient(customFetch, ...middlewares);
-    }
-    static createFetchRequestAdapter(getAccessToken, httpClient) {
-      const auth = new BaseBearerTokenAuthenticationProvider(new AccessTokenProvider(getAccessToken));
-      return new FetchRequestAdapter(
-        auth,
-        void 0,
-        void 0,
-        httpClient
-      );
-    }
-  }
-  exports2.HttpClientFactory = HttpClientFactory;
-  Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
-}));
-//# sourceMappingURL=index.umd.js.map