@adsk-platform/httpclient 0.1.0 → 0.1.1

package/_dist/index.es.js

@@ -1,3393 +0,0 @@
-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$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$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$3(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$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 __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$2 = "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$2(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$2, 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;
-  })()
-);
-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 __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$1 = "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$1, 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$1) || NOOP_CONTEXT_MANAGER;
-    };
-    ContextAPI2.prototype.disable = function() {
-      this._getContextManager().disable();
-      unregisterGlobal(API_NAME$1, 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 = {}));
-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(exports) {
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.serialize = exports.parse = exports.MultipleFractionsError = exports.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(",", "."));
-    }
-    exports.InvalidDurationError = new Error("Invalid duration");
-    exports.MultipleFractionsError = new Error("Multiple fractions specified");
-    function parse(durationStr, config = DEFAULT_PARSE_CONFIG) {
-      const match = durationRegex.exec(durationStr);
-      if (!match || !match.groups) {
-        throw exports.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 exports.MultipleFractionsError;
-            }
-          }
-        }
-      }
-      if (empty) {
-        throw exports.InvalidDurationError;
-      }
-      const duration = values;
-      if (match.groups.negative) {
-        duration.negative = true;
-      }
-      return duration;
-    }
-    exports.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("");
-    }
-    exports.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
-    );
-  }
-}
-export {
-  HttpClientFactory
-};
-//# sourceMappingURL=index.es.js.map