text: /** @license ms-rest-js
    * Copyright (c) Microsoft Corporation. All rights reserved.
    * Licensed under the MIT License. See License.txt and ThirdPartyNotices.txt in the project root for license information.
    */
  'use strict';
  
  Object.defineProperty(exports, '__esModule', { value: true });
  
  function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
  
  var uuidv4 = _interopDefault(require('uuid/v4'));
  var tslib = require('tslib');
  var tough = require('tough-cookie');
  var http = require('http');
  var https = require('https');
  var node_fetch = _interopDefault(require('node-fetch'));
  var FormData = _interopDefault(require('form-data'));
  var stream = require('stream');
  var tunnel = require('tunnel');
  var xml2js = require('xml2js');
  var os = require('os');
  
  // Copyright (c) Microsoft Corporation. All rights reserved.
  // Licensed under the MIT License. See License.txt in the project root for license information.
  /**
   * A collection of HttpHeaders that can be sent with a HTTP request.
   */
  function getHeaderKey(headerName) {
      return headerName.toLowerCase();
  }
  function isHttpHeadersLike(object) {
      if (!object || typeof object !== "object") {
          return false;
      }
      if (typeof object.rawHeaders === "function" &&
          typeof object.clone === "function" &&
          typeof object.get === "function" &&
          typeof object.set === "function" &&
          typeof object.contains === "function" &&
          typeof object.remove === "function" &&
          typeof object.headersArray === "function" &&
          typeof object.headerValues === "function" &&
          typeof object.headerNames === "function" &&
          typeof object.toJson === "function") {
          return true;
      }
      return false;
  }
  /**
   * A collection of HTTP header key/value pairs.
   */
  var HttpHeaders = /** @class */ (function () {
      function HttpHeaders(rawHeaders) {
          this._headersMap = {};
          if (rawHeaders) {
              for (var headerName in rawHeaders) {
                  this.set(headerName, rawHeaders[headerName]);
              }
          }
      }
      /**
       * Set a header in this collection with the provided name and value. The name is
       * case-insensitive.
       * @param headerName The name of the header to set. This value is case-insensitive.
       * @param headerValue The value of the header to set.
       */
      HttpHeaders.prototype.set = function (headerName, headerValue) {
          this._headersMap[getHeaderKey(headerName)] = {
              name: headerName,
              value: headerValue.toString(),
          };
      };
      /**
       * Get the header value for the provided header name, or undefined if no header exists in this
       * collection with the provided name.
       * @param headerName The name of the header.
       */
      HttpHeaders.prototype.get = function (headerName) {
          var header = this._headersMap[getHeaderKey(headerName)];
          return !header ? undefined : header.value;
      };
      /**
       * Get whether or not this header collection contains a header entry for the provided header name.
       */
      HttpHeaders.prototype.contains = function (headerName) {
          return !!this._headersMap[getHeaderKey(headerName)];
      };
      /**
       * Remove the header with the provided headerName. Return whether or not the header existed and
       * was removed.
       * @param headerName The name of the header to remove.
       */
      HttpHeaders.prototype.remove = function (headerName) {
          var result = this.contains(headerName);
          delete this._headersMap[getHeaderKey(headerName)];
          return result;
      };
      /**
       * Get the headers that are contained this collection as an object.
       */
      HttpHeaders.prototype.rawHeaders = function () {
          var result = {};
          for (var headerKey in this._headersMap) {
              var header = this._headersMap[headerKey];
              result[header.name.toLowerCase()] = header.value;
          }
          return result;
      };
      /**
       * Get the headers that are contained in this collection as an array.
       */
      HttpHeaders.prototype.headersArray = function () {
          var headers = [];
          for (var headerKey in this._headersMap) {
              headers.push(this._headersMap[headerKey]);
          }
          return headers;
      };
      /**
       * Get the header names that are contained in this collection.
       */
      HttpHeaders.prototype.headerNames = function () {
          var headerNames = [];
          var headers = this.headersArray();
          for (var i = 0; i < headers.length; ++i) {
              headerNames.push(headers[i].name);
          }
          return headerNames;
      };
      /**
       * Get the header names that are contained in this collection.
       */
      HttpHeaders.prototype.headerValues = function () {
          var headerValues = [];
          var headers = this.headersArray();
          for (var i = 0; i < headers.length; ++i) {
              headerValues.push(headers[i].value);
          }
          return headerValues;
      };
      /**
       * Get the JSON object representation of this HTTP header collection.
       */
      HttpHeaders.prototype.toJson = function () {
          return this.rawHeaders();
      };
      /**
       * Get the string representation of this HTTP header collection.
       */
      HttpHeaders.prototype.toString = function () {
          return JSON.stringify(this.toJson());
      };
      /**
       * Create a deep clone/copy of this HttpHeaders collection.
       */
      HttpHeaders.prototype.clone = function () {
          return new HttpHeaders(this.rawHeaders());
      };
      return HttpHeaders;
  }());
  
  // Copyright (c) Microsoft Corporation. All rights reserved.
  // Licensed under the MIT License. See License.txt in the project root for license information.
  /**
   * Encodes a string in base64 format.
   * @param value the string to encode
   */
  function encodeString(value) {
      return Buffer.from(value).toString("base64");
  }
  /**
   * Encodes a byte array in base64 format.
   * @param value the Uint8Aray to encode
   */
  function encodeByteArray(value) {
      // Buffer.from accepts <ArrayBuffer> | <SharedArrayBuffer>-- the TypeScript definition is off here
      // https://nodejs.org/api/buffer.html#buffer_class_method_buffer_from_arraybuffer_byteoffset_length
      var bufferValue = value instanceof Buffer ? value : Buffer.from(value.buffer);
      return bufferValue.toString("base64");
  }
  /**
   * Decodes a base64 string into a byte array.
   * @param value the base64 string to decode
   */
  function decodeString(value) {
      return Buffer.from(value, "base64");
  }
  
  // Copyright (c) Microsoft Corporation. All rights reserved.
  // Licensed under the MIT License. See License.txt in the project root for license information.
  var Constants = {
      /**
       * The ms-rest version
       * @const
       * @type {string}
       */
      msRestVersion: "2.5.2",
      /**
       * Specifies HTTP.
       *
       * @const
       * @type {string}
       */
      HTTP: "http:",
      /**
       * Specifies HTTPS.
       *
       * @const
       * @type {string}
       */
      HTTPS: "https:",
      /**
       * Specifies HTTP Proxy.
       *
       * @const
       * @type {string}
       */
      HTTP_PROXY: "HTTP_PROXY",
      /**
       * Specifies HTTPS Proxy.
       *
       * @const
       * @type {string}
       */
      HTTPS_PROXY: "HTTPS_PROXY",
      /**
       * Specifies NO Proxy.
       */
      NO_PROXY: "NO_PROXY",
      /**
       * Specifies ALL Proxy.
       */
      ALL_PROXY: "ALL_PROXY",
      HttpConstants: {
          /**
           * Http Verbs
           *
           * @const
           * @enum {string}
           */
          HttpVerbs: {
              PUT: "PUT",
              GET: "GET",
              DELETE: "DELETE",
              POST: "POST",
              MERGE: "MERGE",
              HEAD: "HEAD",
              PATCH: "PATCH",
          },
          StatusCodes: {
              TooManyRequests: 429,
          },
      },
      /**
       * Defines constants for use with HTTP headers.
       */
      HeaderConstants: {
          /**
           * The Authorization header.
           *
           * @const
           * @type {string}
           */
          AUTHORIZATION: "authorization",
          AUTHORIZATION_SCHEME: "Bearer",
          /**
           * The Retry-After response-header field can be used with a 503 (Service
           * Unavailable) or 349 (Too Many Requests) responses to indicate how long
           * the service is expected to be unavailable to the requesting client.
           *
           * @const
           * @type {string}
           */
          RETRY_AFTER: "Retry-After",
          /**
           * The UserAgent header.
           *
           * @const
           * @type {string}
           */
          USER_AGENT: "User-Agent",
      },
  };
  
  // Copyright (c) Microsoft Corporation. All rights reserved.
  /**
   * A constant that indicates whether the environment is node.js or browser based.
   */
  var isNode = typeof process !== "undefined" &&
      !!process.version &&
      !!process.versions &&
      !!process.versions.node;
  /**
   * Encodes an URI.
   *
   * @param {string} uri The URI to be encoded.
   * @return {string} The encoded URI.
   */
  function encodeUri(uri) {
      return encodeURIComponent(uri)
          .replace(/!/g, "%21")
          .replace(/"/g, "%27")
          .replace(/\(/g, "%28")
          .replace(/\)/g, "%29")
          .replace(/\*/g, "%2A");
  }
  /**
   * Returns a stripped version of the Http Response which only contains body,
   * headers and the status.
   *
   * @param {HttpOperationResponse} response The Http Response
   *
   * @return {object} The stripped version of Http Response.
   */
  function stripResponse(response) {
      var strippedResponse = {};
      strippedResponse.body = response.bodyAsText;
      strippedResponse.headers = response.headers;
      strippedResponse.status = response.status;
      return strippedResponse;
  }
  /**
   * Returns a stripped version of the Http Request that does not contain the
   * Authorization header.
   *
   * @param {WebResource} request The Http Request object
   *
   * @return {WebResource} The stripped version of Http Request.
   */
  function stripRequest(request) {
      var strippedRequest = request.clone();
      if (strippedRequest.headers) {
          strippedRequest.headers.remove("authorization");
      }
      return strippedRequest;
  }
  /**
   * Validates the given uuid as a string
   *
   * @param {string} uuid The uuid as a string that needs to be validated
   *
   * @return {boolean} True if the uuid is valid; false otherwise.
   */
  function isValidUuid(uuid) {
      var validUuidRegex = new RegExp("^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$", "ig");
      return validUuidRegex.test(uuid);
  }
  /**
   * Generated UUID
   *
   * @return {string} RFC4122 v4 UUID.
   */
  function generateUuid() {
      return uuidv4();
  }
  /**
   * Executes an array of promises sequentially. Inspiration of this method is here:
   * https://pouchdb.com/2015/05/18/we-have-a-problem-with-promises.html. An awesome blog on promises!
   *
   * @param {Array} promiseFactories An array of promise factories(A function that return a promise)
   *
   * @param {any} [kickstart] Input to the first promise that is used to kickstart the promise chain.
   * If not provided then the promise chain starts with undefined.
   *
   * @return A chain of resolved or rejected promises
   */
  function executePromisesSequentially(promiseFactories, kickstart) {
      var result = Promise.resolve(kickstart);
      promiseFactories.forEach(function (promiseFactory) {
          result = result.then(promiseFactory);
      });
      return result;
  }
  /**
   * A wrapper for setTimeout that resolves a promise after t milliseconds.
   * @param {number} t The number of milliseconds to be delayed.
   * @param {T} value The value to be resolved with after a timeout of t milliseconds.
   * @returns {Promise<T>} Resolved promise
   */
  function delay(t, value) {
      return new Promise(function (resolve) { return setTimeout(function () { return resolve(value); }, t); });
  }
  /**
   * Converts a Promise to a callback.
   * @param {Promise<any>} promise The Promise to be converted to a callback
   * @returns {Function} A function that takes the callback (cb: Function): void
   * @deprecated generated code should instead depend on responseToBody
   */
  function promiseToCallback(promise) {
      if (typeof promise.then !== "function") {
          throw new Error("The provided input is not a Promise.");
      }
      return function (cb) {
          promise.then(function (data) {
              cb(undefined, data);
          }, function (err) {
              cb(err);
          });
      };
  }
  /**
   * Converts a Promise to a service callback.
   * @param {Promise<HttpOperationResponse>} promise - The Promise of HttpOperationResponse to be converted to a service callback
   * @returns {Function} A function that takes the service callback (cb: ServiceCallback<T>): void
   */
  function promiseToServiceCallback(promise) {
      if (typeof promise.then !== "function") {
          throw new Error("The provided input is not a Promise.");
      }
      return function (cb) {
          promise.then(function (data) {
              process.nextTick(cb, undefined, data.parsedBody, data.request, data);
          }, function (err) {
              process.nextTick(cb, err);
          });
      };
  }
  function prepareXMLRootList(obj, elementName) {
      var _a;
      if (!Array.isArray(obj)) {
          obj = [obj];
      }
      return _a = {}, _a[elementName] = obj, _a;
  }
  /**
   * Applies the properties on the prototype of sourceCtors to the prototype of targetCtor
   * @param {object} targetCtor The target object on which the properties need to be applied.
   * @param {Array<object>} sourceCtors An array of source objects from which the properties need to be taken.
   */
  function applyMixins(targetCtor, sourceCtors) {
      sourceCtors.forEach(function (sourceCtors) {
          Object.getOwnPropertyNames(sourceCtors.prototype).forEach(function (name) {
              targetCtor.prototype[name] = sourceCtors.prototype[name];
          });
      });
  }
  var validateISODuration = /^(-|\+)?P(?:([-+]?[0-9,.]*)Y)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)W)?(?:([-+]?[0-9,.]*)D)?(?:T(?:([-+]?[0-9,.]*)H)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)S)?)?$/;
  /**
   * Indicates whether the given string is in ISO 8601 format.
   * @param {string} value The value to be validated for ISO 8601 duration format.
   * @return {boolean} `true` if valid, `false` otherwise.
   */
  function isDuration(value) {
      return validateISODuration.test(value);
  }
  /**
   * Replace all of the instances of searchValue in value with the provided replaceValue.
   * @param {string | undefined} value The value to search and replace in.
   * @param {string} searchValue The value to search for in the value argument.
   * @param {string} replaceValue The value to replace searchValue with in the value argument.
   * @returns {string | undefined} The value where each instance of searchValue was replaced with replacedValue.
   */
  function replaceAll(value, searchValue, replaceValue) {
      return !value || !searchValue ? value : value.split(searchValue).join(replaceValue || "");
  }
  /**
   * Determines whether the given enity is a basic/primitive type
   * (string, number, boolean, null, undefined).
   * @param value Any entity
   * @return boolean - true is it is primitive type, false otherwise.
   */
  function isPrimitiveType(value) {
      return (typeof value !== "object" && typeof value !== "function") || value === null;
  }
  
  // Copyright (c) Microsoft Corporation. All rights reserved.
  var Serializer = /** @class */ (function () {
      function Serializer(modelMappers, isXML) {
          if (modelMappers === void 0) { modelMappers = {}; }
          this.modelMappers = modelMappers;
          this.isXML = isXML;
      }
      Serializer.prototype.validateConstraints = function (mapper, value, objectName) {
          var failValidation = function (constraintName, constraintValue) {
              throw new Error("\"" + objectName + "\" with value \"" + value + "\" should satisfy the constraint \"" + constraintName + "\": " + constraintValue + ".");
          };
          if (mapper.constraints && value != undefined) {
              var _a = mapper.constraints, ExclusiveMaximum = _a.ExclusiveMaximum, ExclusiveMinimum = _a.ExclusiveMinimum, InclusiveMaximum = _a.InclusiveMaximum, InclusiveMinimum = _a.InclusiveMinimum, MaxItems = _a.MaxItems, MaxLength = _a.MaxLength, MinItems = _a.MinItems, MinLength = _a.MinLength, MultipleOf = _a.MultipleOf, Pattern = _a.Pattern, UniqueItems = _a.UniqueItems;
              if (ExclusiveMaximum != undefined && value >= ExclusiveMaximum) {
                  failValidation("ExclusiveMaximum", ExclusiveMaximum);
              }
              if (ExclusiveMinimum != undefined && value <= ExclusiveMinimum) {
                  failValidation("ExclusiveMinimum", ExclusiveMinimum);
              }
              if (InclusiveMaximum != undefined && value > InclusiveMaximum) {
                  failValidation("InclusiveMaximum", InclusiveMaximum);
              }
              if (InclusiveMinimum != undefined && value < InclusiveMinimum) {
                  failValidation("InclusiveMinimum", InclusiveMinimum);
              }
              if (MaxItems != undefined && value.length > MaxItems) {
                  failValidation("MaxItems", MaxItems);
              }
              if (MaxLength != undefined && value.length > MaxLength) {
                  failValidation("MaxLength", MaxLength);
              }
              if (MinItems != undefined && value.length < MinItems) {
                  failValidation("MinItems", MinItems);
              }
              if (MinLength != undefined && value.length < MinLength) {
                  failValidation("MinLength", MinLength);
              }
              if (MultipleOf != undefined && value % MultipleOf !== 0) {
                  failValidation("MultipleOf", MultipleOf);
              }
              if (Pattern) {
                  var pattern = typeof Pattern === "string" ? new RegExp(Pattern) : Pattern;
                  if (typeof value !== "string" || value.match(pattern) === null) {
                      failValidation("Pattern", Pattern);
                  }
              }
              if (UniqueItems &&
                  value.some(function (item, i, ar) { return ar.indexOf(item) !== i; })) {
                  failValidation("UniqueItems", UniqueItems);
              }
          }
      };
      /**
       * Serialize the given object based on its metadata defined in the mapper
       *
       * @param {Mapper} mapper The mapper which defines the metadata of the serializable object
       *
       * @param {object|string|Array|number|boolean|Date|stream} object A valid Javascript object to be serialized
       *
       * @param {string} objectName Name of the serialized object
       *
       * @returns {object|string|Array|number|boolean|Date|stream} A valid serialized Javascript object
       */
      Serializer.prototype.serialize = function (mapper, object, objectName) {
          var payload = {};
          var mapperType = mapper.type.name;
          if (!objectName) {
              objectName = mapper.serializedName;
          }
          if (mapperType.match(/^Sequence$/gi) !== null) {
              payload = [];
          }
          if (mapper.isConstant) {
              object = mapper.defaultValue;
          }
          // This table of allowed values should help explain
          // the mapper.required and mapper.nullable properties.
          // X means "neither undefined or null are allowed".
          //           || required
          //           || true      | false
          //  nullable || ==========================
          //      true || null      | undefined/null
          //     false || X         | undefined
          // undefined || X         | undefined/null
          var required = mapper.required, nullable = mapper.nullable;
          if (required && nullable && object === undefined) {
              throw new Error(objectName + " cannot be undefined.");
          }
          if (required && !nullable && object == undefined) {
              throw new Error(objectName + " cannot be null or undefined.");
          }
          if (!required && nullable === false && object === null) {
              throw new Error(objectName + " cannot be null.");
          }
          if (object == undefined) {
              payload = object;
          }
          else {
              // Validate Constraints if any
              this.validateConstraints(mapper, object, objectName);
              if (mapperType.match(/^any$/gi) !== null) {
                  payload = object;
              }
              else if (mapperType.match(/^(Number|String|Boolean|Object|Stream|Uuid)$/gi) !== null) {
                  payload = serializeBasicTypes(mapperType, objectName, object);
              }
              else if (mapperType.match(/^Enum$/gi) !== null) {
                  var enumMapper = mapper;
                  payload = serializeEnumType(objectName, enumMapper.type.allowedValues, object);
              }
              else if (mapperType.match(/^(Date|DateTime|TimeSpan|DateTimeRfc1123|UnixTime)$/gi) !== null) {
                  payload = serializeDateTypes(mapperType, object, objectName);
              }
              else if (mapperType.match(/^ByteArray$/gi) !== null) {
                  payload = serializeByteArrayType(objectName, object);
              }
              else if (mapperType.match(/^Base64Url$/gi) !== null) {
                  payload = serializeBase64UrlType(objectName, object);
              }
              else if (mapperType.match(/^Sequence$/gi) !== null) {
                  payload = serializeSequenceType(this, mapper, object, objectName);
              }
              else if (mapperType.match(/^Dictionary$/gi) !== null) {
                  payload = serializeDictionaryType(this, mapper, object, objectName);
              }
              else if (mapperType.match(/^Composite$/gi) !== null) {
                  payload = serializeCompositeType(this, mapper, object, objectName);
              }
          }
          return payload;
      };
      /**
       * Deserialize the given object based on its metadata defined in the mapper
       *
       * @param {object} mapper The mapper which defines the metadata of the serializable object
       *
       * @param {object|string|Array|number|boolean|Date|stream} responseBody A valid Javascript entity to be deserialized
       *
       * @param {string} objectName Name of the deserialized object
       *
       * @returns {object|string|Array|number|boolean|Date|stream} A valid deserialized Javascript object
       */
      Serializer.prototype.deserialize = function (mapper, responseBody, objectName) {
          if (responseBody == undefined) {
              if (this.isXML && mapper.type.name === "Sequence" && !mapper.xmlIsWrapped) {
                  // Edge case for empty XML non-wrapped lists. xml2js can't distinguish
                  // between the list being empty versus being missing,
                  // so let's do the more user-friendly thing and return an empty list.
                  responseBody = [];
              }
              // specifically check for undefined as default value can be a falsey value `0, "", false, null`
              if (mapper.defaultValue !== undefined) {
                  responseBody = mapper.defaultValue;
              }
              return responseBody;
          }
          var payload;
          var mapperType = mapper.type.name;
          if (!objectName) {
              objectName = mapper.serializedName;
          }
          if (mapperType.match(/^Composite$/gi) !== null) {
              payload = deserializeCompositeType(this, mapper, responseBody, objectName);
          }
          else {
              if (this.isXML) {
                  /**
                   * If the mapper specifies this as a non-composite type value but the responseBody contains
                   * both header ("$") and body ("_") properties, then just reduce the responseBody value to
                   * the body ("_") property.
                   */
                  if (responseBody["$"] != undefined && responseBody["_"] != undefined) {
                      responseBody = responseBody["_"];
                  }
              }
              if (mapperType.match(/^Number$/gi) !== null) {
                  payload = parseFloat(responseBody);
                  if (isNaN(payload)) {
                      payload = responseBody;
                  }
              }
              else if (mapperType.match(/^Boolean$/gi) !== null) {
                  if (responseBody === "true") {
                      payload = true;
                  }
                  else if (responseBody === "false") {
                      payload = false;
                  }
                  else {
                      payload = responseBody;
                  }
              }
              else if (mapperType.match(/^(String|Enum|Object|Stream|Uuid|TimeSpan|any)$/gi) !== null) {
                  payload = responseBody;
              }
              else if (mapperType.match(/^(Date|DateTime|DateTimeRfc1123)$/gi) !== null) {
                  payload = new Date(responseBody);
              }
              else if (mapperType.match(/^UnixTime$/gi) !== null) {
                  payload = unixTimeToDate(responseBody);
              }
              else if (mapperType.match(/^ByteArray$/gi) !== null) {
                  payload = decodeString(responseBody);
              }
              else if (mapperType.match(/^Base64Url$/gi) !== null) {
                  payload = base64UrlToByteArray(responseBody);
              }
              else if (mapperType.match(/^Sequence$/gi) !== null) {
                  payload = deserializeSequenceType(this, mapper, responseBody, objectName);
              }
              else if (mapperType.match(/^Dictionary$/gi) !== null) {
                  payload = deserializeDictionaryType(this, mapper, responseBody, objectName);
              }
          }
          if (mapper.isConstant) {
              payload = mapper.defaultValue;
          }
          return payload;
      };
      return Serializer;
  }());
  function trimEnd(str, ch) {
      var len = str.length;
      while (len - 1 >= 0 && str[len - 1] === ch) {
          --len;
      }
      return str.substr(0, len);
  }
  function bufferToBase64Url(buffer) {
      if (!buffer) {
          return undefined;
      }
      if (!(buffer instanceof Uint8Array)) {
          throw new Error("Please provide an input of type Uint8Array for converting to Base64Url.");
      }
      // Uint8Array to Base64.
      var str = encodeByteArray(buffer);
      // Base64 to Base64Url.
      return trimEnd(str, "=").replace(/\+/g, "-").replace(/\//g, "_");
  }
  function base64UrlToByteArray(str) {
      if (!str) {
          return undefined;
      }
      if (str && typeof str.valueOf() !== "string") {
          throw new Error("Please provide an input of type string for converting to Uint8Array");
      }
      // Base64Url to Base64.
      str = str.replace(/\-/g, "+").replace(/\_/g, "/");
      // Base64 to Uint8Array.
      return decodeString(str);
  }
  function splitSerializeName(prop) {
      var classes = [];
      var partialclass = "";
      if (prop) {
          var subwords = prop.split(".");
          for (var _i = 0, subwords_1 = subwords; _i < subwords_1.length; _i++) {
              var item = subwords_1[_i];
              if (item.charAt(item.length - 1) === "\\") {
                  partialclass += item.substr(0, item.length - 1) + ".";
              }
              else {
                  partialclass += item;
                  classes.push(partialclass);
                  partialclass = "";
              }
          }
      }
      return classes;
  }
  function dateToUnixTime(d) {
      if (!d) {
          return undefined;
      }
      if (typeof d.valueOf() === "string") {
          d = new Date(d);
      }
      return Math.floor(d.getTime() / 1000);
  }
  function unixTimeToDate(n) {
      if (!n) {
          return undefined;
      }
      return new Date(n * 1000);
  }
  function serializeBasicTypes(typeName, objectName, value) {
      if (value !== null && value !== undefined) {
          if (typeName.match(/^Number$/gi) !== null) {
              if (typeof value !== "number") {
                  throw new Error(objectName + " with value " + value + " must be of type number.");
              }
          }
          else if (typeName.match(/^String$/gi) !== null) {
              if (typeof value.valueOf() !== "string") {
                  throw new Error(objectName + " with value \"" + value + "\" must be of type string.");
              }
          }
          else if (typeName.match(/^Uuid$/gi) !== null) {
              if (!(typeof value.valueOf() === "string" && isValidUuid(value))) {
                  throw new Error(objectName + " with value \"" + value + "\" must be of type string and a valid uuid.");
              }
          }
          else if (typeName.match(/^Boolean$/gi) !== null) {
              if (typeof value !== "boolean") {
                  throw new Error(objectName + " with value " + value + " must be of type boolean.");
              }
          }
          else if (typeName.match(/^Stream$/gi) !== null) {
              var objectType = typeof value;
              if (objectType !== "string" &&
                  objectType !== "function" &&
                  !(value instanceof ArrayBuffer) &&
                  !ArrayBuffer.isView(value) &&
                  !(typeof Blob === "function" && value instanceof Blob)) {
                  throw new Error(objectName + " must be a string, Blob, ArrayBuffer, ArrayBufferView, or a function returning NodeJS.ReadableStream.");
              }
          }
      }
      return value;
  }
  function serializeEnumType(objectName, allowedValues, value) {
      if (!allowedValues) {
          throw new Error("Please provide a set of allowedValues to validate " + objectName + " as an Enum Type.");
      }
      var isPresent = allowedValues.some(function (item) {
          if (typeof item.valueOf() === "string") {
              return item.toLowerCase() === value.toLowerCase();
          }
          return item === value;
      });
      if (!isPresent) {
          throw new Error(value + " is not a valid value for " + objectName + ". The valid values are: " + JSON.stringify(allowedValues) + ".");
      }
      return value;
  }
  function serializeByteArrayType(objectName, value) {
      if (value != undefined) {
          if (!(value instanceof Uint8Array)) {
              throw new Error(objectName + " must be of type Uint8Array.");
          }
          value = encodeByteArray(value);
      }
      return value;
  }
  function serializeBase64UrlType(objectName, value) {
      if (value != undefined) {
          if (!(value instanceof Uint8Array)) {
              throw new Error(objectName + " must be of type Uint8Array.");
          }
          value = bufferToBase64Url(value);
      }
      return value;
  }
  function serializeDateTypes(typeName, value, objectName) {
      if (value != undefined) {
          if (typeName.match(/^Date$/gi) !== null) {
              if (!(value instanceof Date ||
                  (typeof value.valueOf() === "string" && !isNaN(Date.parse(value))))) {
                  throw new Error(objectName + " must be an instanceof Date or a string in ISO8601 format.");
              }
              value =
                  value instanceof Date
                      ? value.toISOString().substring(0, 10)
                      : new Date(value).toISOString().substring(0, 10);
          }
          else if (typeName.match(/^DateTime$/gi) !== null) {
              if (!(value instanceof Date ||
                  (typeof value.valueOf() === "string" && !isNaN(Date.parse(value))))) {
                  throw new Error(objectName + " must be an instanceof Date or a string in ISO8601 format.");
              }
              value = value instanceof Date ? value.toISOString() : new Date(value).toISOString();
          }
          else if (typeName.match(/^DateTimeRfc1123$/gi) !== null) {
              if (!(value instanceof Date ||
                  (typeof value.valueOf() === "string" && !isNaN(Date.parse(value))))) {
                  throw new Error(objectName + " must be an instanceof Date or a string in RFC-1123 format.");
              }
              value = value instanceof Date ? value.toUTCString() : new Date(value).toUTCString();
          }
          else if (typeName.match(/^UnixTime$/gi) !== null) {
              if (!(value instanceof Date ||
                  (typeof value.valueOf() === "string" && !isNaN(Date.parse(value))))) {
                  throw new Error(objectName + " must be an instanceof Date or a string in RFC-1123/ISO8601 format " +
                      "for it to be serialized in UnixTime/Epoch format.");
              }
              value = dateToUnixTime(value);
          }
          else if (typeName.match(/^TimeSpan$/gi) !== null) {
              if (!isDuration(value)) {
                  throw new Error(objectName + " must be a string in ISO 8601 format. Instead was \"" + value + "\".");
              }
              value = value;
          }
      }
      return value;
  }
  function serializeSequenceType(serializer, mapper, object, objectName) {
      if (!Array.isArray(object)) {
          throw new Error(objectName + " must be of type Array.");
      }
      var elementType = mapper.type.element;
      if (!elementType || typeof elementType !== "object") {
          throw new Error("element\" metadata for an Array must be defined in the " +
              ("mapper and it must of type \"object\" in " + objectName + "."));
      }
      var tempArray = [];
      for (var i = 0; i < object.length; i++) {
          tempArray[i] = serializer.serialize(elementType, object[i], objectName);
      }
      return tempArray;
  }
  function serializeDictionaryType(serializer, mapper, object, objectName) {
      if (typeof object !== "object") {
          throw new Error(objectName + " must be of type object.");
      }
      var valueType = mapper.type.value;
      if (!valueType || typeof valueType !== "object") {
          throw new Error("\"value\" metadata for a Dictionary must be defined in the " +
              ("mapper and it must of type \"object\" in " + objectName + "."));
      }
      var tempDictionary = {};
      for (var _i = 0, _a = Object.keys(object); _i < _a.length; _i++) {
          var key = _a[_i];
          tempDictionary[key] = serializer.serialize(valueType, object[key], objectName + "." + key);
      }
      return tempDictionary;
  }
  /**
   * Resolves a composite mapper's modelProperties.
   * @param serializer the serializer containing the entire set of mappers
   * @param mapper the composite mapper to resolve
   */
  function resolveModelProperties(serializer, mapper, objectName) {
      var modelProps = mapper.type.modelProperties;
      if (!modelProps) {
          var className = mapper.type.className;
          if (!className) {
              throw new Error("Class name for model \"" + objectName + "\" is not provided in the mapper \"" + JSON.stringify(mapper, undefined, 2) + "\".");
          }
          var modelMapper = serializer.modelMappers[className];
          if (!modelMapper) {
              throw new Error("mapper() cannot be null or undefined for model \"" + className + "\".");
          }
          modelProps = modelMapper.type.modelProperties;
          if (!modelProps) {
              throw new Error("modelProperties cannot be null or undefined in the " +
                  ("mapper \"" + JSON.stringify(modelMapper) + "\" of type \"" + className + "\" for object \"" + objectName + "\"."));
          }
      }
      return modelProps;
  }
  function serializeCompositeType(serializer, mapper, object, objectName) {
      var _a;
      if (getPolymorphicDiscriminatorRecursively(serializer, mapper)) {
          mapper = getPolymorphicMapper(serializer, mapper, object, "clientName");
      }
      if (object != undefined) {
          var payload = {};
          var modelProps = resolveModelProperties(serializer, mapper, objectName);
          for (var _i = 0, _b = Object.keys(modelProps); _i < _b.length; _i++) {
              var key = _b[_i];
              var propertyMapper = modelProps[key];
              if (propertyMapper.readOnly) {
                  continue;
              }
              var propName = void 0;
              var parentObject = payload;
              if (serializer.isXML) {
                  if (propertyMapper.xmlIsWrapped) {
                      propName = propertyMapper.xmlName;
                  }
                  else {
                      propName = propertyMapper.xmlElementName || propertyMapper.xmlName;
                  }
              }
              else {
                  var paths = splitSerializeName(propertyMapper.serializedName);
                  propName = paths.pop();
                  for (var _c = 0, paths_1 = paths; _c < paths_1.length; _c++) {
                      var pathName = paths_1[_c];
                      var childObject = parentObject[pathName];
                      if (childObject == undefined && object[key] != undefined) {
                          parentObject[pathName] = {};
                      }
                      parentObject = parentObject[pathName];
                  }
              }
              if (parentObject != undefined) {
                  var propertyObjectName = propertyMapper.serializedName !== ""
                      ? objectName + "." + propertyMapper.serializedName
                      : objectName;
                  var toSerialize = object[key];
                  var polymorphicDiscriminator = getPolymorphicDiscriminatorRecursively(serializer, mapper);
                  if (polymorphicDiscriminator &&
                      polymorphicDiscriminator.clientName === key &&
                      toSerialize == undefined) {
                      toSerialize = mapper.serializedName;
                  }
                  var serializedValue = serializer.serialize(propertyMapper, toSerialize, propertyObjectName);
                  if (serializedValue !== undefined && propName != undefined) {
                      if (propertyMapper.xmlIsAttribute) {
                          // $ is the key attributes are kept under in xml2js.
                          // This keeps things simple while preventing name collision
                          // with names in user documents.
                          parentObject.$ = parentObject.$ || {};
                          parentObject.$[propName] = serializedValue;
                      }
                      else if (propertyMapper.xmlIsWrapped) {
                          parentObject[propName] = (_a = {}, _a[propertyMapper.xmlElementName] = serializedValue, _a);
                      }
                      else {
                          parentObject[propName] = serializedValue;
                      }
                  }
              }
          }
          var additionalPropertiesMapper = mapper.type.additionalProperties;
          if (additionalPropertiesMapper) {
              var propNames = Object.keys(modelProps);
              var _loop_1 = function (clientPropName) {
                  var isAdditionalProperty = propNames.every(function (pn) { return pn !== clientPropName; });
                  if (isAdditionalProperty) {
                      payload[clientPropName] = serializer.serialize(additionalPropertiesMapper, object[clientPropName], objectName + '["' + clientPropName + '"]');
                  }
              };
              for (var clientPropName in object) {
                  _loop_1(clientPropName);
              }
          }
          return payload;
      }
      return object;
  }
  function isSpecialXmlProperty(propertyName) {
      return ["$", "_"].includes(propertyName);
  }
  function deserializeCompositeType(serializer, mapper, responseBody, objectName) {
      if (getPolymorphicDiscriminatorRecursively(serializer, mapper)) {
          mapper = getPolymorphicMapper(serializer, mapper, responseBody, "serializedName");
      }
      var modelProps = resolveModelProperties(serializer, mapper, objectName);
      var instance = {};
      var handledPropertyNames = [];
      for (var _i = 0, _a = Object.keys(modelProps); _i < _a.length; _i++) {
          var key = _a[_i];
          var propertyMapper = modelProps[key];
          var paths = splitSerializeName(modelProps[key].serializedName);
          handledPropertyNames.push(paths[0]);
          var serializedName = propertyMapper.serializedName, xmlName = propertyMapper.xmlName, xmlElementName = propertyMapper.xmlElementName;
          var propertyObjectName = objectName;
          if (serializedName !== "" && serializedName !== undefined) {
              propertyObjectName = objectName + "." + serializedName;
          }
          var headerCollectionPrefix = propertyMapper.headerCollectionPrefix;
          if (headerCollectionPrefix) {
              var dictionary = {};
              for (var _b = 0, _c = Object.keys(responseBody); _b < _c.length; _b++) {
                  var headerKey = _c[_b];
                  if (headerKey.startsWith(headerCollectionPrefix)) {
                      dictionary[headerKey.substring(headerCollectionPrefix.length)] = serializer.deserialize(propertyMapper.type.value, responseBody[headerKey], propertyObjectName);
                  }
                  handledPropertyNames.push(headerKey);
              }
              instance[key] = dictionary;
          }
          else if (serializer.isXML) {
              if (propertyMapper.xmlIsAttribute && responseBody.$) {
                  instance[key] = serializer.deserialize(propertyMapper, responseBody.$[xmlName], propertyObjectName);
              }
              else {
                  var propertyName = xmlElementName || xmlName || serializedName;
                  var unwrappedProperty = responseBody[propertyName];
                  if (propertyMapper.xmlIsWrapped) {
                      unwrappedProperty = responseBody[xmlName];
                      unwrappedProperty = unwrappedProperty && unwrappedProperty[xmlElementName];
                      var isEmptyWrappedList = unwrappedProperty === undefined;
                      if (isEmptyWrappedList) {
                          unwrappedProperty = [];
                      }
                  }
                  instance[key] = serializer.deserialize(propertyMapper, unwrappedProperty, propertyObjectName);
              }
          }
          else {
              // deserialize the property if it is present in the provided responseBody instance
              var propertyInstance = void 0;
              var res = responseBody;
              // traversing the object step by step.
              for (var _d = 0, paths_2 = paths; _d < paths_2.length; _d++) {
                  var item = paths_2[_d];
                  if (!res)
                      break;
                  res = res[item];
              }
              propertyInstance = res;
              var polymorphicDiscriminator = mapper.type.polymorphicDiscriminator;
              // checking that the model property name (key)(ex: "fishtype") and the
              // clientName of the polymorphicDiscriminator {metadata} (ex: "fishtype")
              // instead of the serializedName of the polymorphicDiscriminator (ex: "fish.type")
              // is a better approach. The generator is not consistent with escaping '\.' in the
              // serializedName of the property (ex: "fish\.type") that is marked as polymorphic discriminator
              // and the serializedName of the metadata polymorphicDiscriminator (ex: "fish.type"). However,
              // the clientName transformation of the polymorphicDiscriminator (ex: "fishtype") and
              // the transformation of model property name (ex: "fishtype") is done consistently.
              // Hence, it is a safer bet to rely on the clientName of the polymorphicDiscriminator.
              if (polymorphicDiscriminator &&
                  key === polymorphicDiscriminator.clientName &&
                  propertyInstance == undefined) {
                  propertyInstance = mapper.serializedName;
              }
              var serializedValue = void 0;
              // paging
              if (Array.isArray(responseBody[key]) && modelProps[key].serializedName === "") {
                  propertyInstance = responseBody[key];
                  var arrayInstance = serializer.deserialize(propertyMapper, propertyInstance, propertyObjectName);
                  // Copy over any properties that have already been added into the instance, where they do
                  // not exist on the newly de-serialized array
                  for (var _e = 0, _f = Object.entries(instance); _e < _f.length; _e++) {
                      var _g = _f[_e], key_1 = _g[0], value = _g[1];
                      if (!arrayInstance.hasOwnProperty(key_1)) {
                          arrayInstance[key_1] = value;
                      }
                  }
                  instance = arrayInstance;
              }
              else if (propertyInstance !== undefined || propertyMapper.defaultValue !== undefined) {
                  serializedValue = serializer.deserialize(propertyMapper, propertyInstance, propertyObjectName);
                  instance[key] = serializedValue;
              }
          }
      }
      var additionalPropertiesMapper = mapper.type.additionalProperties;
      if (additionalPropertiesMapper) {
          var isAdditionalProperty = function (responsePropName) {
              for (var clientPropName in modelProps) {
                  var paths = splitSerializeName(modelProps[clientPropName].serializedName);
                  if (paths[0] === responsePropName) {
                      return false;
                  }
              }
              return true;
          };
          for (var responsePropName in responseBody) {
              if (isAdditionalProperty(responsePropName)) {
                  instance[responsePropName] = serializer.deserialize(additionalPropertiesMapper, responseBody[responsePropName], objectName + '["' + responsePropName + '"]');
              }
          }
      }
      else if (responseBody) {
          for (var _h = 0, _j = Object.keys(responseBody); _h < _j.length; _h++) {
              var key = _j[_h];
              if (instance[key] === undefined &&
                  !handledPropertyNames.includes(key) &&
                  !isSpecialXmlProperty(key)) {
                  instance[key] = responseBody[key];
              }
          }
      }
      return instance;
  }
  function deserializeDictionaryType(serializer, mapper, responseBody, objectName) {
      /*jshint validthis: true */
      var value = mapper.type.value;
      if (!value || typeof value !== "object") {
          throw new Error("\"value\" metadata for a Dictionary must be defined in the " +
              ("mapper and it must of type \"object\" in " + objectName));
      }
      if (responseBody) {
          var tempDictionary = {};
          for (var _i = 0, _a = Object.keys(responseBody); _i < _a.length; _i++) {
              var key = _a[_i];
              tempDictionary[key] = serializer.deserialize(value, responseBody[key], objectName);
          }
          return tempDictionary;
      }
      return responseBody;
  }
  function deserializeSequenceType(serializer, mapper, responseBody, objectName) {
      /*jshint validthis: true */
      var element = mapper.type.element;
      if (!element || typeof element !== "object") {
          throw new Error("element\" metadata for an Array must be defined in the " +
              ("mapper and it must of type \"object\" in " + objectName));
      }
      if (responseBody) {
          if (!Array.isArray(responseBody)) {
              // xml2js will interpret a single element array as just the element, so force it to be an array
              responseBody = [responseBody];
          }
          var tempArray = [];
          for (var i = 0; i < responseBody.length; i++) {
              tempArray[i] = serializer.deserialize(element, responseBody[i], objectName + "[" + i + "]");
          }
          return tempArray;
      }
      return responseBody;
  }
  function getPolymorphicMapper(serializer, mapper, object, polymorphicPropertyName) {
      var polymorphicDiscriminator = getPolymorphicDiscriminatorRecursively(serializer, mapper);
      if (polymorphicDiscriminator) {
          var discriminatorName = polymorphicDiscriminator[polymorphicPropertyName];
          if (discriminatorName != undefined) {
              var discriminatorValue = object[discriminatorName];
              if (discriminatorValue != undefined) {
                  var typeName = mapper.type.uberParent || mapper.type.className;
                  var indexDiscriminator = discriminatorValue === typeName
                      ? discriminatorValue
                      : typeName + "." + discriminatorValue;
                  var polymorphicMapper = serializer.modelMappers.discriminators[indexDiscriminator];
                  if (polymorphicMapper) {
                      mapper = polymorphicMapper;
                  }
              }
          }
      }
      return mapper;
  }
  function getPolymorphicDiscriminatorRecursively(serializer, mapper) {
      return (mapper.type.polymorphicDiscriminator ||
          getPolymorphicDiscriminatorSafely(serializer, mapper.type.uberParent) ||
          getPolymorphicDiscriminatorSafely(serializer, mapper.type.className));
  }
  function getPolymorphicDiscriminatorSafely(serializer, typeName) {
      return (typeName &&
          serializer.modelMappers[typeName] &&
          serializer.modelMappers[typeName].type.polymorphicDiscriminator);
  }
  // TODO: why is this here?
  function serializeObject(toSerialize) {
      if (toSerialize == undefined)
          return undefined;
      if (toSerialize instanceof Uint8Array) {
          toSerialize = encodeByteArray(toSerialize);
          return toSerialize;
      }
      else if (toSerialize instanceof Date) {
          return toSerialize.toISOString();
      }
      else if (Array.isArray(toSerialize)) {
          var array = [];
          for (var i = 0; i < toSerialize.length; i++) {
              array.push(serializeObject(toSerialize[i]));
          }
          return array;
      }
      else if (typeof toSerialize === "object") {
          var dictionary = {};
          for (var property in toSerialize) {
              dictionary[property] = serializeObject(toSerialize[property]);
          }
          return dictionary;
      }
      return toSerialize;
  }
  /**
   * Utility function to create a K:V from a list of strings
   */
  function strEnum(o) {
      var result = {};
      for (var _i = 0, o_1 = o; _i < o_1.length; _i++) {
          var key = o_1[_i];
          result[key] = key;
      }
      return result;
  }
  var MapperType = strEnum([
      "Base64Url",
      "Boolean",
      "ByteArray",
      "Composite",
      "Date",
      "DateTime",
      "DateTimeRfc1123",
      "Dictionary",
      "Enum",
      "Number",
      "Object",
      "Sequence",
      "String",
      "Stream",
      "TimeSpan",
      "UnixTime",
  ]);
  
  // Copyright (c) Microsoft Corporation. All rights reserved.
  function isWebResourceLike(object) {
      if (typeof object !== "object") {
          return false;
      }
      if (typeof object.url === "string" &&
          typeof object.method === "string" &&
          typeof object.headers === "object" &&
          isHttpHeadersLike(object.headers) &&
          typeof object.validateRequestProperties === "function" &&
          typeof object.prepare === "function" &&
          typeof object.clone === "function") {
          return true;
      }
      return false;
  }
  /**
   * Creates a new WebResource object.
   *
   * This class provides an abstraction over a REST call by being library / implementation agnostic and wrapping the necessary
   * properties to initiate a request.
   *
   * @constructor
   */
  var WebResource = /** @class */ (function () {
      function WebResource(url, method, body, query, headers, streamResponseBody, withCredentials, abortSignal, timeout, onUploadProgress, onDownloadProgress, proxySettings, keepAlive, agentSettings, redirectLimit) {
          this.streamResponseBody = streamResponseBody;
          this.url = url || "";
          this.method = method || "GET";
          this.headers = isHttpHeadersLike(headers) ? headers : new HttpHeaders(headers);
          this.body = body;
          this.query = query;
          this.formData = undefined;
          this.withCredentials = withCredentials || false;
          this.abortSignal = abortSignal;
          this.timeout = timeout || 0;
          this.onUploadProgress = onUploadProgress;
          this.onDownloadProgress = onDownloadProgress;
          this.proxySettings = proxySettings;
          this.keepAlive = keepAlive;
          this.agentSettings = agentSettings;
          this.redirectLimit = redirectLimit;
      }
      /**
       * Validates that the required properties such as method, url, headers["Content-Type"],
       * headers["accept-language"] are defined. It will throw an error if one of the above
       * mentioned properties are not defined.
       */
      WebResource.prototype.validateRequestProperties = function () {
          if (!this.method) {
              throw new Error("WebResource.method is required.");
          }
          if (!this.url) {
              throw new Error("WebResource.url is required.");
          }
      };
      /**
       * Prepares the request.
       * @param {RequestPrepareOptions} options Options to provide for preparing the request.
       * @returns {WebResource} Returns the prepared WebResource (HTTP Request) object that needs to be given to the request pipeline.
       */
      WebResource.prototype.prepare = function (options) {
          if (!options) {
              throw new Error("options object is required");
          }
          if (options.method == undefined || typeof options.method.valueOf() !== "string") {
              throw new Error("options.method must be a string.");
          }
          if (options.url && options.pathTemplate) {
              throw new Error("options.url and options.pathTemplate are mutually exclusive. Please provide exactly one of them.");
          }
          if ((options.pathTemplate == undefined || typeof options.pathTemplate.valueOf() !== "string") &&
              (options.url == undefined || typeof options.url.valueOf() !== "string")) {
              throw new Error("Please provide exactly one of options.pathTemplate or options.url.");
          }
          // set the url if it is provided.
          if (options.url) {
              if (typeof options.url !== "string") {
                  throw new Error('options.url must be of type "string".');
              }
              this.url = options.url;
          }
          // set the method
          if (options.method) {
              var validMethods = ["GET", "PUT", "HEAD", "DELETE", "OPTIONS", "POST", "PATCH", "TRACE"];
              if (validMethods.indexOf(options.method.toUpperCase()) === -1) {
                  throw new Error('The provided method "' +
                      options.method +
                      '" is invalid. Supported HTTP methods are: ' +
                      JSON.stringify(validMethods));
              }
          }
          this.method = options.method.toUpperCase();
          // construct the url if path template is provided
          if (options.pathTemplate) {
              var pathTemplate_1 = options.pathTemplate, pathParameters_1 = options.pathParameters;
              if (typeof pathTemplate_1 !== "string") {
                  throw new Error('options.pathTemplate must be of type "string".');
              }
              if (!options.baseUrl) {
                  options.baseUrl = "https://management.azure.com";
              }
              var baseUrl = options.baseUrl;
              var url_1 = baseUrl +
                  (baseUrl.endsWith("/") ? "" : "/") +
                  (pathTemplate_1.startsWith("/") ? pathTemplate_1.slice(1) : pathTemplate_1);
              var segments = url_1.match(/({\w*\s*\w*})/gi);
              if (segments && segments.length) {
                  if (!pathParameters_1) {
                      throw new Error("pathTemplate: " + pathTemplate_1 + " has been provided. Hence, options.pathParameters must also be provided.");
                  }
                  segments.forEach(function (item) {
                      var pathParamName = item.slice(1, -1);
                      var pathParam = pathParameters_1[pathParamName];
                      if (pathParam === null ||
                          pathParam === undefined ||
                          !(typeof pathParam === "string" || typeof pathParam === "object")) {
                          throw new Error("pathTemplate: " + pathTemplate_1 + " contains the path parameter " + pathParamName +
                              (" however, it is not present in " + pathParameters_1 + " - " + JSON.stringify(pathParameters_1, undefined, 2) + ".") +
                              ("The value of the path parameter can either be a \"string\" of the form { " + pathParamName + ": \"some sample value\" } or ") +
                              ("it can be an \"object\" of the form { \"" + pathParamName + "\": { value: \"some sample value\", skipUrlEncoding: true } }."));
                      }
                      if (typeof pathParam.valueOf() === "string") {
                          url_1 = url_1.replace(item, encodeURIComponent(pathParam));
                      }
                      if (typeof pathParam.valueOf() === "object") {
                          if (!pathParam.value) {
                              throw new Error("options.pathParameters[" + pathParamName + "] is of type \"object\" but it does not contain a \"value\" property.");
                          }
                          if (pathParam.skipUrlEncoding) {
                              url_1 = url_1.replace(item, pathParam.value);
                          }
                          else {
                              url_1 = url_1.replace(item, encodeURIComponent(pathParam.value));
                          }
                      }
                  });
              }
              this.url = url_1;
          }
          // append query parameters to the url if they are provided. They can be provided with pathTemplate or url option.
          if (options.queryParameters) {
              var queryParameters = options.queryParameters;
              if (typeof queryParameters !== "object") {
                  throw new Error("options.queryParameters must be of type object. It should be a JSON object " +
                      "of \"query-parameter-name\" as the key and the \"query-parameter-value\" as the value. " +
                      "The \"query-parameter-value\" may be fo type \"string\" or an \"object\" of the form { value: \"query-parameter-value\", skipUrlEncoding: true }.");
              }
              // append question mark if it is not present in the url
              if (this.url && this.url.indexOf("?") === -1) {
                  this.url += "?";
              }
              // construct queryString
              var queryParams = [];
              // We need to populate this.query as a dictionary if the request is being used for Sway's validateRequest().
              this.query = {};
              for (var queryParamName in queryParameters) {
                  var queryParam = queryParameters[queryParamName];
                  if (queryParam) {
                      if (typeof queryParam === "string") {
                          queryParams.push(queryParamName + "=" + encodeURIComponent(queryParam));
                          this.query[queryParamName] = encodeURIComponent(queryParam);
                      }
                      else if (typeof queryParam === "object") {
                          if (!queryParam.value) {
                              throw new Error("options.queryParameters[" + queryParamName + "] is of type \"object\" but it does not contain a \"value\" property.");
                          }
                          if (queryParam.skipUrlEncoding) {
                              queryParams.push(queryParamName + "=" + queryParam.value);
                              this.query[queryParamName] = queryParam.value;
                          }
                          else {
                              queryParams.push(queryParamName + "=" + encodeURIComponent(queryParam.value));
                              this.query[queryParamName] = encodeURIComponent(queryParam.value);
                          }
                      }
                  }
              } // end-of-for
              // append the queryString
              this.url += queryParams.join("&");
          }
          // add headers to the request if they are provided
          if (options.headers) {
              var headers = options.headers;
              for (var _i = 0, _a = Object.keys(options.headers); _i < _a.length; _i++) {
                  var headerName = _a[_i];
                  this.headers.set(headerName, headers[headerName]);
              }
          }
          // ensure accept-language is set correctly
          if (!this.headers.get("accept-language")) {
              this.headers.set("accept-language", "en-US");
          }
          // ensure the request-id is set correctly
          if (!this.headers.get("x-ms-client-request-id") && !options.disableClientRequestId) {
              this.headers.set("x-ms-client-request-id", generateUuid());
          }
          // default
          if (!this.headers.get("Content-Type")) {
              this.headers.set("Content-Type", "application/json; charset=utf-8");
          }
          // set the request body. request.js automatically sets the Content-Length request header, so we need not set it explicilty
          this.body = options.body;
          if (options.body != undefined) {
              // body as a stream special case. set the body as-is and check for some special request headers specific to sending a stream.
              if (options.bodyIsStream) {
                  if (!this.headers.get("Transfer-Encoding")) {
                      this.headers.set("Transfer-Encoding", "chunked");
                  }
                  if (this.headers.get("Content-Type") !== "application/octet-stream") {
                      this.headers.set("Content-Type", "application/octet-stream");
                  }
              }
              else {
                  if (options.serializationMapper) {
                      this.body = new Serializer(options.mappers).serialize(options.serializationMapper, options.body, "requestBody");
                  }
                  if (!options.disableJsonStringifyOnBody) {
                      this.body = JSON.stringify(options.body);
                  }
              }
          }
          this.abortSignal = options.abortSignal;
          this.onDownloadProgress = options.onDownloadProgress;
          this.onUploadProgress = options.onUploadProgress;
          this.redirectLimit = options.redirectLimit;
          this.streamResponseBody = options.streamResponseBody;
          return this;
      };
      /**
       * Clone this WebResource HTTP request object.
       * @returns {WebResource} The clone of this WebResource HTTP request object.
       */
      WebResource.prototype.clone = function () {
          var result = new WebResource(this.url, this.method, this.body, this.query, this.headers && this.headers.clone(), this.streamResponseBody, this.withCredentials, this.abortSignal, this.timeout, this.onUploadProgress, this.onDownloadProgress, this.proxySettings, this.keepAlive, this.agentSettings, this.redirectLimit);
          if (this.formData) {
              result.formData = this.formData;
          }
          if (this.operationSpec) {
              result.operationSpec = this.operationSpec;
          }
          if (this.shouldDeserialize) {
              result.shouldDeserialize = this.shouldDeserialize;
          }
          if (this.operationResponseGetter) {
              result.operationResponseGetter = this.operationResponseGetter;
          }
          return result;
      };
      return WebResource;
  }());
  
  /**
   * @author Toru Nagashima <https://github.com/mysticatea>
   * @copyright 2015 Toru Nagashima. All rights reserved.
   * See LICENSE file in root directory for full license.
   */
  /**
   * @typedef {object} PrivateData
   * @property {EventTarget} eventTarget The event target.
   * @property {{type:string}} event The original event object.
   * @property {number} eventPhase The current event phase.
   * @property {EventTarget|null} currentTarget The current event target.
   * @property {boolean} canceled The flag to prevent default.
   * @property {boolean} stopped The flag to stop propagation.
   * @property {boolean} immediateStopped The flag to stop propagation immediately.
   * @property {Function|null} passiveListener The listener if the current listener is passive. Otherwise this is null.
   * @property {number} timeStamp The unix time.
   * @private
   */
  
  /**
   * Private data for event wrappers.
   * @type {WeakMap<Event, PrivateData>}
   * @private
   */
  const privateData = new WeakMap();
  
  /**
   * Cache for wrapper classes.
   * @type {WeakMap<Object, Function>}
   * @private
   */
  const wrappers = new WeakMap();
  
  /**
   * Get private data.
   * @param {Event} event The event object to get private data.
   * @returns {PrivateData} The private data of the event.
   * @private
   */
  function pd(event) {
      const retv = privateData.get(event);
      console.assert(
          retv != null,
          "'this' is expected an Event object, but got",
          event
      );
      return retv
  }
  
  /**
   * https://dom.spec.whatwg.org/#set-the-canceled-flag
   * @param data {PrivateData} private data.
   */
  function setCancelFlag(data) {
      if (data.passiveListener != null) {
          if (
              typeof console !== "undefined" &&
              typeof console.error === "function"
          ) {
              console.error(
                  "Unable to preventDefault inside passive event listener invocation.",
                  data.passiveListener
              );
          }
          return
      }
      if (!data.event.cancelable) {
          return
      }
  
      data.canceled = true;
      if (typeof data.event.preventDefault === "function") {
          data.event.preventDefault();
      }
  }
  
  /**
   * @see https://dom.spec.whatwg.org/#interface-event
   * @private
   */
  /**
   * The event wrapper.
   * @constructor
   * @param {EventTarget} eventTarget The event target of this dispatching.
   * @param {Event|{type:string}} event The original event to wrap.
   */
  function Event(eventTarget, event) {
      privateData.set(this, {
          eventTarget,
          event,
          eventPhase: 2,
          currentTarget: eventTarget,
          canceled: false,
          stopped: false,
          immediateStopped: false,
          passiveListener: null,
          timeStamp: event.timeStamp || Date.now(),
      });
  
      // https://heycam.github.io/webidl/#Unforgeable
      Object.defineProperty(this, "isTrusted", { value: false, enumerable: true });
  
      // Define accessors
      const keys = Object.keys(event);
      for (let i = 0; i < keys.length; ++i) {
          const key = keys[i];
          if (!(key in this)) {
              Object.defineProperty(this, key, defineRedirectDescriptor(key));
          }
      }
  }
  
  // Should be enumerable, but class methods are not enumerable.
  Event.prototype = {
      /**
       * The type of this event.
       * @type {string}
       */
      get type() {
          return pd(this).event.type
      },
  
      /**
       * The target of this event.
       * @type {EventTarget}
       */
      get target() {
          return pd(this).eventTarget
      },
  
      /**
       * The target of this event.
       * @type {EventTarget}
       */
      get currentTarget() {
          return pd(this).currentTarget
      },
  
      /**
       * @returns {EventTarget[]} The composed path of this event.
       */
      composedPath() {
          const currentTarget = pd(this).currentTarget;
          if (currentTarget == null) {
              return []
          }
          return [currentTarget]
      },
  
      /**
       * Constant of NONE.
       * @type {number}
       */
      get NONE() {
          return 0
      },
  
      /**
       * Constant of CAPTURING_PHASE.
       * @type {number}
       */
      get CAPTURING_PHASE() {
          return 1
      },
  
      /**
       * Constant of AT_TARGET.
       * @type {number}
       */
      get AT_TARGET() {
          return 2
      },
  
      /**
       * Constant of BUBBLING_PHASE.
       * @type {number}
       */
      get BUBBLING_PHASE() {
          return 3
      },
  
      /**
       * The target of this event.
       * @type {number}
       */
      get eventPhase() {
          return pd(this).eventPhase
      },
  
      /**
       * Stop event bubbling.
       * @returns {void}
       */
      stopPropagation() {
          const data = pd(this);
  
          data.stopped = true;
          if (typeof data.event.stopPropagation === "function") {
              data.event.stopPropagation();
          }
      },
  
      /**
       * Stop event bubbling.
       * @returns {void}
       */
      stopImmediatePropagation() {
          const data = pd(this);
  
          data.stopped = true;
          data.immediateStopped = true;
          if (typeof data.event.stopImmediatePropagation === "function") {
              data.event.stopImmediatePropagation();
          }
      },
  
      /**
       * The flag to be bubbling.
       * @type {boolean}
       */
      get bubbles() {
          return Boolean(pd(this).event.bubbles)
      },
  
      /**
       * The flag to be cancelable.
       * @type {boolean}
       */
      get cancelable() {
          return Boolean(pd(this).event.cancelable)
      },
  
      /**
       * Cancel this event.
       * @returns {void}
       */
      preventDefault() {
          setCancelFlag(pd(this));
      },
  
      /**
       * The flag to indicate cancellation state.
       * @type {boolean}
       */
      get defaultPrevented() {
          return pd(this).canceled
      },
  
      /**
       * The flag to be composed.
       * @type {boolean}
       */
      get composed() {
          return Boolean(pd(this).event.composed)
      },
  
      /**
       * The unix time of this event.
       * @type {number}
       */
      get timeStamp() {
          return pd(this).timeStamp
      },
  
      /**
       * The target of this event.
       * @type {EventTarget}
       * @deprecated
       */
      get srcElement() {
          return pd(this).eventTarget
      },
  
      /**
       * The flag to stop event bubbling.
       * @type {boolean}
       * @deprecated
       */
      get cancelBubble() {
          return pd(this).stopped
      },
      set cancelBubble(value) {
          if (!value) {
              return
          }
          const data = pd(this);
  
          data.stopped = true;
          if (typeof data.event.cancelBubble === "boolean") {
              data.event.cancelBubble = true;
          }
      },
  
      /**
       * The flag to indicate cancellation state.
       * @type {boolean}
       * @deprecated
       */
      get returnValue() {
          return !pd(this).canceled
      },
      set returnValue(value) {
          if (!value) {
              setCancelFlag(pd(this));
          }
      },
  
      /**
       * Initialize this event object. But do nothing under event dispatching.
       * @param {string} type The event type.
       * @param {boolean} [bubbles=false] The flag to be possible to bubble up.
       * @param {boolean} [cancelable=false] The flag to be possible to cancel.
       * @deprecated
       */
      initEvent() {
          // Do nothing.
      },
  };
  
  // `constructor` is not enumerable.
  Object.defineProperty(Event.prototype, "constructor", {
      value: Event,
      configurable: true,
      writable: true,
  });
  
  // Ensure `event instanceof window.Event` is `true`.
  if (typeof window !== "undefined" && typeof window.Event !== "undefined") {
      Object.setPrototypeOf(Event.prototype, window.Event.prototype);
  
      // Make association for wrappers.
      wrappers.set(window.Event.prototype, Event);
  }
  
  /**
   * Get the property descriptor to redirect a given property.
   * @param {string} key Property name to define property descriptor.
   * @returns {PropertyDescriptor} The property descriptor to redirect the property.
   * @private
   */
  function defineRedirectDescriptor(key) {
      return {
          get() {
              return pd(this).event[key]
          },
          set(value) {
              pd(this).event[key] = value;
          },
          configurable: true,
          enumerable: true,
      }
  }
  
  /**
   * Get the property descriptor to call a given method property.
   * @param {string} key Property name to define property descriptor.
   * @returns {PropertyDescriptor} The property descriptor to call the method property.
   * @private
   */
  function defineCallDescriptor(key) {
      return {
          value() {
              const event = pd(this).event;
              return event[key].apply(event, arguments)
          },
          configurable: true,
          enumerable: true,
      }
  }
  
  /**
   * Define new wrapper class.
   * @param {Function} BaseEvent The base wrapper class.
   * @param {Object} proto The prototype of the original event.
   * @returns {Function} The defined wrapper class.
   * @private
   */
  function defineWrapper(BaseEvent, proto) {
      const keys = Object.keys(proto);
      if (keys.length === 0) {
          return BaseEvent
      }
  
      /** CustomEvent */
      function CustomEvent(eventTarget, event) {
          BaseEvent.call(this, eventTarget, event);
      }
  
      CustomEvent.prototype = Object.create(BaseEvent.prototype, {
          constructor: { value: CustomEvent, configurable: true, writable: true },
      });
  
      // Define accessors.
      for (let i = 0; i < keys.length; ++i) {
          const key = keys[i];
          if (!(key in BaseEvent.prototype)) {
              const descriptor = Object.getOwnPropertyDescriptor(proto, key);
              const isFunc = typeof descriptor.value === "function";
              Object.defineProperty(
                  CustomEvent.prototype,
                  key,
                  isFunc
                      ? defineCallDescriptor(key)
                      : defineRedirectDescriptor(key)
              );
          }
      }
  
      return CustomEvent
  }
  
  /**
   * Get the wrapper class of a given prototype.
   * @param {Object} proto The prototype of the original event to get its wrapper.
   * @returns {Function} The wrapper class.
   * @private
   */
  function getWrapper(proto) {
      if (proto == null || proto === Object.prototype) {
          return Event
      }
  
      let wrapper = wrappers.get(proto);
      if (wrapper == null) {
          wrapper = defineWrapper(getWrapper(Object.getPrototypeOf(proto)), proto);
          wrappers.set(proto, wrapper);
      }
      return wrapper
  }
  
  /**
   * Wrap a given event to management a dispatching.
   * @param {EventTarget} eventTarget The event target of this dispatching.
   * @param {Object} event The event to wrap.
   * @returns {Event} The wrapper instance.
   * @private
   */
  function wrapEvent(eventTarget, event) {
      const Wrapper = getWrapper(Object.getPrototypeOf(event));
      return new Wrapper(eventTarget, event)
  }
  
  /**
   * Get the immediateStopped flag of a given event.
   * @param {Event} event The event to get.
   * @returns {boolean} The flag to stop propagation immediately.
   * @private
   */
  function isStopped(event) {
      return pd(event).immediateStopped
  }
  
  /**
   * Set the current event phase of a given event.
   * @param {Event} event The event to set current target.
   * @param {number} eventPhase New event phase.
   * @returns {void}
   * @private
   */
  function setEventPhase(event, eventPhase) {
      pd(event).eventPhase = eventPhase;
  }
  
  /**
   * Set the current target of a given event.
   * @param {Event} event The event to set current target.
   * @param {EventTarget|null} currentTarget New current target.
   * @returns {void}
   * @private
   */
  function setCurrentTarget(event, currentTarget) {
      pd(event).currentTarget = currentTarget;
  }
  
  /**
   * Set a passive listener of a given event.
   * @param {Event} event The event to set current target.
   * @param {Function|null} passiveListener New passive listener.
   * @returns {void}
   * @private
   */
  function setPassiveListener(event, passiveListener) {
      pd(event).passiveListener = passiveListener;
  }
  
  /**
   * @typedef {object} ListenerNode
   * @property {Function} listener
   * @property {1|2|3} listenerType
   * @property {boolean} passive
   * @property {boolean} once
   * @property {ListenerNode|null} next
   * @private
   */
  
  /**
   * @type {WeakMap<object, Map<string, ListenerNode>>}
   * @private
   */
  const listenersMap = new WeakMap();
  
  // Listener types
  const CAPTURE = 1;
  const BUBBLE = 2;
  const ATTRIBUTE = 3;
  
  /**
   * Check whether a given value is an object or not.
   * @param {any} x The value to check.
   * @returns {boolean} `true` if the value is an object.
   */
  function isObject(x) {
      return x !== null && typeof x === "object" //eslint-disable-line no-restricted-syntax
  }
  
  /**
   * Get listeners.
   * @param {EventTarget} eventTarget The event target to get.
   * @returns {Map<string, ListenerNode>} The listeners.
   * @private
   */
  function getListeners(eventTarget) {
      const listeners = listenersMap.get(eventTarget);
      if (listeners == null) {
          throw new TypeError(
              "'this' is expected an EventTarget object, but got another value."
          )
      }
      return listeners
  }
  
  /**
   * Get the property descriptor for the event attribute of a given event.
   * @param {string} eventName The event name to get property descriptor.
   * @returns {PropertyDescriptor} The property descriptor.
   * @private
   */
  function defineEventAttributeDescriptor(eventName) {
      return {
          get() {
              const listeners = getListeners(this);
              let node = listeners.get(eventName);
              while (node != null) {
                  if (node.listenerType === ATTRIBUTE) {
                      return node.listener
                  }
                  node = node.next;
              }
              return null
          },
  
          set(listener) {
              if (typeof listener !== "function" && !isObject(listener)) {
                  listener = null; // eslint-disable-line no-param-reassign
              }
              const listeners = getListeners(this);
  
              // Traverse to the tail while removing old value.
              let prev = null;
              let node = listeners.get(eventName);
              while (node != null) {
                  if (node.listenerType === ATTRIBUTE) {
                      // Remove old value.
                      if (prev !== null) {
                          prev.next = node.next;
                      } else if (node.next !== null) {
                          listeners.set(eventName, node.next);
                      } else {
                          listeners.delete(eventName);
                      }
                  } else {
                      prev = node;
                  }
  
                  node = node.next;
              }
  
              // Add new value.
              if (listener !== null) {
                  const newNode = {
                      listener,
                      listenerType: ATTRIBUTE,
                      passive: false,
                      once: false,
                      next: null,
                  };
                  if (prev === null) {
                      listeners.set(eventName, newNode);
                  } else {
                      prev.next = newNode;
                  }
              }
          },
          configurable: true,
          enumerable: true,
      }
  }
  
  /**
   * Define an event attribute (e.g. `eventTarget.onclick`).
   * @param {Object} eventTargetPrototype The event target prototype to define an event attrbite.
   * @param {string} eventName The event name to define.
   * @returns {void}
   */
  function defineEventAttribute(eventTargetPrototype, eventName) {
      Object.defineProperty(
          eventTargetPrototype,
          `on${eventName}`,
          defineEventAttributeDescriptor(eventName)
      );
  }
  
  /**
   * Define a custom EventTarget with event attributes.
   * @param {string[]} eventNames Event names for event attributes.
   * @returns {EventTarget} The custom EventTarget.
   * @private
   */
  function defineCustomEventTarget(eventNames) {
      /** CustomEventTarget */
      function CustomEventTarget() {
          EventTarget.call(this);
      }
  
      CustomEventTarget.prototype = Object.create(EventTarget.prototype, {
          constructor: {
              value: CustomEventTarget,
              configurable: true,
              writable: true,
          },
      });
  
      for (let i = 0; i < eventNames.length; ++i) {
          defineEventAttribute(CustomEventTarget.prototype, eventNames[i]);
      }
  
      return CustomEventTarget
  }
  
  /**
   * EventTarget.
   *
   * - This is constructor if no arguments.
   * - This is a function which returns a CustomEventTarget constructor if there are arguments.
   *
   * For example:
   *
   *     class A extends EventTarget {}
   *     class B extends EventTarget("message") {}
   *     class C extends EventTarget("message", "error") {}
   *     class D extends EventTarget(["message", "error"]) {}
   */
  function EventTarget() {
      /*eslint-disable consistent-return */
      if (this instanceof EventTarget) {
          listenersMap.set(this, new Map());
          return
      }
      if (arguments.length === 1 && Array.isArray(arguments[0])) {
          return defineCustomEventTarget(arguments[0])
      }
      if (arguments.length > 0) {
          const types = new Array(arguments.length);
          for (let i = 0; i < arguments.length; ++i) {
              types[i] = arguments[i];
          }
          return defineCustomEventTarget(types)
      }
      throw new TypeError("Cannot call a class as a function")
      /*eslint-enable consistent-return */
  }
  
  // Should be enumerable, but class methods are not enumerable.
  EventTarget.prototype = {
      /**
       * Add a given listener to this event target.
       * @param {string} eventName The event name to add.
       * @param {Function} listener The listener to add.
       * @param {boolean|{capture?:boolean,passive?:boolean,once?:boolean}} [options] The options for this listener.
       * @returns {void}
       */
      addEventListener(eventName, listener, options) {
          if (listener == null) {
              return
          }
          if (typeof listener !== "function" && !isObject(listener)) {
              throw new TypeError("'listener' should be a function or an object.")
          }
  
          const listeners = getListeners(this);
          const optionsIsObj = isObject(options);
          const capture = optionsIsObj
              ? Boolean(options.capture)
              : Boolean(options);
          const listenerType = capture ? CAPTURE : BUBBLE;
          const newNode = {
              listener,
              listenerType,
              passive: optionsIsObj && Boolean(options.passive),
              once: optionsIsObj && Boolean(options.once),
              next: null,
          };
  
          // Set it as the first node if the first node is null.
          let node = listeners.get(eventName);
          if (node === undefined) {
              listeners.set(eventName, newNode);
              return
          }
  
          // Traverse to the tail while checking duplication..
          let prev = null;
          while (node != null) {
              if (
                  node.listener === listener &&
                  node.listenerType === listenerType
              ) {
                  // Should ignore duplication.
                  return
              }
              prev = node;
              node = node.next;
          }
  
          // Add it.
          prev.next = newNode;
      },
  
      /**
       * Remove a given listener from this event target.
       * @param {string} eventName The event name to remove.
       * @param {Function} listener The listener to remove.
       * @param {boolean|{capture?:boolean,passive?:boolean,once?:boolean}} [options] The options for this listener.
       * @returns {void}
       */
      removeEventListener(eventName, listener, options) {
          if (listener == null) {
              return
          }
  
          const listeners = getListeners(this);
          const capture = isObject(options)
              ? Boolean(options.capture)
              : Boolean(options);
          const listenerType = capture ? CAPTURE : BUBBLE;
  
          let prev = null;
          let node = listeners.get(eventName);
          while (node != null) {
              if (
                  node.listener === listener &&
                  node.listenerType === listenerType
              ) {
                  if (prev !== null) {
                      prev.next = node.next;
                  } else if (node.next !== null) {
                      listeners.set(eventName, node.next);
                  } else {
                      listeners.delete(eventName);
                  }
                  return
              }
  
              prev = node;
              node = node.next;
          }
      },
  
      /**
       * Dispatch a given event.
       * @param {Event|{type:string}} event The event to dispatch.
       * @returns {boolean} `false` if canceled.
       */
      dispatchEvent(event) {
          if (event == null || typeof event.type !== "string") {
              throw new TypeError('"event.type" should be a string.')
          }
  
          // If listeners aren't registered, terminate.
          const listeners = getListeners(this);
          const eventName = event.type;
          let node = listeners.get(eventName);
          if (node == null) {
              return true
          }
  
          // Since we cannot rewrite several properties, so wrap object.
          const wrappedEvent = wrapEvent(this, event);
  
          // This doesn't process capturing phase and bubbling phase.
          // This isn't participating in a tree.
          let prev = null;
          while (node != null) {
              // Remove this listener if it's once
              if (node.once) {
                  if (prev !== null) {
                      prev.next = node.next;
                  } else if (node.next !== null) {
                      listeners.set(eventName, node.next);
                  } else {
                      listeners.delete(eventName);
                  }
              } else {
                  prev = node;
              }
  
              // Call this listener
              setPassiveListener(
                  wrappedEvent,
                  node.passive ? node.listener : null
              );
              if (typeof node.listener === "function") {
                  try {
                      node.listener.call(this, wrappedEvent);
                  } catch (err) {
                      if (
                          typeof console !== "undefined" &&
                          typeof console.error === "function"
                      ) {
                          console.error(err);
                      }
                  }
              } else if (
                  node.listenerType !== ATTRIBUTE &&
                  typeof node.listener.handleEvent === "function"
              ) {
                  node.listener.handleEvent(wrappedEvent);
              }
  
              // Break if `event.stopImmediatePropagation` was called.
              if (isStopped(wrappedEvent)) {
                  break
              }
  
              node = node.next;
          }
          setPassiveListener(wrappedEvent, null);
          setEventPhase(wrappedEvent, 0);
          setCurrentTarget(wrappedEvent, null);
  
          return !wrappedEvent.defaultPrevented
      },
  };
  
  // `constructor` is not enumerable.
  Object.defineProperty(EventTarget.prototype, "constructor", {
      value: EventTarget,
      configurable: true,
      writable: true,
  });
  
  // Ensure `eventTarget instanceof window.EventTarget` is `true`.
  if (
      typeof window !== "undefined" &&
      typeof window.EventTarget !== "undefined"
  ) {
      Object.setPrototypeOf(EventTarget.prototype, window.EventTarget.prototype);
  }
  
  /**
   * @author Toru Nagashima <https://github.com/mysticatea>
   * See LICENSE file in root directory for full license.
   */
  
  /**
   * The signal class.
   * @see https://dom.spec.whatwg.org/#abortsignal
   */
  class AbortSignal extends EventTarget {
      /**
       * AbortSignal cannot be constructed directly.
       */
      constructor() {
          super();
          throw new TypeError("AbortSignal cannot be constructed directly");
      }
      /**
       * Returns `true` if this `AbortSignal`'s `AbortController` has signaled to abort, and `false` otherwise.
       */
      get aborted() {
          const aborted = abortedFlags.get(this);
          if (typeof aborted !== "boolean") {
              throw new TypeError(`Expected 'this' to be an 'AbortSignal' object, but got ${this === null ? "null" : typeof this}`);
          }
          return aborted;
      }
  }
  defineEventAttribute(AbortSignal.prototype, "abort");
  /**
   * Create an AbortSignal object.
   */
  function createAbortSignal() {
      const signal = Object.create(AbortSignal.prototype);
      EventTarget.call(signal);
      abortedFlags.set(signal, false);
      return signal;
  }
  /**
   * Abort a given signal.
   */
  function abortSignal(signal) {
      if (abortedFlags.get(signal) !== false) {
          return;
      }
      abortedFlags.set(signal, true);
      signal.dispatchEvent({ type: "abort" });
  }
  /**
   * Aborted flag for each instances.
   */
  const abortedFlags = new WeakMap();
  // Properties should be enumerable.
  Object.defineProperties(AbortSignal.prototype, {
      aborted: { enumerable: true },
  });
  // `toString()` should return `"[object AbortSignal]"`
  if (typeof Symbol === "function" && typeof Symbol.toStringTag === "symbol") {
      Object.defineProperty(AbortSignal.prototype, Symbol.toStringTag, {
          configurable: true,
          value: "AbortSignal",
      });
  }
  
  /**
   * The AbortController.
   * @see https://dom.spec.whatwg.org/#abortcontroller
   */
  class AbortController {
      /**
       * Initialize this controller.
       */
      constructor() {
          signals.set(this, createAbortSignal());
      }
      /**
       * Returns the `AbortSignal` object associated with this object.
       */
      get signal() {
          return getSignal(this);
      }
      /**
       * Abort and signal to any observers that the associated activity is to be aborted.
       */
      abort() {
          abortSignal(getSignal(this));
      }
  }
  /**
   * Associated signals.
   */
  const signals = new WeakMap();
  /**
   * Get the associated signal of a given controller.
   */
  function getSignal(controller) {
      const signal = signals.get(controller);
      if (signal == null) {
          throw new TypeError(`Expected 'this' to be an 'AbortController' object, but got ${controller === null ? "null" : typeof controller}`);
      }
      return signal;
  }
  // Properties should be enumerable.
  Object.defineProperties(AbortController.prototype, {
      signal: { enumerable: true },
      abort: { enumerable: true },
  });
  if (typeof Symbol === "function" && typeof Symbol.toStringTag === "symbol") {
      Object.defineProperty(AbortController.prototype, Symbol.toStringTag, {
          configurable: true,
          value: "AbortController",
      });
  }
  
  // Copyright (c) Microsoft Corporation. All rights reserved.
  var RestError = /** @class */ (function (_super) {
      tslib.__extends(RestError, _super);
      function RestError(message, code, statusCode, request, response, body) {
          var _this = _super.call(this, message) || this;
          _this.code = code;
          _this.statusCode = statusCode;
          _this.request = request;
          _this.response = response;
          _this.body = body;
          Object.setPrototypeOf(_this, RestError.prototype);
          return _this;
      }
      RestError.REQUEST_SEND_ERROR = "REQUEST_SEND_ERROR";
      RestError.REQUEST_ABORTED_ERROR = "REQUEST_ABORTED_ERROR";
      RestError.PARSE_ERROR = "PARSE_ERROR";
      return RestError;
  }(Error));
  
  // Copyright (c) Microsoft Corporation. All rights reserved.
  var FetchHttpClient = /** @class */ (function () {
      function FetchHttpClient() {
      }
      FetchHttpClient.prototype.sendRequest = function (httpRequest) {
          return tslib.__awaiter(this, void 0, void 0, function () {
              var abortController, abortListener, formData, requestForm_1, appendFormValue, _i, _a, formKey, formValue, j, contentType, body, loadedBytes_1, uploadReportStream, platformSpecificRequestInit, requestInit, operationResponse, response, headers, _b, _c, onDownloadProgress_1, responseBody, loadedBytes_2, downloadReportStream, length_1, error_1, fetchError, uploadStreamDone, downloadStreamDone;
              return tslib.__generator(this, function (_d) {
                  switch (_d.label) {
                      case 0:
                          if (!httpRequest && typeof httpRequest !== "object") {
                              throw new Error("'httpRequest' (WebResource) cannot be null or undefined and must be of type object.");
                          }
                          abortController = new AbortController();
                          if (httpRequest.abortSignal) {
                              if (httpRequest.abortSignal.aborted) {
                                  throw new RestError("The request was aborted", RestError.REQUEST_ABORTED_ERROR, undefined, httpRequest);
                              }
                              abortListener = function (event) {
                                  if (event.type === "abort") {
                                      abortController.abort();
                                  }
                              };
                              httpRequest.abortSignal.addEventListener("abort", abortListener);
                          }
                          if (httpRequest.timeout) {
                              setTimeout(function () {
                                  abortController.abort();
                              }, httpRequest.timeout);
                          }
                          if (httpRequest.formData) {
                              formData = httpRequest.formData;
                              requestForm_1 = new FormData();
                              appendFormValue = function (key, value) {
                                  // value function probably returns a stream so we can provide a fresh stream on each retry
                                  if (typeof value === "function") {
                                      value = value();
                                  }
                                  if (value && value.hasOwnProperty("value") && value.hasOwnProperty("options")) {
                                      requestForm_1.append(key, value.value, value.options);
                                  }
                                  else {
                                      requestForm_1.append(key, value);
                                  }
                              };
                              for (_i = 0, _a = Object.keys(formData); _i < _a.length; _i++) {
                                  formKey = _a[_i];
                                  formValue = formData[formKey];
                                  if (Array.isArray(formValue)) {
                                      for (j = 0; j < formValue.length; j++) {
                                          appendFormValue(formKey, formValue[j]);
                                      }
                                  }
                                  else {
                                      appendFormValue(formKey, formValue);
                                  }
                              }
                              httpRequest.body = requestForm_1;
                              httpRequest.formData = undefined;
                              contentType = httpRequest.headers.get("Content-Type");
                              if (contentType && contentType.indexOf("multipart/form-data") !== -1) {
                                  if (typeof requestForm_1.getBoundary === "function") {
                                      httpRequest.headers.set("Content-Type", "multipart/form-data; boundary=" + requestForm_1.getBoundary());
                                  }
                                  else {
                                      // browser will automatically apply a suitable content-type header
                                      httpRequest.headers.remove("Content-Type");
                                  }
                              }
                          }
                          body = httpRequest.body
                              ? typeof httpRequest.body === "function"
                                  ? httpRequest.body()
                                  : httpRequest.body
                              : undefined;
                          if (httpRequest.onUploadProgress && httpRequest.body) {
                              loadedBytes_1 = 0;
                              uploadReportStream = new stream.Transform({
                                  transform: function (chunk, _encoding, callback) {
                                      loadedBytes_1 += chunk.length;
                                      httpRequest.onUploadProgress({ loadedBytes: loadedBytes_1 });
                                      callback(undefined, chunk);
                                  },
                              });
                              if (isReadableStream(body)) {
                                  body.pipe(uploadReportStream);
                              }
                              else {
                                  uploadReportStream.end(body);
                              }
                              body = uploadReportStream;
                          }
                          return [4 /*yield*/, this.prepareRequest(httpRequest)];
                      case 1:
                          platformSpecificRequestInit = _d.sent();
                          requestInit = tslib.__assign({ body: body, headers: httpRequest.headers.rawHeaders(), method: httpRequest.method, signal: abortController.signal, redirect: "manual" }, platformSpecificRequestInit);
                          _d.label = 2;
                      case 2:
                          _d.trys.push([2, 8, 9, 10]);
                          return [4 /*yield*/, this.fetch(httpRequest.url, requestInit)];
                      case 3:
                          response = _d.sent();
                          headers = parseHeaders(response.headers);
                          _b = {
                              headers: headers,
                              request: httpRequest,
                              status: response.status,
                              readableStreamBody: httpRequest.streamResponseBody
                                  ? response.body
                                  : undefined
                          };
                          if (!!httpRequest.streamResponseBody) return [3 /*break*/, 5];
                          return [4 /*yield*/, response.text()];
                      case 4:
                          _c = _d.sent();
                          return [3 /*break*/, 6];
                      case 5:
                          _c = undefined;
                          _d.label = 6;
                      case 6:
                          operationResponse = (_b.bodyAsText = _c,
                              _b.redirected = response.redirected,
                              _b.url = response.url,
                              _b);
                          onDownloadProgress_1 = httpRequest.onDownloadProgress;
                          if (onDownloadProgress_1) {
                              responseBody = response.body || undefined;
                              if (isReadableStream(responseBody)) {
                                  loadedBytes_2 = 0;
                                  downloadReportStream = new stream.Transform({
                                      transform: function (chunk, _encoding, callback) {
                                          loadedBytes_2 += chunk.length;
                                          onDownloadProgress_1({ loadedBytes: loadedBytes_2 });
                                          callback(undefined, chunk);
                                      },
                                  });
                                  responseBody.pipe(downloadReportStream);
                                  operationResponse.readableStreamBody = downloadReportStream;
                              }
                              else {
                                  length_1 = parseInt(headers.get("Content-Length")) || undefined;
                                  if (length_1) {
                                      // Calling callback for non-stream response for consistency with browser
                                      onDownloadProgress_1({ loadedBytes: length_1 });
                                  }
                              }
                          }
                          return [4 /*yield*/, this.processRequest(operationResponse)];
                      case 7:
                          _d.sent();
                          return [2 /*return*/, operationResponse];
                      case 8:
                          error_1 = _d.sent();
                          fetchError = error_1;
                          if (fetchError.code === "ENOTFOUND") {
                              throw new RestError(fetchError.message, RestError.REQUEST_SEND_ERROR, undefined, httpRequest);
                          }
                          else if (fetchError.type === "aborted") {
                              throw new RestError("The request was aborted", RestError.REQUEST_ABORTED_ERROR, undefined, httpRequest);
                          }
                          throw fetchError;
                      case 9:
                          // clean up event listener
                          if (httpRequest.abortSignal && abortListener) {
                              uploadStreamDone = Promise.resolve();
                              if (isReadableStream(body)) {
                                  uploadStreamDone = isStreamComplete(body);
                              }
                              downloadStreamDone = Promise.resolve();
                              if (isReadableStream(operationResponse === null || operationResponse === void 0 ? void 0 : operationResponse.readableStreamBody)) {
                                  downloadStreamDone = isStreamComplete(operationResponse.readableStreamBody);
                              }
                              Promise.all([uploadStreamDone, downloadStreamDone])
                                  .then(function () {
                                  var _a;
                                  (_a = httpRequest.abortSignal) === null || _a === void 0 ? void 0 : _a.removeEventListener("abort", abortListener);
                                  return;
                              })
                                  .catch(function (_e) { });
                          }
                          return [7 /*endfinally*/];
                      case 10: return [2 /*return*/];
                  }
              });
          });
      };
      return FetchHttpClient;
  }());
  function isReadableStream(body) {
      return body && typeof body.pipe === "function";
  }
  function isStreamComplete(stream) {
      return new Promise(function (resolve) {
          stream.on("close", resolve);
          stream.on("end", resolve);
          stream.on("error", resolve);
      });
  }
  function parseHeaders(headers) {
      var httpHeaders = new HttpHeaders();
      headers.forEach(function (value, key) {
          httpHeaders.set(key, value);
      });
      return httpHeaders;
  }
  
  // Copyright (c) Microsoft Corporation. All rights reserved.
  /**
   * A class that handles the query portion of a URLBuilder.
   */
  var URLQuery = /** @class */ (function () {
      function URLQuery() {
          this._rawQuery = {};
      }
      /**
       * Get whether or not there any query parameters in this URLQuery.
       */
      URLQuery.prototype.any = function () {
          return Object.keys(this._rawQuery).length > 0;
      };
      /**
       * Set a query parameter with the provided name and value. If the parameterValue is undefined or
       * empty, then this will attempt to remove an existing query parameter with the provided
       * parameterName.
       */
      URLQuery.prototype.set = function (parameterName, parameterValue) {
          if (parameterName) {
              if (parameterValue != undefined) {
                  var newValue = Array.isArray(parameterValue) ? parameterValue : parameterValue.toString();
                  this._rawQuery[parameterName] = newValue;
              }
              else {
                  delete this._rawQuery[parameterName];
              }
          }
      };
      /**
       * Get the value of the query parameter with the provided name. If no parameter exists with the
       * provided parameter name, then undefined will be returned.
       */
      URLQuery.prototype.get = function (parameterName) {
          return parameterName ? this._rawQuery[parameterName] : undefined;
      };
      /**
       * Get the string representation of this query. The return value will not start with a "?".
       */
      URLQuery.prototype.toString = function () {
          var result = "";
          for (var parameterName in this._rawQuery) {
              if (result) {
                  result += "&";
              }
              var parameterValue = this._rawQuery[parameterName];
              if (Array.isArray(parameterValue)) {
                  var parameterStrings = [];
                  for (var _i = 0, parameterValue_1 = parameterValue; _i < parameterValue_1.length; _i++) {
                      var parameterValueElement = parameterValue_1[_i];
                      parameterStrings.push(parameterName + "=" + parameterValueElement);
                  }
                  result += parameterStrings.join("&");
              }
              else {
                  result += parameterName + "=" + parameterValue;
              }
          }
          return result;
      };
      /**
       * Parse a URLQuery from the provided text.
       */
      URLQuery.parse = function (text) {
          var result = new URLQuery();
          if (text) {
              if (text.startsWith("?")) {
                  text = text.substring(1);
              }
              var currentState = "ParameterName";
              var parameterName = "";
              var parameterValue = "";
              for (var i = 0; i < text.length; ++i) {
                  var currentCharacter = text[i];
                  switch (currentState) {
                      case "ParameterName":
                          switch (currentCharacter) {
                              case "=":
                                  currentState = "ParameterValue";
                                  break;
                              case "&":
                                  parameterName = "";
                                  parameterValue = "";
                                  break;
                              default:
                                  parameterName += currentCharacter;
                                  break;
                          }
                          break;
                      case "ParameterValue":
                          switch (currentCharacter) {
                              case "&":
                                  result.set(parameterName, parameterValue);
                                  parameterName = "";
                                  parameterValue = "";
                                  currentState = "ParameterName";
                                  break;
                              default:
                                  parameterValue += currentCharacter;
                                  break;
                          }
                          break;
                      default:
                          throw new Error("Unrecognized URLQuery parse state: " + currentState);
                  }
              }
              if (currentState === "ParameterValue") {
                  result.set(parameterName, parameterValue);
              }
          }
          return result;
      };
      return URLQuery;
  }());
  /**
   * A class that handles creating, modifying, and parsing URLs.
   */
  var URLBuilder = /** @class */ (function () {
      function URLBuilder() {
      }
      /**
       * Set the scheme/protocol for this URL. If the provided scheme contains other parts of a URL
       * (such as a host, port, path, or query), those parts will be added to this URL as well.
       */
      URLBuilder.prototype.setScheme = function (scheme) {
          if (!scheme) {
              this._scheme = undefined;
          }
          else {
              this.set(scheme, "SCHEME");
          }
      };
      /**
       * Get the scheme that has been set in this URL.
       */
      URLBuilder.prototype.getScheme = function () {
          return this._scheme;
      };
      /**
       * Set the host for this URL. If the provided host contains other parts of a URL (such as a
       * port, path, or query), those parts will be added to this URL as well.
       */
      URLBuilder.prototype.setHost = function (host) {
          if (!host) {
              this._host = undefined;
          }
          else {
              this.set(host, "SCHEME_OR_HOST");
          }
      };
      /**
       * Get the host that has been set in this URL.
       */
      URLBuilder.prototype.getHost = function () {
          return this._host;
      };
      /**
       * Set the port for this URL. If the provided port contains other parts of a URL (such as a
       * path or query), those parts will be added to this URL as well.
       */
      URLBuilder.prototype.setPort = function (port) {
          if (port == undefined || port === "") {
              this._port = undefined;
          }
          else {
              this.set(port.toString(), "PORT");
          }
      };
      /**
       * Get the port that has been set in this URL.
       */
      URLBuilder.prototype.getPort = function () {
          return this._port;
      };
      /**
       * Set the path for this URL. If the provided path contains a query, then it will be added to
       * this URL as well.
       */
      URLBuilder.prototype.setPath = function (path) {
          if (!path) {
              this._path = undefined;
          }
          else {
              var schemeIndex = path.indexOf("://");
              if (schemeIndex !== -1) {
                  var schemeStart = path.lastIndexOf("/", schemeIndex);
                  // Make sure to only grab the URL part of the path before setting the state back to SCHEME
                  // this will handle cases such as "/a/b/c/https://microsoft.com" => "https://microsoft.com"
                  this.set(schemeStart === -1 ? path : path.substr(schemeStart + 1), "SCHEME");
              }
              else {
                  this.set(path, "PATH");
              }
          }
      };
      /**
       * Append the provided path to this URL's existing path. If the provided path contains a query,
       * then it will be added to this URL as well.
       */
      URLBuilder.prototype.appendPath = function (path) {
          if (path) {
              var currentPath = this.getPath();
              if (currentPath) {
                  if (!currentPath.endsWith("/")) {
                      currentPath += "/";
                  }
                  if (path.startsWith("/")) {
                      path = path.substring(1);
                  }
                  path = currentPath + path;
              }
              this.set(path, "PATH");
          }
      };
      /**
       * Get the path that has been set in this URL.
       */
      URLBuilder.prototype.getPath = function () {
          return this._path;
      };
      /**
       * Set the query in this URL.
       */
      URLBuilder.prototype.setQuery = function (query) {
          if (!query) {
              this._query = undefined;
          }
          else {
              this._query = URLQuery.parse(query);
          }
      };
      /**
       * Set a query parameter with the provided name and value in this URL's query. If the provided
       * query parameter value is undefined or empty, then the query parameter will be removed if it
       * existed.
       */
      URLBuilder.prototype.setQueryParameter = function (queryParameterName, queryParameterValue) {
          if (queryParameterName) {
              if (!this._query) {
                  this._query = new URLQuery();
              }
              this._query.set(queryParameterName, queryParameterValue);
          }
      };
      /**
       * Get the value of the query parameter with the provided query parameter name. If no query
       * parameter exists with the provided name, then undefined will be returned.
       */
      URLBuilder.prototype.getQueryParameterValue = function (queryParameterName) {
          return this._query ? this._query.get(queryParameterName) : undefined;
      };
      /**
       * Get the query in this URL.
       */
      URLBuilder.prototype.getQuery = function () {
          return this._query ? this._query.toString() : undefined;
      };
      /**
       * Set the parts of this URL by parsing the provided text using the provided startState.
       */
      URLBuilder.prototype.set = function (text, startState) {
          var tokenizer = new URLTokenizer(text, startState);
          while (tokenizer.next()) {
              var token = tokenizer.current();
              if (token) {
                  switch (token.type) {
                      case "SCHEME":
                          this._scheme = token.text || undefined;
                          break;
                      case "HOST":
                          this._host = token.text || undefined;
                          break;
                      case "PORT":
                          this._port = token.text || undefined;
                          break;
                      case "PATH":
                          var tokenPath = token.text || undefined;
                          if (!this._path || this._path === "/" || tokenPath !== "/") {
                              this._path = tokenPath;
                          }
                          break;
                      case "QUERY":
                          this._query = URLQuery.parse(token.text);
                          break;
                      default:
                          throw new Error("Unrecognized URLTokenType: " + token.type);
                  }
              }
          }
      };
      URLBuilder.prototype.toString = function () {
          var result = "";
          if (this._scheme) {
              result += this._scheme + "://";
          }
          if (this._host) {
              result += this._host;
          }
          if (this._port) {
              result += ":" + this._port;
          }
          if (this._path) {
              if (!this._path.startsWith("/")) {
                  result += "/";
              }
              result += this._path;
          }
          if (this._query && this._query.any()) {
              result += "?" + this._query.toString();
          }
          return result;
      };
      /**
       * If the provided searchValue is found in this URLBuilder, then replace it with the provided
       * replaceValue.
       */
      URLBuilder.prototype.replaceAll = function (searchValue, replaceValue) {
          if (searchValue) {
              this.setScheme(replaceAll(this.getScheme(), searchValue, replaceValue));
              this.setHost(replaceAll(this.getHost(), searchValue, replaceValue));
              this.setPort(replaceAll(this.getPort(), searchValue, replaceValue));
              this.setPath(replaceAll(this.getPath(), searchValue, replaceValue));
              this.setQuery(replaceAll(this.getQuery(), searchValue, replaceValue));
          }
      };
      URLBuilder.parse = function (text) {
          var result = new URLBuilder();
          result.set(text, "SCHEME_OR_HOST");
          return result;
      };
      return URLBuilder;
  }());
  var URLToken = /** @class */ (function () {
      function URLToken(text, type) {
          this.text = text;
          this.type = type;
      }
      URLToken.scheme = function (text) {
          return new URLToken(text, "SCHEME");
      };
      URLToken.host = function (text) {
          return new URLToken(text, "HOST");
      };
      URLToken.port = function (text) {
          return new URLToken(text, "PORT");
      };
      URLToken.path = function (text) {
          return new URLToken(text, "PATH");
      };
      URLToken.query = function (text) {
          return new URLToken(text, "QUERY");
      };
      return URLToken;
  }());
  /**
   * Get whether or not the provided character (single character string) is an alphanumeric (letter or
   * digit) character.
   */
  function isAlphaNumericCharacter(character) {
      var characterCode = character.charCodeAt(0);
      return ((48 /* '0' */ <= characterCode && characterCode <= 57) /* '9' */ ||
          (65 /* 'A' */ <= characterCode && characterCode <= 90) /* 'Z' */ ||
          (97 /* 'a' */ <= characterCode && characterCode <= 122) /* 'z' */);
  }
  /**
   * A class that tokenizes URL strings.
   */
  var URLTokenizer = /** @class */ (function () {
      function URLTokenizer(_text, state) {
          this._text = _text;
          this._textLength = _text ? _text.length : 0;
          this._currentState = state != undefined ? state : "SCHEME_OR_HOST";
          this._currentIndex = 0;
      }
      /**
       * Get the current URLToken this URLTokenizer is pointing at, or undefined if the URLTokenizer
       * hasn't started or has finished tokenizing.
       */
      URLTokenizer.prototype.current = function () {
          return this._currentToken;
      };
      /**
       * Advance to the next URLToken and return whether or not a URLToken was found.
       */
      URLTokenizer.prototype.next = function () {
          if (!hasCurrentCharacter(this)) {
              this._currentToken = undefined;
          }
          else {
              switch (this._currentState) {
                  case "SCHEME":
                      nextScheme(this);
                      break;
                  case "SCHEME_OR_HOST":
                      nextSchemeOrHost(this);
                      break;
                  case "HOST":
                      nextHost(this);
                      break;
                  case "PORT":
                      nextPort(this);
                      break;
                  case "PATH":
                      nextPath(this);
                      break;
                  case "QUERY":
                      nextQuery(this);
                      break;
                  default:
                      throw new Error("Unrecognized URLTokenizerState: " + this._currentState);
              }
          }
          return !!this._currentToken;
      };
      return URLTokenizer;
  }());
  /**
   * Read the remaining characters from this Tokenizer's character stream.
   */
  function readRemaining(tokenizer) {
      var result = "";
      if (tokenizer._currentIndex < tokenizer._textLength) {
          result = tokenizer._text.substring(tokenizer._currentIndex);
          tokenizer._currentIndex = tokenizer._textLength;
      }
      return result;
  }
  /**
   * Whether or not this URLTokenizer has a current character.
   */
  function hasCurrentCharacter(tokenizer) {
      return tokenizer._currentIndex < tokenizer._textLength;
  }
  /**
   * Get the character in the text string at the current index.
   */
  function getCurrentCharacter(tokenizer) {
      return tokenizer._text[tokenizer._currentIndex];
  }
  /**
   * Advance to the character in text that is "step" characters ahead. If no step value is provided,
   * then step will default to 1.
   */
  function nextCharacter(tokenizer, step) {
      if (hasCurrentCharacter(tokenizer)) {
          if (!step) {
              step = 1;
          }
          tokenizer._currentIndex += step;
      }
  }
  /**
   * Starting with the current character, peek "charactersToPeek" number of characters ahead in this
   * Tokenizer's stream of characters.
   */
  function peekCharacters(tokenizer, charactersToPeek) {
      var endIndex = tokenizer._currentIndex + charactersToPeek;
      if (tokenizer._textLength < endIndex) {
          endIndex = tokenizer._textLength;
      }
      return tokenizer._text.substring(tokenizer._currentIndex, endIndex);
  }
  /**
   * Read characters from this Tokenizer until the end of the stream or until the provided condition
   * is false when provided the current character.
   */
  function readWhile(tokenizer, condition) {
      var result = "";
      while (hasCurrentCharacter(tokenizer)) {
          var currentCharacter = getCurrentCharacter(tokenizer);
          if (!condition(currentCharacter)) {
              break;
          }
          else {
              result += currentCharacter;
              nextCharacter(tokenizer);
          }
      }
      return result;
  }
  /**
   * Read characters from this Tokenizer until a non-alphanumeric character or the end of the
   * character stream is reached.
   */
  function readWhileLetterOrDigit(tokenizer) {
      return readWhile(tokenizer, function (character) { return isAlphaNumericCharacter(character); });
  }
  /**
   * Read characters from this Tokenizer until one of the provided terminating characters is read or
   * the end of the character stream is reached.
   */
  function readUntilCharacter(tokenizer) {
      var terminatingCharacters = [];
      for (var _i = 1; _i < arguments.length; _i++) {
          terminatingCharacters[_i - 1] = arguments[_i];
      }
      return readWhile(tokenizer, function (character) { return terminatingCharacters.indexOf(character) === -1; });
  }
  function nextScheme(tokenizer) {
      var scheme = readWhileLetterOrDigit(tokenizer);
      tokenizer._currentToken = URLToken.scheme(scheme);
      if (!hasCurrentCharacter(tokenizer)) {
          tokenizer._currentState = "DONE";
      }
      else {
          tokenizer._currentState = "HOST";
      }
  }
  function nextSchemeOrHost(tokenizer) {
      var schemeOrHost = readUntilCharacter(tokenizer, ":", "/", "?");
      if (!hasCurrentCharacter(tokenizer)) {
          tokenizer._currentToken = URLToken.host(schemeOrHost);
          tokenizer._currentState = "DONE";
      }
      else if (getCurrentCharacter(tokenizer) === ":") {
          if (peekCharacters(tokenizer, 3) === "://") {
              tokenizer._currentToken = URLToken.scheme(schemeOrHost);
              tokenizer._currentState = "HOST";
          }
          else {
              tokenizer._currentToken = URLToken.host(schemeOrHost);
              tokenizer._currentState = "PORT";
          }
      }
      else {
          tokenizer._currentToken = URLToken.host(schemeOrHost);
          if (getCurrentCharacter(tokenizer) === "/") {
              tokenizer._currentState = "PATH";
          }
          else {
              tokenizer._currentState = "QUERY";
          }
      }
  }
  function nextHost(tokenizer) {
      if (peekCharacters(tokenizer, 3) === "://") {
          nextCharacter(tokenizer, 3);
      }
      var host = readUntilCharacter(tokenizer, ":", "/", "?");
      tokenizer._currentToken = URLToken.host(host);
      if (!hasCurrentCharacter(tokenizer)) {
          tokenizer._currentState = "DONE";
      }
      else if (getCurrentCharacter(tokenizer) === ":") {
          tokenizer._currentState = "PORT";
      }
      else if (getCurrentCharacter(tokenizer) === "/") {
          tokenizer._currentState = "PATH";
      }
      else {
          tokenizer._currentState = "QUERY";
      }
  }
  function nextPort(tokenizer) {
      if (getCurrentCharacter(tokenizer) === ":") {
          nextCharacter(tokenizer);
      }
      var port = readUntilCharacter(tokenizer, "/", "?");
      tokenizer._currentToken = URLToken.port(port);
      if (!hasCurrentCharacter(tokenizer)) {
          tokenizer._currentState = "DONE";
      }
      else if (getCurrentCharacter(tokenizer) === "/") {
          tokenizer._currentState = "PATH";
      }
      else {
          tokenizer._currentState = "QUERY";
      }
  }
  function nextPath(tokenizer) {
      var path = readUntilCharacter(tokenizer, "?");
      tokenizer._currentToken = URLToken.path(path);
      if (!hasCurrentCharacter(tokenizer)) {
          tokenizer._currentState = "DONE";
      }
      else {
          tokenizer._currentState = "QUERY";
      }
  }
  function nextQuery(tokenizer) {
      if (getCurrentCharacter(tokenizer) === "?") {
          nextCharacter(tokenizer);
      }
      var query = readRemaining(tokenizer);
      tokenizer._currentToken = URLToken.query(query);
      tokenizer._currentState = "DONE";
  }
  
  // Copyright (c) Microsoft Corporation. All rights reserved.
  function createProxyAgent(requestUrl, proxySettings, headers) {
      var tunnelOptions = {
          proxy: {
              host: URLBuilder.parse(proxySettings.host).getHost(),
              port: proxySettings.port,
              headers: (headers && headers.rawHeaders()) || {},
          },
      };
      if (proxySettings.username && proxySettings.password) {
          tunnelOptions.proxy.proxyAuth = proxySettings.username + ":" + proxySettings.password;
      }
      else if (proxySettings.username) {
          tunnelOptions.proxy.proxyAuth = "" + proxySettings.username;
      }
      var requestScheme = URLBuilder.parse(requestUrl).getScheme() || "";
      var isRequestHttps = requestScheme.toLowerCase() === "https";
      var proxyScheme = URLBuilder.parse(proxySettings.host).getScheme() || "";
      var isProxyHttps = proxyScheme.toLowerCase() === "https";
      var proxyAgent = {
          isHttps: isRequestHttps,
          agent: createTunnel(isRequestHttps, isProxyHttps, tunnelOptions),
      };
      return proxyAgent;
  }
  function createTunnel(isRequestHttps, isProxyHttps, tunnelOptions) {
      if (isRequestHttps && isProxyHttps) {
          return tunnel.httpsOverHttps(tunnelOptions);
      }
      else if (isRequestHttps && !isProxyHttps) {
          return tunnel.httpsOverHttp(tunnelOptions);
      }
      else if (!isRequestHttps && isProxyHttps) {
          return tunnel.httpOverHttps(tunnelOptions);
      }
      else {
          return tunnel.httpOverHttp(tunnelOptions);
      }
  }
  
  // Copyright (c) Microsoft Corporation. All rights reserved.
  var NodeFetchHttpClient = /** @class */ (function (_super) {
      tslib.__extends(NodeFetchHttpClient, _super);
      function NodeFetchHttpClient() {
          var _this = _super !== null && _super.apply(this, arguments) || this;
          _this.cookieJar = new tough.CookieJar(undefined, { looseMode: true });
          return _this;
      }
      NodeFetchHttpClient.prototype.fetch = function (input, init) {
          return tslib.__awaiter(this, void 0, void 0, function () {
              return tslib.__generator(this, function (_a) {
                  return [2 /*return*/, node_fetch(input, init)];
              });
          });
      };
      NodeFetchHttpClient.prototype.prepareRequest = function (httpRequest) {
          return tslib.__awaiter(this, void 0, void 0, function () {
              var requestInit, cookieString, _a, httpAgent, httpsAgent, tunnel, options, agent;
              var _this = this;
              return tslib.__generator(this, function (_b) {
                  switch (_b.label) {
                      case 0:
                          requestInit = {};
                          if (!(this.cookieJar && !httpRequest.headers.get("Cookie"))) return [3 /*break*/, 2];
                          return [4 /*yield*/, new Promise(function (resolve, reject) {
                                  _this.cookieJar.getCookieString(httpRequest.url, function (err, cookie) {
                                      if (err) {
                                          reject(err);
                                      }
                                      else {
                                          resolve(cookie);
                                      }
                                  });
                              })];
                      case 1:
                          cookieString = _b.sent();
                          httpRequest.headers.set("Cookie", cookieString);
                          _b.label = 2;
                      case 2:
                          if (httpRequest.agentSettings) {
                              _a = httpRequest.agentSettings, httpAgent = _a.http, httpsAgent = _a.https;
                              if (httpsAgent && httpRequest.url.startsWith("https")) {
                                  requestInit.agent = httpsAgent;
                              }
                              else if (httpAgent) {
                                  requestInit.agent = httpAgent;
                              }
                          }
                          else if (httpRequest.proxySettings) {
                              tunnel = createProxyAgent(httpRequest.url, httpRequest.proxySettings, httpRequest.headers);
                              requestInit.agent = tunnel.agent;
                          }
                          if (httpRequest.keepAlive === true) {
                              if (requestInit.agent) {
                                  requestInit.agent.keepAlive = true;
                              }
                              else {
                                  options = { keepAlive: true };
                                  agent = httpRequest.url.startsWith("https")
                                      ? new https.Agent(options)
                                      : new http.Agent(options);
                                  requestInit.agent = agent;
                              }
                          }
                          return [2 /*return*/, requestInit];
                  }
              });
          });
      };
      NodeFetchHttpClient.prototype.processRequest = function (operationResponse) {
          return tslib.__awaiter(this, void 0, void 0, function () {
              var setCookieHeader_1;
              var _this = this;
              return tslib.__generator(this, function (_a) {
                  switch (_a.label) {
                      case 0:
                          if (!this.cookieJar) return [3 /*break*/, 2];
                          setCookieHeader_1 = operationResponse.headers.get("Set-Cookie");
                          if (!(setCookieHeader_1 != undefined)) return [3 /*break*/, 2];
                          return [4 /*yield*/, new Promise(function (resolve, reject) {
                                  _this.cookieJar.setCookie(setCookieHeader_1, operationResponse.request.url, { ignoreError: true }, function (err) {
                                      if (err) {
                                          reject(err);
                                      }
                                      else {
                                          resolve();
                                      }
                                  });
                              })];
                      case 1:
                          _a.sent();
                          _a.label = 2;
                      case 2: return [2 /*return*/];
                  }
              });
          });
      };
      return NodeFetchHttpClient;
  }(FetchHttpClient));
  
  // Copyright (c) Microsoft Corporation. All rights reserved.
  (function (HttpPipelineLogLevel) {
      /**
       * A log level that indicates that no logs will be logged.
       */
      HttpPipelineLogLevel[HttpPipelineLogLevel["OFF"] = 0] = "OFF";
      /**
       * An error log.
       */
      HttpPipelineLogLevel[HttpPipelineLogLevel["ERROR"] = 1] = "ERROR";
      /**
       * A warning log.
       */
      HttpPipelineLogLevel[HttpPipelineLogLevel["WARNING"] = 2] = "WARNING";
      /**
       * An information log.
       */
      HttpPipelineLogLevel[HttpPipelineLogLevel["INFO"] = 3] = "INFO";
  })(exports.HttpPipelineLogLevel || (exports.HttpPipelineLogLevel = {}));
  
  // Copyright (c) Microsoft Corporation.
  // Licensed under the MIT license.
  /**
   * Tests an object to determine whether it implements TokenCredential.
   *
   * @param credential - The assumed TokenCredential to be tested.
   */
  function isTokenCredential(credential) {
      // Check for an object with a 'getToken' function and possibly with
      // a 'signRequest' function.  We do this check to make sure that
      // a ServiceClientCredentials implementor (like TokenClientCredentials
      // in ms-rest-nodeauth) doesn't get mistaken for a TokenCredential if
      // it doesn't actually implement TokenCredential also.
      var castCredential = credential;
      return (castCredential &&
          typeof castCredential.getToken === "function" &&
          (castCredential.signRequest === undefined || castCredential.getToken.length > 0));
  }
  
  // Copyright (c) Microsoft Corporation. All rights reserved.
  // Licensed under the MIT License. See License.txt in the project root for license information.
  /**
   * Get the path to this parameter's value as a dotted string (a.b.c).
   * @param parameter The parameter to get the path string for.
   * @returns The path to this parameter's value as a dotted string.
   */
  function getPathStringFromParameter(parameter) {
      return getPathStringFromParameterPath(parameter.parameterPath, parameter.mapper);
  }
  function getPathStringFromParameterPath(parameterPath, mapper) {
      var result;
      if (typeof parameterPath === "string") {
          result = parameterPath;
      }
      else if (Array.isArray(parameterPath)) {
          result = parameterPath.join(".");
      }
      else {
          result = mapper.serializedName;
      }
      return result;
  }
  
  // Copyright (c) Microsoft Corporation. All rights reserved.
  function isStreamOperation(operationSpec) {
      var result = false;
      for (var statusCode in operationSpec.responses) {
          var operationResponse = operationSpec.responses[statusCode];
          if (operationResponse.bodyMapper &&
              operationResponse.bodyMapper.type.name === MapperType.Stream) {
              result = true;
              break;
          }
      }
      return result;
  }
  
  // Copyright (c) Microsoft Corporation. All rights reserved.
  function stringifyXML(obj, opts) {
      var builder = new xml2js.Builder({
          rootName: (opts || {}).rootName,
          renderOpts: {
              pretty: false,
          },
      });
      return builder.buildObject(obj);
  }
  function parseXML(str) {
      var xmlParser = new xml2js.Parser({
          explicitArray: false,
          explicitCharkey: false,
          explicitRoot: false,
      });
      return new Promise(function (resolve, reject) {
          if (!str) {
              reject(new Error("Document is empty"));
          }
          else {
              xmlParser.parseString(str, function (err, res) {
                  if (err) {
                      reject(err);
                  }
                  else {
                      resolve(res);
                  }
              });
          }
      });
  }
  
  // Copyright (c) Microsoft Corporation. All rights reserved.
  var BaseRequestPolicy = /** @class */ (function () {
      function BaseRequestPolicy(_nextPolicy, _options) {
          this._nextPolicy = _nextPolicy;
          this._options = _options;
      }
      /**
       * Get whether or not a log with the provided log level should be logged.
       * @param logLevel The log level of the log that will be logged.
       * @returns Whether or not a log with the provided log level should be logged.
       */
      BaseRequestPolicy.prototype.shouldLog = function (logLevel) {
          return this._options.shouldLog(logLevel);
      };
      /**
       * Attempt to log the provided message to the provided logger. If no logger was provided or if
       * the log level does not meat the logger's threshold, then nothing will be logged.
       * @param logLevel The log level of this log.
       * @param message The message of this log.
       */
      BaseRequestPolicy.prototype.log = function (logLevel, message) {
          this._options.log(logLevel, message);
      };
      return BaseRequestPolicy;
  }());
  /**
   * Optional properties that can be used when creating a RequestPolicy.
   */
  var RequestPolicyOptions = /** @class */ (function () {
      function RequestPolicyOptions(_logger) {
          this._logger = _logger;
      }
      /**
       * Get whether or not a log with the provided log level should be logged.
       * @param logLevel The log level of the log that will be logged.
       * @returns Whether or not a log with the provided log level should be logged.
       */
      RequestPolicyOptions.prototype.shouldLog = function (logLevel) {
          return (!!this._logger &&
              logLevel !== exports.HttpPipelineLogLevel.OFF &&
              logLevel <= this._logger.minimumLogLevel);
      };
      /**
       * Attempt to log the provided message to the provided logger. If no logger was provided or if
       * the log level does not meat the logger's threshold, then nothing will be logged.
       * @param logLevel The log level of this log.
       * @param message The message of this log.
       */
      RequestPolicyOptions.prototype.log = function (logLevel, message) {
          if (this._logger && this.shouldLog(logLevel)) {
              this._logger.log(logLevel, message);
          }
      };
      return RequestPolicyOptions;
  }());
  
  // Copyright (c) Microsoft Corporation. All rights reserved.
  /**
   * Create a new serialization RequestPolicyCreator that will serialized HTTP request bodies as they
   * pass through the HTTP pipeline.
   */
  function deserializationPolicy(deserializationContentTypes) {
      return {
          create: function (nextPolicy, options) {
              return new DeserializationPolicy(nextPolicy, deserializationContentTypes, options);
          },
      };
  }
  var defaultJsonContentTypes = ["application/json", "text/json"];
  var defaultXmlContentTypes = ["application/xml", "application/atom+xml"];
  /**
   * A RequestPolicy that will deserialize HTTP response bodies and headers as they pass through the
   * HTTP pipeline.
   */
  var DeserializationPolicy = /** @class */ (function (_super) {
      tslib.__extends(DeserializationPolicy, _super);
      function DeserializationPolicy(nextPolicy, deserializationContentTypes, options) {
          var _this = _super.call(this, nextPolicy, options) || this;
          _this.jsonContentTypes =
              (deserializationContentTypes && deserializationContentTypes.json) || defaultJsonContentTypes;
          _this.xmlContentTypes =
              (deserializationContentTypes && deserializationContentTypes.xml) || defaultXmlContentTypes;
          return _this;
      }
      DeserializationPolicy.prototype.sendRequest = function (request) {
          return tslib.__awaiter(this, void 0, void 0, function () {
              var _this = this;
              return tslib.__generator(this, function (_a) {
                  return [2 /*return*/, this._nextPolicy
                          .sendRequest(request)
                          .then(function (response) {
                          return deserializeResponseBody(_this.jsonContentTypes, _this.xmlContentTypes, response);
                      })];
              });
          });
      };
      return DeserializationPolicy;
  }(BaseRequestPolicy));
  function getOperationResponse(parsedResponse) {
      var result;
      var request = parsedResponse.request;
      var operationSpec = request.operationSpec;
      if (operationSpec) {
          var operationResponseGetter = request.operationResponseGetter;
          if (!operationResponseGetter) {
              result = operationSpec.responses[parsedResponse.status];
          }
          else {
              result = operationResponseGetter(operationSpec, parsedResponse);
          }
      }
      return result;
  }
  function shouldDeserializeResponse(parsedResponse) {
      var shouldDeserialize = parsedResponse.request.shouldDeserialize;
      var result;
      if (shouldDeserialize === undefined) {
          result = true;
      }
      else if (typeof shouldDeserialize === "boolean") {
          result = shouldDeserialize;
      }
      else {
          result = shouldDeserialize(parsedResponse);
      }
      return result;
  }
  function deserializeResponseBody(jsonContentTypes, xmlContentTypes, response) {
      return parse(jsonContentTypes, xmlContentTypes, response).then(function (parsedResponse) {
          var shouldDeserialize = shouldDeserializeResponse(parsedResponse);
          if (shouldDeserialize) {
              var operationSpec = parsedResponse.request.operationSpec;
              if (operationSpec && operationSpec.responses) {
                  var statusCode = parsedResponse.status;
                  var expectedStatusCodes = Object.keys(operationSpec.responses);
                  var hasNoExpectedStatusCodes = expectedStatusCodes.length === 0 ||
                      (expectedStatusCodes.length === 1 && expectedStatusCodes[0] === "default");
                  var responseSpec = getOperationResponse(parsedResponse);
                  var isExpectedStatusCode = hasNoExpectedStatusCodes
                      ? 200 <= statusCode && statusCode < 300
                      : !!responseSpec;
                  if (!isExpectedStatusCode) {
                      var defaultResponseSpec = operationSpec.responses.default;
                      if (defaultResponseSpec) {
                          var initialErrorMessage = isStreamOperation(operationSpec)
                              ? "Unexpected status code: " + statusCode
                              : parsedResponse.bodyAsText;
                          var error = new RestError(initialErrorMessage);
                          error.statusCode = statusCode;
                          error.request = stripRequest(parsedResponse.request);
                          error.response = stripResponse(parsedResponse);
                          var parsedErrorResponse = parsedResponse.parsedBody;
                          try {
                              if (parsedErrorResponse) {
                                  var defaultResponseBodyMapper = defaultResponseSpec.bodyMapper;
                                  if (defaultResponseBodyMapper &&
                                      defaultResponseBodyMapper.serializedName === "CloudError") {
                                      if (parsedErrorResponse.error) {
                                          parsedErrorResponse = parsedErrorResponse.error;
                                      }
                                      if (parsedErrorResponse.code) {
                                          error.code = parsedErrorResponse.code;
                                      }
                                      if (parsedErrorResponse.message) {
                                          error.message = parsedErrorResponse.message;
                                      }
                                  }
                                  else {
                                      var internalError = parsedErrorResponse;
                                      if (parsedErrorResponse.error) {
                                          internalError = parsedErrorResponse.error;
                                      }
                                      error.code = internalError.code;
                                      if (internalError.message) {
                                          error.message = internalError.message;
                                      }
                                  }
                                  if (defaultResponseBodyMapper) {
                                      var valueToDeserialize = parsedErrorResponse;
                                      if (operationSpec.isXML &&
                                          defaultResponseBodyMapper.type.name === MapperType.Sequence) {
                                          valueToDeserialize =
                                              typeof parsedErrorResponse === "object"
                                                  ? parsedErrorResponse[defaultResponseBodyMapper.xmlElementName]
                                                  : [];
                                      }
                                      error.body = operationSpec.serializer.deserialize(defaultResponseBodyMapper, valueToDeserialize, "error.body");
                                  }
                              }
                          }
                          catch (defaultError) {
                              error.message = "Error \"" + defaultError.message + "\" occurred in deserializing the responseBody - \"" + parsedResponse.bodyAsText + "\" for the default response.";
                          }
                          return Promise.reject(error);
                      }
                  }
                  else if (responseSpec) {
                      if (responseSpec.bodyMapper) {
                          var valueToDeserialize = parsedResponse.parsedBody;
                          if (operationSpec.isXML && responseSpec.bodyMapper.type.name === MapperType.Sequence) {
                              valueToDeserialize =
                                  typeof valueToDeserialize === "object"
                                      ? valueToDeserialize[responseSpec.bodyMapper.xmlElementName]
                                      : [];
                          }
                          try {
                              parsedResponse.parsedBody = operationSpec.serializer.deserialize(responseSpec.bodyMapper, valueToDeserialize, "operationRes.parsedBody");
                          }
                          catch (error) {
                              var restError = new RestError("Error " + error + " occurred in deserializing the responseBody - " + parsedResponse.bodyAsText);
                              restError.request = stripRequest(parsedResponse.request);
                              restError.response = stripResponse(parsedResponse);
                              return Promise.reject(restError);
                          }
                      }
                      else if (operationSpec.httpMethod === "HEAD") {
                          // head methods never have a body, but we return a boolean to indicate presence/absence of the resource
                          parsedResponse.parsedBody = response.status >= 200 && response.status < 300;
                      }
                      if (responseSpec.headersMapper) {
                          parsedResponse.parsedHeaders = operationSpec.serializer.deserialize(responseSpec.headersMapper, parsedResponse.headers.rawHeaders(), "operationRes.parsedHeaders");
                      }
                  }
              }
          }
          return Promise.resolve(parsedResponse);
      });
  }
  function parse(jsonContentTypes, xmlContentTypes, operationResponse) {
      var errorHandler = function (err) {
          var msg = "Error \"" + err + "\" occurred while parsing the response body - " + operationResponse.bodyAsText + ".";
          var errCode = err.code || RestError.PARSE_ERROR;
          var e = new RestError(msg, errCode, operationResponse.status, operationResponse.request, operationResponse, operationResponse.bodyAsText);
          return Promise.reject(e);
      };
      if (!operationResponse.request.streamResponseBody && operationResponse.bodyAsText) {
          var text_1 = operationResponse.bodyAsText;
          var contentType = operationResponse.headers.get("Content-Type") || "";
          var contentComponents = !contentType
              ? []
              : contentType.split(";").map(function (component) { return component.toLowerCase(); });
          if (contentComponents.length === 0 ||
              contentComponents.some(function (component) { return jsonContentTypes.indexOf(component) !== -1; })) {
              return new Promise(function (resolve) {
                  operationResponse.parsedBody = JSON.parse(text_1);
                  resolve(operationResponse);
              }).catch(errorHandler);
          }
          else if (contentComponents.some(function (component) { return xmlContentTypes.indexOf(component) !== -1; })) {
              return parseXML(text_1)
                  .then(function (body) {
                  operationResponse.parsedBody = body;
                  return operationResponse;
              })
                  .catch(errorHandler);
          }
      }
      return Promise.resolve(operationResponse);
  }
  
  // Copyright (c) Microsoft Corporation. All rights reserved.
  function exponentialRetryPolicy(retryCount, retryInterval, minRetryInterval, maxRetryInterval) {
      return {
          create: function (nextPolicy, options) {
              return new ExponentialRetryPolicy(nextPolicy, options, retryCount, retryInterval, minRetryInterval, maxRetryInterval);
          },
      };
  }
  var DEFAULT_CLIENT_RETRY_INTERVAL = 1000 * 30;
  var DEFAULT_CLIENT_RETRY_COUNT = 3;
  var DEFAULT_CLIENT_MAX_RETRY_INTERVAL = 1000 * 90;
  var DEFAULT_CLIENT_MIN_RETRY_INTERVAL = 1000 * 3;
  /**
   * @class
   * Instantiates a new "ExponentialRetryPolicyFilter" instance.
   */
  var ExponentialRetryPolicy = /** @class */ (function (_super) {
      tslib.__extends(ExponentialRetryPolicy, _super);
      /**
       * @constructor
       * @param {RequestPolicy} nextPolicy The next RequestPolicy in the pipeline chain.
       * @param {RequestPolicyOptionsLike} options The options for this RequestPolicy.
       * @param {number} [retryCount]        The client retry count.
       * @param {number} [retryInterval]     The client retry interval, in milliseconds.
       * @param {number} [minRetryInterval]  The minimum retry interval, in milliseconds.
       * @param {number} [maxRetryInterval]  The maximum retry interval, in milliseconds.
       */
      function ExponentialRetryPolicy(nextPolicy, options, retryCount, retryInterval, minRetryInterval, maxRetryInterval) {
          var _this = _super.call(this, nextPolicy, options) || this;
          function isNumber(n) {
              return typeof n === "number";
          }
          _this.retryCount = isNumber(retryCount) ? retryCount : DEFAULT_CLIENT_RETRY_COUNT;
          _this.retryInterval = isNumber(retryInterval) ? retryInterval : DEFAULT_CLIENT_RETRY_INTERVAL;
          _this.minRetryInterval = isNumber(minRetryInterval)
              ? minRetryInterval
              : DEFAULT_CLIENT_MIN_RETRY_INTERVAL;
          _this.maxRetryInterval = isNumber(maxRetryInterval)
              ? maxRetryInterval
              : DEFAULT_CLIENT_MAX_RETRY_INTERVAL;
          return _this;
      }
      ExponentialRetryPolicy.prototype.sendRequest = function (request) {
          var _this = this;
          return this._nextPolicy
              .sendRequest(request.clone())
              .then(function (response) { return retry(_this, request, response); })
              .catch(function (error) { return retry(_this, request, error.response, undefined, error); });
      };
      return ExponentialRetryPolicy;
  }(BaseRequestPolicy));
  /**
   * Determines if the operation should be retried and how long to wait until the next retry.
   *
   * @param {ExponentialRetryPolicy} policy The ExponentialRetryPolicy that this function is being called against.
   * @param {number} statusCode The HTTP status code.
   * @param {RetryData} retryData  The retry data.
   * @return {boolean} True if the operation qualifies for a retry; false otherwise.
   */
  function shouldRetry(policy, statusCode, retryData) {
      if (statusCode == undefined ||
          (statusCode < 500 && statusCode !== 408) ||
          statusCode === 501 ||
          statusCode === 505) {
          return false;
      }
      var currentCount;
      if (!retryData) {
          throw new Error("retryData for the ExponentialRetryPolicyFilter cannot be null.");
      }
      else {
          currentCount = retryData && retryData.retryCount;
      }
      return currentCount < policy.retryCount;
  }
  /**
   * Updates the retry data for the next attempt.
   *
   * @param {ExponentialRetryPolicy} policy The ExponentialRetryPolicy that this function is being called against.
   * @param {RetryData} retryData  The retry data.
   * @param {RetryError} [err] The operation"s error, if any.
   */
  function updateRetryData(policy, retryData, err) {
      if (!retryData) {
          retryData = {
              retryCount: 0,
              retryInterval: 0,
          };
      }
      if (err) {
          if (retryData.error) {
              err.innerError = retryData.error;
          }
          retryData.error = err;
      }
      // Adjust retry count
      retryData.retryCount++;
      // Adjust retry interval
      var incrementDelta = Math.pow(2, retryData.retryCount) - 1;
      var boundedRandDelta = policy.retryInterval * 0.8 +
          Math.floor(Math.random() * (policy.retryInterval * 1.2 - policy.retryInterval * 0.8));
      incrementDelta *= boundedRandDelta;
      retryData.retryInterval = Math.min(policy.minRetryInterval + incrementDelta, policy.maxRetryInterval);
      return retryData;
  }
  function retry(policy, request, response, retryData, requestError) {
      retryData = updateRetryData(policy, retryData, requestError);
      var isAborted = request.abortSignal && request.abortSignal.aborted;
      if (!isAborted && shouldRetry(policy, response && response.status, retryData)) {
          return delay(retryData.retryInterval)
              .then(function () { return policy._nextPolicy.sendRequest(request.clone()); })
              .then(function (res) { return retry(policy, request, res, retryData, undefined); })
              .catch(function (err) { return retry(policy, request, response, retryData, err); });
      }
      else if (isAborted || requestError || !response) {
          // If the operation failed in the end, return all errors instead of just the last one
          var err = retryData.error ||
              new RestError("Failed to send the request.", RestError.REQUEST_SEND_ERROR, response && response.status, response && response.request, response);
          return Promise.reject(err);
      }
      else {
          return Promise.resolve(response);
      }
  }
  
  // Copyright (c) Microsoft Corporation. All rights reserved.
  function generateClientRequestIdPolicy(requestIdHeaderName) {
      if (requestIdHeaderName === void 0) { requestIdHeaderName = "x-ms-client-request-id"; }
      return {
          create: function (nextPolicy, options) {
              return new GenerateClientRequestIdPolicy(nextPolicy, options, requestIdHeaderName);
          },
      };
  }
  var GenerateClientRequestIdPolicy = /** @class */ (function (_super) {
      tslib.__extends(GenerateClientRequestIdPolicy, _super);
      function GenerateClientRequestIdPolicy(nextPolicy, options, _requestIdHeaderName) {
          var _this = _super.call(this, nextPolicy, options) || this;
          _this._requestIdHeaderName = _requestIdHeaderName;
          return _this;
      }
      GenerateClientRequestIdPolicy.prototype.sendRequest = function (request) {
          if (!request.headers.contains(this._requestIdHeaderName)) {
              request.headers.set(this._requestIdHeaderName, generateUuid());
          }
          return this._nextPolicy.sendRequest(request);
      };
      return GenerateClientRequestIdPolicy;
  }(BaseRequestPolicy));
  
  // Copyright (c) Microsoft Corporation. All rights reserved.
  function getDefaultUserAgentKey() {
      return Constants.HeaderConstants.USER_AGENT;
  }
  function getPlatformSpecificData() {
      var runtimeInfo = {
          key: "Node",
          value: process.version,
      };
      var osInfo = {
          key: "OS",
          value: "(" + os.arch() + "-" + os.type() + "-" + os.release() + ")",
      };
      return [runtimeInfo, osInfo];
  }
  
  // Copyright (c) Microsoft Corporation. All rights reserved.
  function getRuntimeInfo() {
      var msRestRuntime = {
          key: "ms-rest-js",
          value: Constants.msRestVersion,
      };
      return [msRestRuntime];
  }
  function getUserAgentString(telemetryInfo, keySeparator, valueSeparator) {
      if (keySeparator === void 0) { keySeparator = " "; }
      if (valueSeparator === void 0) { valueSeparator = "/"; }
      return telemetryInfo
          .map(function (info) {
          var value = info.value ? "" + valueSeparator + info.value : "";
          return "" + info.key + value;
      })
          .join(keySeparator);
  }
  var getDefaultUserAgentHeaderName = getDefaultUserAgentKey;
  function getDefaultUserAgentValue() {
      var runtimeInfo = getRuntimeInfo();
      var platformSpecificData = getPlatformSpecificData();
      var userAgent = getUserAgentString(runtimeInfo.concat(platformSpecificData));
      return userAgent;
  }
  function userAgentPolicy(userAgentData) {
      var key = !userAgentData || userAgentData.key == undefined ? getDefaultUserAgentKey() : userAgentData.key;
      var value = !userAgentData || userAgentData.value == undefined
          ? getDefaultUserAgentValue()
          : userAgentData.value;
      return {
          create: function (nextPolicy, options) {
              return new UserAgentPolicy(nextPolicy, options, key, value);
          },
      };
  }
  var UserAgentPolicy = /** @class */ (function (_super) {
      tslib.__extends(UserAgentPolicy, _super);
      function UserAgentPolicy(_nextPolicy, _options, headerKey, headerValue) {
          var _this = _super.call(this, _nextPolicy, _options) || this;
          _this._nextPolicy = _nextPolicy;
          _this._options = _options;
          _this.headerKey = headerKey;
          _this.headerValue = headerValue;
          return _this;
      }
      UserAgentPolicy.prototype.sendRequest = function (request) {
          this.addUserAgentHeader(request);
          return this._nextPolicy.sendRequest(request);
      };
      UserAgentPolicy.prototype.addUserAgentHeader = function (request) {
          if (!request.headers) {
              request.headers = new HttpHeaders();
          }
          if (!request.headers.get(this.headerKey) && this.headerValue) {
              request.headers.set(this.headerKey, this.headerValue);
          }
      };
      return UserAgentPolicy;
  }(BaseRequestPolicy));
  
  // Copyright (c) Microsoft Corporation. All rights reserved.
  var DefaultRedirectOptions = {
      handleRedirects: true,
      maxRetries: 20,
  };
  function redirectPolicy(maximumRetries) {
      if (maximumRetries === void 0) { maximumRetries = 20; }
      return {
          create: function (nextPolicy, options) {
              return new RedirectPolicy(nextPolicy, options, maximumRetries);
          },
      };
  }
  var RedirectPolicy = /** @class */ (function (_super) {
      tslib.__extends(RedirectPolicy, _super);
      function RedirectPolicy(nextPolicy, options, maxRetries) {
          if (maxRetries === void 0) { maxRetries = 20; }
          var _this = _super.call(this, nextPolicy, options) || this;
          _this.maxRetries = maxRetries;
          return _this;
      }
      RedirectPolicy.prototype.sendRequest = function (request) {
          var _this = this;
          return this._nextPolicy
              .sendRequest(request)
              .then(function (response) { return handleRedirect(_this, response, 0); });
      };
      return RedirectPolicy;
  }(BaseRequestPolicy));
  function handleRedirect(policy, response, currentRetries) {
      var request = response.request, status = response.status;
      var locationHeader = response.headers.get("location");
      if (locationHeader &&
          (status === 300 ||
              (status === 301 && ["GET", "HEAD"].includes(request.method)) ||
              (status === 302 && ["GET", "POST", "HEAD"].includes(request.method)) ||
              (status === 303 && "POST" === request.method) ||
              status === 307) &&
          ((request.redirectLimit !== undefined && currentRetries < request.redirectLimit) ||
              (request.redirectLimit === undefined && currentRetries < policy.maxRetries))) {
          var builder = URLBuilder.parse(request.url);
          builder.setPath(locationHeader);
          request.url = builder.toString();
          // POST request with Status code 302 and 303 should be converted into a
          // redirected GET request if the redirect url is present in the location header
          // reference: https://tools.ietf.org/html/rfc7231#page-57 && https://fetch.spec.whatwg.org/#http-redirect-fetch
          if ((status === 302 || status === 303) && request.method === "POST") {
              request.method = "GET";
              delete request.body;
          }
          return policy._nextPolicy
              .sendRequest(request)
              .then(function (res) { return handleRedirect(policy, res, currentRetries + 1); })
              .then(function (res) { return recordRedirect(res, request.url); });
      }
      return Promise.resolve(response);
  }
  function recordRedirect(response, redirect) {
      // This is called as the recursive calls to handleRedirect() unwind,
      // only record the deepest/last redirect
      if (!response.redirected) {
          response.redirected = true;
          response.url = redirect;
      }
      return response;
  }
  
  function rpRegistrationPolicy(retryTimeout) {
      if (retryTimeout === void 0) { retryTimeout = 30; }
      return {
          create: function (nextPolicy, options) {
              return new RPRegistrationPolicy(nextPolicy, options, retryTimeout);
          },
      };
  }
  var RPRegistrationPolicy = /** @class */ (function (_super) {
      tslib.__extends(RPRegistrationPolicy, _super);
      function RPRegistrationPolicy(nextPolicy, options, _retryTimeout) {
          if (_retryTimeout === void 0) { _retryTimeout = 30; }
          var _this = _super.call(this, nextPolicy, options) || this;
          _this._retryTimeout = _retryTimeout;
          return _this;
      }
      RPRegistrationPolicy.prototype.sendRequest = function (request) {
          var _this = this;
          return this._nextPolicy
              .sendRequest(request.clone())
              .then(function (response) { return registerIfNeeded(_this, request, response); });
      };
      return RPRegistrationPolicy;
  }(BaseRequestPolicy));
  function registerIfNeeded(policy, request, response) {
      if (response.status === 409) {
          var rpName = checkRPNotRegisteredError(response.bodyAsText);
          if (rpName) {
              var urlPrefix = extractSubscriptionUrl(request.url);
              return (registerRP(policy, urlPrefix, rpName, request)
                  // Autoregistration of ${provider} failed for some reason. We will not return this error
                  // instead will return the initial response with 409 status code back to the user.
                  // do nothing here as we are returning the original response at the end of this method.
                  .catch(function () { return false; })
                  .then(function (registrationStatus) {
                  if (registrationStatus) {
                      // Retry the original request. We have to change the x-ms-client-request-id
                      // otherwise Azure endpoint will return the initial 409 (cached) response.
                      request.headers.set("x-ms-client-request-id", generateUuid());
                      return policy._nextPolicy.sendRequest(request.clone());
                  }
                  return response;
              }));
          }
      }
      return Promise.resolve(response);
  }
  /**
   * Reuses the headers of the original request and url (if specified).
   * @param {WebResourceLike} originalRequest The original request
   * @param {boolean} reuseUrlToo Should the url from the original request be reused as well. Default false.
   * @returns {object} A new request object with desired headers.
   */
  function getRequestEssentials(originalRequest, reuseUrlToo) {
      if (reuseUrlToo === void 0) { reuseUrlToo = false; }
      var reqOptions = originalRequest.clone();
      if (reuseUrlToo) {
          reqOptions.url = originalRequest.url;
      }
      // We have to change the x-ms-client-request-id otherwise Azure endpoint
      // will return the initial 409 (cached) response.
      reqOptions.headers.set("x-ms-client-request-id", generateUuid());
      // Set content-type to application/json
      reqOptions.headers.set("Content-Type", "application/json; charset=utf-8");
      return reqOptions;
  }
  /**
   * Validates the error code and message associated with 409 response status code. If it matches to that of
   * RP not registered then it returns the name of the RP else returns undefined.
   * @param {string} body The response body received after making the original request.
   * @returns {string} The name of the RP if condition is satisfied else undefined.
   */
  function checkRPNotRegisteredError(body) {
      var result, responseBody;
      if (body) {
          try {
              responseBody = JSON.parse(body);
          }
          catch (err) {
              // do nothing;
          }
          if (responseBody &&
              responseBody.error &&
              responseBody.error.message &&
              responseBody.error.code &&
              responseBody.error.code === "MissingSubscriptionRegistration") {
              var matchRes = responseBody.error.message.match(/.*'(.*)'/i);
              if (matchRes) {
                  result = matchRes.pop();
              }
          }
      }
      return result;
  }
  /**
   * Extracts the first part of the URL, just after subscription:
   * https://management.azure.com/subscriptions/00000000-0000-0000-0000-000000000000/
   * @param {string} url The original request url
   * @returns {string} The url prefix as explained above.
   */
  function extractSubscriptionUrl(url) {
      var result;
      var matchRes = url.match(/.*\/subscriptions\/[a-f0-9-]+\//gi);
      if (matchRes && matchRes[0]) {
          result = matchRes[0];
      }
      else {
          throw new Error("Unable to extract subscriptionId from the given url - " + url + ".");
      }
      return result;
  }
  /**
   * Registers the given provider.
   * @param {RPRegistrationPolicy} policy The RPRegistrationPolicy this function is being called against.
   * @param {string} urlPrefix https://management.azure.com/subscriptions/00000000-0000-0000-0000-000000000000/
   * @param {string} provider The provider name to be registered.
   * @param {WebResourceLike} originalRequest The original request sent by the user that returned a 409 response
   * with a message that the provider is not registered.
   * @param {registrationCallback} callback The callback that handles the RP registration
   */
  function registerRP(policy, urlPrefix, provider, originalRequest) {
      var postUrl = urlPrefix + "providers/" + provider + "/register?api-version=2016-02-01";
      var getUrl = urlPrefix + "providers/" + provider + "?api-version=2016-02-01";
      var reqOptions = getRequestEssentials(originalRequest);
      reqOptions.method = "POST";
      reqOptions.url = postUrl;
      return policy._nextPolicy.sendRequest(reqOptions).then(function (response) {
          if (response.status !== 200) {
              throw new Error("Autoregistration of " + provider + " failed. Please try registering manually.");
          }
          return getRegistrationStatus(policy, getUrl, originalRequest);
      });
  }
  /**
   * Polls the registration status of the provider that was registered. Polling happens at an interval of 30 seconds.
   * Polling will happen till the registrationState property of the response body is "Registered".
   * @param {RPRegistrationPolicy} policy The RPRegistrationPolicy this function is being called against.
   * @param {string} url The request url for polling
   * @param {WebResourceLike} originalRequest The original request sent by the user that returned a 409 response
   * with a message that the provider is not registered.
   * @returns {Promise<boolean>} True if RP Registration is successful.
   */
  function getRegistrationStatus(policy, url, originalRequest) {
      var reqOptions = getRequestEssentials(originalRequest);
      reqOptions.url = url;
      reqOptions.method = "GET";
      return policy._nextPolicy.sendRequest(reqOptions).then(function (res) {
          var obj = res.parsedBody;
          if (res.parsedBody && obj.registrationState && obj.registrationState === "Registered") {
              return true;
          }
          else {
              return delay(policy._retryTimeout * 1000)
                  .then(function () { return getRegistrationStatus(policy, url, originalRequest); });
          }
      });
  }
  
  // Copyright (c) Microsoft Corporation. All rights reserved.
  function signingPolicy(authenticationProvider) {
      return {
          create: function (nextPolicy, options) {
              return new SigningPolicy(nextPolicy, options, authenticationProvider);
          },
      };
  }
  var SigningPolicy = /** @class */ (function (_super) {
      tslib.__extends(SigningPolicy, _super);
      function SigningPolicy(nextPolicy, options, authenticationProvider) {
          var _this = _super.call(this, nextPolicy, options) || this;
          _this.authenticationProvider = authenticationProvider;
          return _this;
      }
      SigningPolicy.prototype.signRequest = function (request) {
          return this.authenticationProvider.signRequest(request);
      };
      SigningPolicy.prototype.sendRequest = function (request) {
          var _this = this;
          return this.signRequest(request).then(function (nextRequest) {
              return _this._nextPolicy.sendRequest(nextRequest);
          });
      };
      return SigningPolicy;
  }(BaseRequestPolicy));
  
  // Copyright (c) Microsoft Corporation. All rights reserved.
  function systemErrorRetryPolicy(retryCount, retryInterval, minRetryInterval, maxRetryInterval) {
      return {
          create: function (nextPolicy, options) {
              return new SystemErrorRetryPolicy(nextPolicy, options, retryCount, retryInterval, minRetryInterval, maxRetryInterval);
          },
      };
  }
  /**
   * @class
   * Instantiates a new "ExponentialRetryPolicyFilter" instance.
   *
   * @constructor
   * @param {number} retryCount        The client retry count.
   * @param {number} retryInterval     The client retry interval, in milliseconds.
   * @param {number} minRetryInterval  The minimum retry interval, in milliseconds.
   * @param {number} maxRetryInterval  The maximum retry interval, in milliseconds.
   */
  var SystemErrorRetryPolicy = /** @class */ (function (_super) {
      tslib.__extends(SystemErrorRetryPolicy, _super);
      function SystemErrorRetryPolicy(nextPolicy, options, retryCount, retryInterval, minRetryInterval, maxRetryInterval) {
          var _this = _super.call(this, nextPolicy, options) || this;
          _this.DEFAULT_CLIENT_RETRY_INTERVAL = 1000 * 30;
          _this.DEFAULT_CLIENT_RETRY_COUNT = 3;
          _this.DEFAULT_CLIENT_MAX_RETRY_INTERVAL = 1000 * 90;
          _this.DEFAULT_CLIENT_MIN_RETRY_INTERVAL = 1000 * 3;
          _this.retryCount = typeof retryCount === "number" ? retryCount : _this.DEFAULT_CLIENT_RETRY_COUNT;
          _this.retryInterval =
              typeof retryInterval === "number" ? retryInterval : _this.DEFAULT_CLIENT_RETRY_INTERVAL;
          _this.minRetryInterval =
              typeof minRetryInterval === "number"
                  ? minRetryInterval
                  : _this.DEFAULT_CLIENT_MIN_RETRY_INTERVAL;
          _this.maxRetryInterval =
              typeof maxRetryInterval === "number"
                  ? maxRetryInterval
                  : _this.DEFAULT_CLIENT_MAX_RETRY_INTERVAL;
          return _this;
      }
      SystemErrorRetryPolicy.prototype.sendRequest = function (request) {
          var _this = this;
          return this._nextPolicy
              .sendRequest(request.clone())
              .catch(function (error) { return retry$1(_this, request, error.response, error); });
      };
      return SystemErrorRetryPolicy;
  }(BaseRequestPolicy));
  /**
   * Determines if the operation should be retried and how long to wait until the next retry.
   *
   * @param {number} statusCode The HTTP status code.
   * @param {RetryData} retryData  The retry data.
   * @return {boolean} True if the operation qualifies for a retry; false otherwise.
   */
  function shouldRetry$1(policy, retryData) {
      var currentCount;
      if (!retryData) {
          throw new Error("retryData for the SystemErrorRetryPolicyFilter cannot be null.");
      }
      else {
          currentCount = retryData && retryData.retryCount;
      }
      return currentCount < policy.retryCount;
  }
  /**
   * Updates the retry data for the next attempt.
   *
   * @param {RetryData} retryData  The retry data.
   * @param {object} err        The operation"s error, if any.
   */
  function updateRetryData$1(policy, retryData, err) {
      if (!retryData) {
          retryData = {
              retryCount: 0,
              retryInterval: 0,
          };
      }
      if (err) {
          if (retryData.error) {
              err.innerError = retryData.error;
          }
          retryData.error = err;
      }
      // Adjust retry count
      retryData.retryCount++;
      // Adjust retry interval
      var incrementDelta = Math.pow(2, retryData.retryCount) - 1;
      var boundedRandDelta = policy.retryInterval * 0.8 + Math.floor(Math.random() * (policy.retryInterval * 0.4));
      incrementDelta *= boundedRandDelta;
      retryData.retryInterval = Math.min(policy.minRetryInterval + incrementDelta, policy.maxRetryInterval);
      return retryData;
  }
  function retry$1(policy, request, operationResponse, err, retryData) {
      return tslib.__awaiter(this, void 0, void 0, function () {
          var error_1;
          return tslib.__generator(this, function (_a) {
              switch (_a.label) {
                  case 0:
                      retryData = updateRetryData$1(policy, retryData, err);
                      if (!(err &&
                          err.code &&
                          shouldRetry$1(policy, retryData) &&
                          (err.code === "ETIMEDOUT" ||
                              err.code === "ESOCKETTIMEDOUT" ||
                              err.code === "ECONNREFUSED" ||
                              err.code === "ECONNRESET" ||
                              err.code === "ENOENT"))) return [3 /*break*/, 5];
                      _a.label = 1;
                  case 1:
                      _a.trys.push([1, 3, , 4]);
                      return [4 /*yield*/, delay(retryData.retryInterval)];
                  case 2:
                      _a.sent();
                      return [2 /*return*/, policy._nextPolicy.sendRequest(request.clone())];
                  case 3:
                      error_1 = _a.sent();
                      return [2 /*return*/, retry$1(policy, request, operationResponse, error_1, retryData)];
                  case 4: return [3 /*break*/, 6];
                  case 5:
                      if (err) {
                          // If the operation failed in the end, return all errors instead of just the last one
                          return [2 /*return*/, Promise.reject(retryData.error)];
                      }
                      return [2 /*return*/, operationResponse];
                  case 6: return [2 /*return*/];
              }
          });
      });
  }
  
  // Copyright (c) Microsoft Corporation. All rights reserved.
  (function (QueryCollectionFormat) {
      QueryCollectionFormat["Csv"] = ",";
      QueryCollectionFormat["Ssv"] = " ";
      QueryCollectionFormat["Tsv"] = "\t";
      QueryCollectionFormat["Pipes"] = "|";
      QueryCollectionFormat["Multi"] = "Multi";
  })(exports.QueryCollectionFormat || (exports.QueryCollectionFormat = {}));
  
  // Copyright (c) Microsoft Corporation. All rights reserved.
  function agentPolicy(agentSettings) {
      return {
          create: function (nextPolicy, options) {
              return new AgentPolicy(nextPolicy, options, agentSettings);
          },
      };
  }
  var AgentPolicy = /** @class */ (function (_super) {
      tslib.__extends(AgentPolicy, _super);
      function AgentPolicy(nextPolicy, options, agentSettings) {
          var _this = _super.call(this, nextPolicy, options) || this;
          _this.agentSettings = agentSettings;
          return _this;
      }
      AgentPolicy.prototype.sendRequest = function (request) {
          if (!request.agentSettings) {
              request.agentSettings = this.agentSettings;
          }
          return this._nextPolicy.sendRequest(request);
      };
      return AgentPolicy;
  }(BaseRequestPolicy));
  
  // Copyright (c) Microsoft Corporation. All rights reserved.
  /**
   * @internal
   */
  var noProxyList = loadNoProxy();
  var byPassedList = new Map();
  /**
   * @internal
   */
  function getEnvironmentValue(name) {
      if (process.env[name]) {
          return process.env[name];
      }
      else if (process.env[name.toLowerCase()]) {
          return process.env[name.toLowerCase()];
      }
      return undefined;
  }
  function loadEnvironmentProxyValue() {
      if (!process) {
          return undefined;
      }
      var httpsProxy = getEnvironmentValue(Constants.HTTPS_PROXY);
      var allProxy = getEnvironmentValue(Constants.ALL_PROXY);
      var httpProxy = getEnvironmentValue(Constants.HTTP_PROXY);
      return httpsProxy || allProxy || httpProxy;
  }
  // Check whether the host of a given `uri` is in the noProxyList.
  // If there's a match, any request sent to the same host won't have the proxy settings set.
  // This implementation is a port of https://github.com/Azure/azure-sdk-for-net/blob/8cca811371159e527159c7eb65602477898683e2/sdk/core/Azure.Core/src/Pipeline/Internal/HttpEnvironmentProxy.cs#L210
  function isBypassed(uri) {
      if (noProxyList.length === 0) {
          return false;
      }
      var host = URLBuilder.parse(uri).getHost();
      if (byPassedList.has(host)) {
          return byPassedList.get(host);
      }
      var isBypassedFlag = false;
      for (var _i = 0, noProxyList_1 = noProxyList; _i < noProxyList_1.length; _i++) {
          var pattern = noProxyList_1[_i];
          if (pattern[0] === ".") {
              // This should match either domain it self or any subdomain or host
              // .foo.com will match foo.com it self or *.foo.com
              if (host.endsWith(pattern)) {
                  isBypassedFlag = true;
              }
              else {
                  if (host.length === pattern.length - 1 && host === pattern.slice(1)) {
                      isBypassedFlag = true;
                  }
              }
          }
          else {
              if (host === pattern) {
                  isBypassedFlag = true;
              }
          }
      }
      byPassedList.set(host, isBypassedFlag);
      return isBypassedFlag;
  }
  /**
   * @internal
   */
  function loadNoProxy() {
      var noProxy = getEnvironmentValue(Constants.NO_PROXY);
      if (noProxy) {
          return noProxy
              .split(",")
              .map(function (item) { return item.trim(); })
              .filter(function (item) { return item.length; });
      }
      return [];
  }
  /**
   * @internal
   */
  function extractAuthFromUrl(url) {
      var atIndex = url.indexOf("@");
      if (atIndex === -1) {
          return { urlWithoutAuth: url };
      }
      var schemeIndex = url.indexOf("://");
      var authStart = schemeIndex !== -1 ? schemeIndex + 3 : 0;
      var auth = url.substring(authStart, atIndex);
      var colonIndex = auth.indexOf(":");
      var hasPassword = colonIndex !== -1;
      var username = hasPassword ? auth.substring(0, colonIndex) : auth;
      var password = hasPassword ? auth.substring(colonIndex + 1) : undefined;
      var urlWithoutAuth = url.substring(0, authStart) + url.substring(atIndex + 1);
      return {
          username: username,
          password: password,
          urlWithoutAuth: urlWithoutAuth,
      };
  }
  function getDefaultProxySettings(proxyUrl) {
      if (!proxyUrl) {
          proxyUrl = loadEnvironmentProxyValue();
          if (!proxyUrl) {
              return undefined;
          }
      }
      var _a = extractAuthFromUrl(proxyUrl), username = _a.username, password = _a.password, urlWithoutAuth = _a.urlWithoutAuth;
      var parsedUrl = URLBuilder.parse(urlWithoutAuth);
      var schema = parsedUrl.getScheme() ? parsedUrl.getScheme() + "://" : "";
      return {
          host: schema + parsedUrl.getHost(),
          port: Number.parseInt(parsedUrl.getPort() || "80"),
          username: username,
          password: password,
      };
  }
  function proxyPolicy(proxySettings) {
      if (!proxySettings) {
          proxySettings = getDefaultProxySettings();
      }
      return {
          create: function (nextPolicy, options) {
              return new ProxyPolicy(nextPolicy, options, proxySettings);
          },
      };
  }
  var ProxyPolicy = /** @class */ (function (_super) {
      tslib.__extends(ProxyPolicy, _super);
      function ProxyPolicy(nextPolicy, options, proxySettings) {
          var _this = _super.call(this, nextPolicy, options) || this;
          _this.proxySettings = proxySettings;
          return _this;
      }
      ProxyPolicy.prototype.sendRequest = function (request) {
          if (!request.proxySettings && !isBypassed(request.url)) {
              request.proxySettings = this.proxySettings;
          }
          return this._nextPolicy.sendRequest(request);
      };
      return ProxyPolicy;
  }(BaseRequestPolicy));
  
  // Copyright (c) Microsoft Corporation. All rights reserved.
  var StatusCodes = Constants.HttpConstants.StatusCodes;
  var DEFAULT_RETRY_COUNT = 3;
  function throttlingRetryPolicy(maxRetries) {
      if (maxRetries === void 0) { maxRetries = DEFAULT_RETRY_COUNT; }
      return {
          create: function (nextPolicy, options) {
              return new ThrottlingRetryPolicy(nextPolicy, options, maxRetries);
          },
      };
  }
  /**
   * To learn more, please refer to
   * https://docs.microsoft.com/en-us/azure/azure-resource-manager/resource-manager-request-limits,
   * https://docs.microsoft.com/en-us/azure/azure-subscription-service-limits and
   * https://docs.microsoft.com/en-us/azure/virtual-machines/troubleshooting/troubleshooting-throttling-errors
   */
  var ThrottlingRetryPolicy = /** @class */ (function (_super) {
      tslib.__extends(ThrottlingRetryPolicy, _super);
      function ThrottlingRetryPolicy(nextPolicy, options, retryLimit) {
          var _this = _super.call(this, nextPolicy, options) || this;
          _this.retryLimit = retryLimit;
          return _this;
      }
      ThrottlingRetryPolicy.prototype.sendRequest = function (httpRequest) {
          return tslib.__awaiter(this, void 0, void 0, function () {
              var _this = this;
              return tslib.__generator(this, function (_a) {
                  return [2 /*return*/, this._nextPolicy.sendRequest(httpRequest.clone()).then(function (response) {
                          return _this.retry(httpRequest, response, 0);
                      })];
              });
          });
      };
      ThrottlingRetryPolicy.prototype.retry = function (httpRequest, httpResponse, retryCount) {
          return tslib.__awaiter(this, void 0, void 0, function () {
              var retryAfterHeader, delayInMs, res;
              return tslib.__generator(this, function (_a) {
                  switch (_a.label) {
                      case 0:
                          if (httpResponse.status !== StatusCodes.TooManyRequests) {
                              return [2 /*return*/, httpResponse];
                          }
                          retryAfterHeader = httpResponse.headers.get(Constants.HeaderConstants.RETRY_AFTER);
                          if (!(retryAfterHeader && retryCount < this.retryLimit)) return [3 /*break*/, 3];
                          delayInMs = ThrottlingRetryPolicy.parseRetryAfterHeader(retryAfterHeader);
                          if (!delayInMs) return [3 /*break*/, 3];
                          return [4 /*yield*/, delay(delayInMs)];
                      case 1:
                          _a.sent();
                          return [4 /*yield*/, this._nextPolicy.sendRequest(httpRequest)];
                      case 2:
                          res = _a.sent();
                          return [2 /*return*/, this.retry(httpRequest, res, retryCount + 1)];
                      case 3: return [2 /*return*/, httpResponse];
                  }
              });
          });
      };
      ThrottlingRetryPolicy.parseRetryAfterHeader = function (headerValue) {
          var retryAfterInSeconds = Number(headerValue);
          if (Number.isNaN(retryAfterInSeconds)) {
              return ThrottlingRetryPolicy.parseDateRetryAfterHeader(headerValue);
          }
          else {
              return retryAfterInSeconds * 1000;
          }
      };
      ThrottlingRetryPolicy.parseDateRetryAfterHeader = function (headerValue) {
          try {
              var now = Date.now();
              var date = Date.parse(headerValue);
              var diff = date - now;
              return Number.isNaN(diff) ? undefined : diff;
          }
          catch (error) {
              return undefined;
          }
      };
      return ThrottlingRetryPolicy;
  }(BaseRequestPolicy));
  
  // Copyright (c) Microsoft Corporation. All rights reserved.
  var DEFAULT_AUTHORIZATION_SCHEME = "Bearer";
  /**
   * This class provides a simple extension to use {@link TokenCredential} from `@azure/identity` library to
   * use with legacy Azure SDKs that accept {@link ServiceClientCredentials} family of credentials for authentication.
   */
  var AzureIdentityCredentialAdapter = /** @class */ (function () {
      function AzureIdentityCredentialAdapter(azureTokenCredential, scopes) {
          if (scopes === void 0) { scopes = "https://management.azure.com/.default"; }
          this.azureTokenCredential = azureTokenCredential;
          this.scopes = scopes;
      }
      AzureIdentityCredentialAdapter.prototype.getToken = function () {
          return tslib.__awaiter(this, void 0, void 0, function () {
              var accessToken, result;
              return tslib.__generator(this, function (_a) {
                  switch (_a.label) {
                      case 0: return [4 /*yield*/, this.azureTokenCredential.getToken(this.scopes)];
                      case 1:
                          accessToken = _a.sent();
                          if (accessToken !== null) {
                              result = {
                                  accessToken: accessToken.token,
                                  tokenType: DEFAULT_AUTHORIZATION_SCHEME,
                                  expiresOn: accessToken.expiresOnTimestamp,
                              };
                              return [2 /*return*/, result];
                          }
                          else {
                              throw new Error("Could find token for scope");
                          }
                  }
              });
          });
      };
      AzureIdentityCredentialAdapter.prototype.signRequest = function (webResource) {
          return tslib.__awaiter(this, void 0, void 0, function () {
              var tokenResponse;
              return tslib.__generator(this, function (_a) {
                  switch (_a.label) {
                      case 0: return [4 /*yield*/, this.getToken()];
                      case 1:
                          tokenResponse = _a.sent();
                          webResource.headers.set(Constants.HeaderConstants.AUTHORIZATION, tokenResponse.tokenType + " " + tokenResponse.accessToken);
                          return [2 /*return*/, Promise.resolve(webResource)];
                  }
              });
          });
      };
      return AzureIdentityCredentialAdapter;
  }());
  
  // Copyright (c) Microsoft Corporation. All rights reserved.
  /**
   * @class
   * Initializes a new instance of the ServiceClient.
   */
  var ServiceClient = /** @class */ (function () {
      /**
       * The ServiceClient constructor
       * @constructor
       * @param {ServiceClientCredentials} [credentials] The credentials object used for authentication.
       * @param {ServiceClientOptions} [options] The service client options that govern the behavior of the client.
       */
      function ServiceClient(credentials, options) {
          if (!options) {
              options = {};
          }
          var serviceClientCredentials;
          if (isTokenCredential(credentials)) {
              serviceClientCredentials = new AzureIdentityCredentialAdapter(credentials);
          }
          else {
              serviceClientCredentials = credentials;
          }
          if (serviceClientCredentials && !serviceClientCredentials.signRequest) {
              throw new Error("credentials argument needs to implement signRequest method");
          }
          this._withCredentials = options.withCredentials || false;
          this._httpClient = options.httpClient || new NodeFetchHttpClient();
          this._requestPolicyOptions = new RequestPolicyOptions(options.httpPipelineLogger);
          var requestPolicyFactories;
          if (Array.isArray(options.requestPolicyFactories)) {
              requestPolicyFactories = options.requestPolicyFactories;
          }
          else {
              requestPolicyFactories = createDefaultRequestPolicyFactories(serviceClientCredentials, options);
              if (options.requestPolicyFactories) {
                  var newRequestPolicyFactories = options.requestPolicyFactories(requestPolicyFactories);
                  if (newRequestPolicyFactories) {
                      requestPolicyFactories = newRequestPolicyFactories;
                  }
              }
          }
          this._requestPolicyFactories = requestPolicyFactories;
      }
      /**
       * Send the provided httpRequest.
       */
      ServiceClient.prototype.sendRequest = function (options) {
          if (options === null || options === undefined || typeof options !== "object") {
              throw new Error("options cannot be null or undefined and it must be of type object.");
          }
          var httpRequest;
          try {
              if (isWebResourceLike(options)) {
                  options.validateRequestProperties();
                  httpRequest = options;
              }
              else {
                  httpRequest = new WebResource();
                  httpRequest = httpRequest.prepare(options);
              }
          }
          catch (error) {
              return Promise.reject(error);
          }
          var httpPipeline = this._httpClient;
          if (this._requestPolicyFactories && this._requestPolicyFactories.length > 0) {
              for (var i = this._requestPolicyFactories.length - 1; i >= 0; --i) {
                  httpPipeline = this._requestPolicyFactories[i].create(httpPipeline, this._requestPolicyOptions);
              }
          }
          return httpPipeline.sendRequest(httpRequest);
      };
      /**
       * Send an HTTP request that is populated using the provided OperationSpec.
       * @param {OperationArguments} operationArguments The arguments that the HTTP request's templated values will be populated from.
       * @param {OperationSpec} operationSpec The OperationSpec to use to populate the httpRequest.
       * @param {ServiceCallback} callback The callback to call when the response is received.
       */
      ServiceClient.prototype.sendOperationRequest = function (operationArguments, operationSpec, callback) {
          if (typeof operationArguments.options === "function") {
              callback = operationArguments.options;
              operationArguments.options = undefined;
          }
          var httpRequest = new WebResource();
          var result;
          try {
              var baseUri = operationSpec.baseUrl || this.baseUri;
              if (!baseUri) {
                  throw new Error("If operationSpec.baseUrl is not specified, then the ServiceClient must have a baseUri string property that contains the base URL to use.");
              }
              httpRequest.method = operationSpec.httpMethod;
              httpRequest.operationSpec = operationSpec;
              var requestUrl = URLBuilder.parse(baseUri);
              if (operationSpec.path) {
                  requestUrl.appendPath(operationSpec.path);
              }
              if (operationSpec.urlParameters && operationSpec.urlParameters.length > 0) {
                  for (var _i = 0, _a = operationSpec.urlParameters; _i < _a.length; _i++) {
                      var urlParameter = _a[_i];
                      var urlParameterValue = getOperationArgumentValueFromParameter(this, operationArguments, urlParameter, operationSpec.serializer);
                      urlParameterValue = operationSpec.serializer.serialize(urlParameter.mapper, urlParameterValue, getPathStringFromParameter(urlParameter));
                      if (!urlParameter.skipEncoding) {
                          urlParameterValue = encodeURIComponent(urlParameterValue);
                      }
                      requestUrl.replaceAll("{" + (urlParameter.mapper.serializedName || getPathStringFromParameter(urlParameter)) + "}", urlParameterValue);
                  }
              }
              if (operationSpec.queryParameters && operationSpec.queryParameters.length > 0) {
                  for (var _b = 0, _c = operationSpec.queryParameters; _b < _c.length; _b++) {
                      var queryParameter = _c[_b];
                      var queryParameterValue = getOperationArgumentValueFromParameter(this, operationArguments, queryParameter, operationSpec.serializer);
                      if (queryParameterValue != undefined) {
                          queryParameterValue = operationSpec.serializer.serialize(queryParameter.mapper, queryParameterValue, getPathStringFromParameter(queryParameter));
                          if (queryParameter.collectionFormat != undefined) {
                              if (queryParameter.collectionFormat === exports.QueryCollectionFormat.Multi) {
                                  if (queryParameterValue.length === 0) {
                                      queryParameterValue = "";
                                  }
                                  else {
                                      for (var index in queryParameterValue) {
                                          var item = queryParameterValue[index];
                                          queryParameterValue[index] = item == undefined ? "" : item.toString();
                                      }
                                  }
                              }
                              else if (queryParameter.collectionFormat === exports.QueryCollectionFormat.Ssv ||
                                  queryParameter.collectionFormat === exports.QueryCollectionFormat.Tsv) {
                                  queryParameterValue = queryParameterValue.join(queryParameter.collectionFormat);
                              }
                          }
                          if (!queryParameter.skipEncoding) {
                              if (Array.isArray(queryParameterValue)) {
                                  for (var index in queryParameterValue) {
                                      if (queryParameterValue[index] !== undefined &&
                                          queryParameterValue[index] !== null) {
                                          queryParameterValue[index] = encodeURIComponent(queryParameterValue[index]);
                                      }
                                  }
                              }
                              else {
                                  queryParameterValue = encodeURIComponent(queryParameterValue);
                              }
                          }
                          if (queryParameter.collectionFormat != undefined &&
                              queryParameter.collectionFormat !== exports.QueryCollectionFormat.Multi &&
                              queryParameter.collectionFormat !== exports.QueryCollectionFormat.Ssv &&
                              queryParameter.collectionFormat !== exports.QueryCollectionFormat.Tsv) {
                              queryParameterValue = queryParameterValue.join(queryParameter.collectionFormat);
                          }
                          requestUrl.setQueryParameter(queryParameter.mapper.serializedName || getPathStringFromParameter(queryParameter), queryParameterValue);
                      }
                  }
              }
              httpRequest.url = requestUrl.toString();
              var contentType = operationSpec.contentType || this.requestContentType;
              if (contentType) {
                  httpRequest.headers.set("Content-Type", contentType);
              }
              if (operationSpec.headerParameters) {
                  for (var _d = 0, _e = operationSpec.headerParameters; _d < _e.length; _d++) {
                      var headerParameter = _e[_d];
                      var headerValue = getOperationArgumentValueFromParameter(this, operationArguments, headerParameter, operationSpec.serializer);
                      if (headerValue != undefined) {
                          headerValue = operationSpec.serializer.serialize(headerParameter.mapper, headerValue, getPathStringFromParameter(headerParameter));
                          var headerCollectionPrefix = headerParameter.mapper
                              .headerCollectionPrefix;
                          if (headerCollectionPrefix) {
                              for (var _f = 0, _g = Object.keys(headerValue); _f < _g.length; _f++) {
                                  var key = _g[_f];
                                  httpRequest.headers.set(headerCollectionPrefix + key, headerValue[key]);
                              }
                          }
                          else {
                              httpRequest.headers.set(headerParameter.mapper.serializedName ||
                                  getPathStringFromParameter(headerParameter), headerValue);
                          }
                      }
                  }
              }
              var options = operationArguments.options;
              if (options) {
                  if (options.customHeaders) {
                      for (var customHeaderName in options.customHeaders) {
                          httpRequest.headers.set(customHeaderName, options.customHeaders[customHeaderName]);
                      }
                  }
                  if (options.abortSignal) {
                      httpRequest.abortSignal = options.abortSignal;
                  }
                  if (options.timeout) {
                      httpRequest.timeout = options.timeout;
                  }
                  if (options.onUploadProgress) {
                      httpRequest.onUploadProgress = options.onUploadProgress;
                  }
                  if (options.onDownloadProgress) {
                      httpRequest.onDownloadProgress = options.onDownloadProgress;
                  }
              }
              httpRequest.withCredentials = this._withCredentials;
              serializeRequestBody(this, httpRequest, operationArguments, operationSpec);
              if (httpRequest.streamResponseBody == undefined) {
                  httpRequest.streamResponseBody = isStreamOperation(operationSpec);
              }
              result = this.sendRequest(httpRequest).then(function (res) {
                  return flattenResponse(res, operationSpec.responses[res.status]);
              });
          }
          catch (error) {
              result = Promise.reject(error);
          }
          var cb = callback;
          if (cb) {
              result
                  // tslint:disable-next-line:no-null-keyword
                  .then(function (res) { return cb(null, res._response.parsedBody, res._response.request, res._response); })
                  .catch(function (err) { return cb(err); });
          }
          return result;
      };
      return ServiceClient;
  }());
  function serializeRequestBody(serviceClient, httpRequest, operationArguments, operationSpec) {
      if (operationSpec.requestBody && operationSpec.requestBody.mapper) {
          httpRequest.body = getOperationArgumentValueFromParameter(serviceClient, operationArguments, operationSpec.requestBody, operationSpec.serializer);
          var bodyMapper = operationSpec.requestBody.mapper;
          var required = bodyMapper.required, xmlName = bodyMapper.xmlName, xmlElementName = bodyMapper.xmlElementName, serializedName = bodyMapper.serializedName;
          var typeName = bodyMapper.type.name;
          try {
              if (httpRequest.body != undefined || required) {
                  var requestBodyParameterPathString = getPathStringFromParameter(operationSpec.requestBody);
                  httpRequest.body = operationSpec.serializer.serialize(bodyMapper, httpRequest.body, requestBodyParameterPathString);
                  var isStream = typeName === MapperType.Stream;
                  if (operationSpec.isXML) {
                      if (typeName === MapperType.Sequence) {
                          httpRequest.body = stringifyXML(prepareXMLRootList(httpRequest.body, xmlElementName || xmlName || serializedName), { rootName: xmlName || serializedName });
                      }
                      else if (!isStream) {
                          httpRequest.body = stringifyXML(httpRequest.body, {
                              rootName: xmlName || serializedName,
                          });
                      }
                  }
                  else if (!isStream) {
                      httpRequest.body = JSON.stringify(httpRequest.body);
                  }
              }
          }
          catch (error) {
              throw new Error("Error \"" + error.message + "\" occurred in serializing the payload - " + JSON.stringify(serializedName, undefined, "  ") + ".");
          }
      }
      else if (operationSpec.formDataParameters && operationSpec.formDataParameters.length > 0) {
          httpRequest.formData = {};
          for (var _i = 0, _a = operationSpec.formDataParameters; _i < _a.length; _i++) {
              var formDataParameter = _a[_i];
              var formDataParameterValue = getOperationArgumentValueFromParameter(serviceClient, operationArguments, formDataParameter, operationSpec.serializer);
              if (formDataParameterValue != undefined) {
                  var formDataParameterPropertyName = formDataParameter.mapper.serializedName || getPathStringFromParameter(formDataParameter);
                  httpRequest.formData[formDataParameterPropertyName] = operationSpec.serializer.serialize(formDataParameter.mapper, formDataParameterValue, getPathStringFromParameter(formDataParameter));
              }
          }
      }
  }
  function isRequestPolicyFactory(instance) {
      return typeof instance.create === "function";
  }
  function getValueOrFunctionResult(value, defaultValueCreator) {
      var result;
      if (typeof value === "string") {
          result = value;
      }
      else {
          result = defaultValueCreator();
          if (typeof value === "function") {
              result = value(result);
          }
      }
      return result;
  }
  function createDefaultRequestPolicyFactories(credentials, options) {
      var factories = [];
      if (options.generateClientRequestIdHeader) {
          factories.push(generateClientRequestIdPolicy(options.clientRequestIdHeaderName));
      }
      if (credentials) {
          if (isRequestPolicyFactory(credentials)) {
              factories.push(credentials);
          }
          else {
              factories.push(signingPolicy(credentials));
          }
      }
      var userAgentHeaderName = getValueOrFunctionResult(options.userAgentHeaderName, getDefaultUserAgentHeaderName);
      var userAgentHeaderValue = getValueOrFunctionResult(options.userAgent, getDefaultUserAgentValue);
      if (userAgentHeaderName && userAgentHeaderValue) {
          factories.push(userAgentPolicy({ key: userAgentHeaderName, value: userAgentHeaderValue }));
      }
      var redirectOptions = tslib.__assign(tslib.__assign({}, DefaultRedirectOptions), options.redirectOptions);
      if (redirectOptions.handleRedirects) {
          factories.push(redirectPolicy(redirectOptions.maxRetries));
      }
      factories.push(rpRegistrationPolicy(options.rpRegistrationRetryTimeout));
      if (!options.noRetryPolicy) {
          factories.push(exponentialRetryPolicy());
          factories.push(systemErrorRetryPolicy());
          factories.push(throttlingRetryPolicy());
      }
      factories.push(deserializationPolicy(options.deserializationContentTypes));
      var proxySettings = options.proxySettings || getDefaultProxySettings();
      if (proxySettings) {
          factories.push(proxyPolicy(proxySettings));
      }
      if (options.agentSettings) {
          factories.push(agentPolicy(options.agentSettings));
      }
      return factories;
  }
  function getOperationArgumentValueFromParameter(serviceClient, operationArguments, parameter, serializer) {
      return getOperationArgumentValueFromParameterPath(serviceClient, operationArguments, parameter.parameterPath, parameter.mapper, serializer);
  }
  function getOperationArgumentValueFromParameterPath(serviceClient, operationArguments, parameterPath, parameterMapper, serializer) {
      var value;
      if (typeof parameterPath === "string") {
          parameterPath = [parameterPath];
      }
      if (Array.isArray(parameterPath)) {
          if (parameterPath.length > 0) {
              if (parameterMapper.isConstant) {
                  value = parameterMapper.defaultValue;
              }
              else {
                  var propertySearchResult = getPropertyFromParameterPath(operationArguments, parameterPath);
                  if (!propertySearchResult.propertyFound) {
                      propertySearchResult = getPropertyFromParameterPath(serviceClient, parameterPath);
                  }
                  var useDefaultValue = false;
                  if (!propertySearchResult.propertyFound) {
                      useDefaultValue =
                          parameterMapper.required ||
                              (parameterPath[0] === "options" && parameterPath.length === 2);
                  }
                  value = useDefaultValue ? parameterMapper.defaultValue : propertySearchResult.propertyValue;
              }
              // Serialize just for validation purposes.
              var parameterPathString = getPathStringFromParameterPath(parameterPath, parameterMapper);
              serializer.serialize(parameterMapper, value, parameterPathString);
          }
      }
      else {
          if (parameterMapper.required) {
              value = {};
          }
          for (var propertyName in parameterPath) {
              var propertyMapper = parameterMapper.type.modelProperties[propertyName];
              var propertyPath = parameterPath[propertyName];
              var propertyValue = getOperationArgumentValueFromParameterPath(serviceClient, operationArguments, propertyPath, propertyMapper, serializer);
              // Serialize just for validation purposes.
              var propertyPathString = getPathStringFromParameterPath(propertyPath, propertyMapper);
              serializer.serialize(propertyMapper, propertyValue, propertyPathString);
              if (propertyValue !== undefined) {
                  if (!value) {
                      value = {};
                  }
                  value[propertyName] = propertyValue;
              }
          }
      }
      return value;
  }
  function getPropertyFromParameterPath(parent, parameterPath) {
      var result = { propertyFound: false };
      var i = 0;
      for (; i < parameterPath.length; ++i) {
          var parameterPathPart = parameterPath[i];
          // Make sure to check inherited properties too, so don't use hasOwnProperty().
          if (parent != undefined && parameterPathPart in parent) {
              parent = parent[parameterPathPart];
          }
          else {
              break;
          }
      }
      if (i === parameterPath.length) {
          result.propertyValue = parent;
          result.propertyFound = true;
      }
      return result;
  }
  function flattenResponse(_response, responseSpec) {
      var parsedHeaders = _response.parsedHeaders;
      var bodyMapper = responseSpec && responseSpec.bodyMapper;
      var addOperationResponse = function (obj) {
          return Object.defineProperty(obj, "_response", {
              value: _response,
          });
      };
      if (bodyMapper) {
          var typeName = bodyMapper.type.name;
          if (typeName === "Stream") {
              return addOperationResponse(tslib.__assign(tslib.__assign({}, parsedHeaders), { blobBody: _response.blobBody, readableStreamBody: _response.readableStreamBody }));
          }
          var modelProperties_1 = (typeName === "Composite" && bodyMapper.type.modelProperties) || {};
          var isPageableResponse = Object.keys(modelProperties_1).some(function (k) { return modelProperties_1[k].serializedName === ""; });
          if (typeName === "Sequence" || isPageableResponse) {
              // We're expecting a sequece(array) make sure that the response body is in the
              // correct format, if not make it an empty array []
              var parsedBody = Array.isArray(_response.parsedBody) ? _response.parsedBody : [];
              var arrayResponse = tslib.__spreadArrays(parsedBody);
              for (var _i = 0, _a = Object.keys(modelProperties_1); _i < _a.length; _i++) {
                  var key = _a[_i];
                  if (modelProperties_1[key].serializedName) {
                      arrayResponse[key] = _response.parsedBody[key];
                  }
              }
              if (parsedHeaders) {
                  for (var _b = 0, _c = Object.keys(parsedHeaders); _b < _c.length; _b++) {
                      var key = _c[_b];
                      arrayResponse[key] = parsedHeaders[key];
                  }
              }
              addOperationResponse(arrayResponse);
              return arrayResponse;
          }
          if (typeName === "Composite" || typeName === "Dictionary") {
              return addOperationResponse(tslib.__assign(tslib.__assign({}, parsedHeaders), _response.parsedBody));
          }
      }
      if (bodyMapper ||
          _response.request.method === "HEAD" ||
          isPrimitiveType(_response.parsedBody)) {
          // primitive body types and HEAD booleans
          return addOperationResponse(tslib.__assign(tslib.__assign({}, parsedHeaders), { body: _response.parsedBody }));
      }
      return addOperationResponse(tslib.__assign(tslib.__assign({}, parsedHeaders), _response.parsedBody));
  }
  
  // Copyright (c) Microsoft Corporation. All rights reserved.
  function logPolicy(logger) {
      if (logger === void 0) { logger = console.log; }
      return {
          create: function (nextPolicy, options) {
              return new LogPolicy(nextPolicy, options, logger);
          },
      };
  }
  var LogPolicy = /** @class */ (function (_super) {
      tslib.__extends(LogPolicy, _super);
      function LogPolicy(nextPolicy, options, logger) {
          if (logger === void 0) { logger = console.log; }
          var _this = _super.call(this, nextPolicy, options) || this;
          _this.logger = logger;
          return _this;
      }
      LogPolicy.prototype.sendRequest = function (request) {
          var _this = this;
          return this._nextPolicy.sendRequest(request).then(function (response) { return logResponse(_this, response); });
      };
      return LogPolicy;
  }(BaseRequestPolicy));
  function logResponse(policy, response) {
      policy.logger(">> Request: " + JSON.stringify(response.request, undefined, 2));
      policy.logger(">> Response status code: " + response.status);
      var responseBody = response.bodyAsText;
      policy.logger(">> Body: " + responseBody);
      return Promise.resolve(response);
  }
  
  // Copyright (c) Microsoft Corporation. All rights reserved.
  var HeaderConstants = Constants.HeaderConstants;
  var DEFAULT_AUTHORIZATION_SCHEME$1 = "Bearer";
  /**
   * A credentials object that uses a token string and a authorzation scheme to authenticate.
   */
  var TokenCredentials = /** @class */ (function () {
      /**
       * Creates a new TokenCredentials object.
       *
       * @constructor
       * @param {string} token The token.
       * @param {string} [authorizationScheme] The authorization scheme.
       */
      function TokenCredentials(token, authorizationScheme) {
          if (authorizationScheme === void 0) { authorizationScheme = DEFAULT_AUTHORIZATION_SCHEME$1; }
          this.authorizationScheme = DEFAULT_AUTHORIZATION_SCHEME$1;
          if (!token) {
              throw new Error("token cannot be null or undefined.");
          }
          this.token = token;
          this.authorizationScheme = authorizationScheme;
      }
      /**
       * Signs a request with the Authentication header.
       *
       * @param {WebResourceLike} webResource The WebResourceLike to be signed.
       * @return {Promise<WebResourceLike>} The signed request object.
       */
      TokenCredentials.prototype.signRequest = function (webResource) {
          if (!webResource.headers)
              webResource.headers = new HttpHeaders();
          webResource.headers.set(HeaderConstants.AUTHORIZATION, this.authorizationScheme + " " + this.token);
          return Promise.resolve(webResource);
      };
      return TokenCredentials;
  }());
  
  // Copyright (c) Microsoft Corporation. All rights reserved.
  var HeaderConstants$1 = Constants.HeaderConstants;
  var DEFAULT_AUTHORIZATION_SCHEME$2 = "Basic";
  var BasicAuthenticationCredentials = /** @class */ (function () {
      /**
       * Creates a new BasicAuthenticationCredentials object.
       *
       * @constructor
       * @param {string} userName User name.
       * @param {string} password Password.
       * @param {string} [authorizationScheme] The authorization scheme.
       */
      function BasicAuthenticationCredentials(userName, password, authorizationScheme) {
          if (authorizationScheme === void 0) { authorizationScheme = DEFAULT_AUTHORIZATION_SCHEME$2; }
          this.authorizationScheme = DEFAULT_AUTHORIZATION_SCHEME$2;
          if (userName === null || userName === undefined || typeof userName.valueOf() !== "string") {
              throw new Error("userName cannot be null or undefined and must be of type string.");
          }
          if (password === null || password === undefined || typeof password.valueOf() !== "string") {
              throw new Error("password cannot be null or undefined and must be of type string.");
          }
          this.userName = userName;
          this.password = password;
          this.authorizationScheme = authorizationScheme;
      }
      /**
       * Signs a request with the Authentication header.
       *
       * @param {WebResourceLike} webResource The WebResourceLike to be signed.
       * @returns {Promise<WebResourceLike>} The signed request object.
       */
      BasicAuthenticationCredentials.prototype.signRequest = function (webResource) {
          var credentials = this.userName + ":" + this.password;
          var encodedCredentials = this.authorizationScheme + " " + encodeString(credentials);
          if (!webResource.headers)
              webResource.headers = new HttpHeaders();
          webResource.headers.set(HeaderConstants$1.AUTHORIZATION, encodedCredentials);
          return Promise.resolve(webResource);
      };
      return BasicAuthenticationCredentials;
  }());
  
  // Copyright (c) Microsoft Corporation. All rights reserved.
  /**
   * Authenticates to a service using an API key.
   */
  var ApiKeyCredentials = /** @class */ (function () {
      /**
       * @constructor
       * @param {object} options   Specifies the options to be provided for auth. Either header or query needs to be provided.
       */
      function ApiKeyCredentials(options) {
          if (!options || (options && !options.inHeader && !options.inQuery)) {
              throw new Error("options cannot be null or undefined. Either \"inHeader\" or \"inQuery\" property of the options object needs to be provided.");
          }
          this.inHeader = options.inHeader;
          this.inQuery = options.inQuery;
      }
      /**
       * Signs a request with the values provided in the inHeader and inQuery parameter.
       *
       * @param {WebResource} webResource The WebResource to be signed.
       * @returns {Promise<WebResource>} The signed request object.
       */
      ApiKeyCredentials.prototype.signRequest = function (webResource) {
          if (!webResource) {
              return Promise.reject(new Error("webResource cannot be null or undefined and must be of type \"object\"."));
          }
          if (this.inHeader) {
              if (!webResource.headers) {
                  webResource.headers = new HttpHeaders();
              }
              for (var headerName in this.inHeader) {
                  webResource.headers.set(headerName, this.inHeader[headerName]);
              }
          }
          if (this.inQuery) {
              if (!webResource.url) {
                  return Promise.reject(new Error("url cannot be null in the request object."));
              }
              if (webResource.url.indexOf("?") < 0) {
                  webResource.url += "?";
              }
              for (var key in this.inQuery) {
                  if (!webResource.url.endsWith("?")) {
                      webResource.url += "&";
                  }
                  webResource.url += key + "=" + this.inQuery[key];
              }
          }
          return Promise.resolve(webResource);
      };
      return ApiKeyCredentials;
  }());
  
  // Copyright (c) Microsoft Corporation. All rights reserved.
  var TopicCredentials = /** @class */ (function (_super) {
      tslib.__extends(TopicCredentials, _super);
      /**
       * Creates a new EventGrid TopicCredentials object.
       *
       * @constructor
       * @param {string} topicKey   The EventGrid topic key
       */
      function TopicCredentials(topicKey) {
          var _this = this;
          if (!topicKey || (topicKey && typeof topicKey !== "string")) {
              throw new Error("topicKey cannot be null or undefined and must be of type string.");
          }
          var options = {
              inHeader: {
                  "aeg-sas-key": topicKey,
              },
          };
          _this = _super.call(this, options) || this;
          return _this;
      }
      return TopicCredentials;
  }(ApiKeyCredentials));
  
  // Copyright (c) Microsoft Corporation. All rights reserved.
  var DomainCredentials = /** @class */ (function (_super) {
      tslib.__extends(DomainCredentials, _super);
      /**
       * Creates a new EventGrid DomainCredentials object.
       *
       * @constructor
       * @param {string} domainKey   The EventGrid domain key
       */
      function DomainCredentials(domainKey) {
          var _this = this;
          if (!domainKey || (domainKey && typeof domainKey !== "string")) {
              throw new Error("domainKey cannot be null or undefined and must be of type string.");
          }
          var options = {
              inHeader: {
                  "aeg-sas-key": domainKey,
              },
          };
          _this = _super.call(this, options) || this;
          return _this;
      }
      return DomainCredentials;
  }(ApiKeyCredentials));
  
  exports.ApiKeyCredentials = ApiKeyCredentials;
  exports.AzureIdentityCredentialAdapter = AzureIdentityCredentialAdapter;
  exports.BaseRequestPolicy = BaseRequestPolicy;
  exports.BasicAuthenticationCredentials = BasicAuthenticationCredentials;
  exports.Constants = Constants;
  exports.DefaultHttpClient = NodeFetchHttpClient;
  exports.DomainCredentials = DomainCredentials;
  exports.HttpHeaders = HttpHeaders;
  exports.MapperType = MapperType;
  exports.RequestPolicyOptions = RequestPolicyOptions;
  exports.RestError = RestError;
  exports.Serializer = Serializer;
  exports.ServiceClient = ServiceClient;
  exports.TokenCredentials = TokenCredentials;
  exports.TopicCredentials = TopicCredentials;
  exports.URLBuilder = URLBuilder;
  exports.URLQuery = URLQuery;
  exports.WebResource = WebResource;
  exports.agentPolicy = agentPolicy;
  exports.applyMixins = applyMixins;
  exports.delay = delay;
  exports.deserializationPolicy = deserializationPolicy;
  exports.deserializeResponseBody = deserializeResponseBody;
  exports.encodeUri = encodeUri;
  exports.executePromisesSequentially = executePromisesSequentially;
  exports.exponentialRetryPolicy = exponentialRetryPolicy;
  exports.flattenResponse = flattenResponse;
  exports.generateClientRequestIdPolicy = generateClientRequestIdPolicy;
  exports.generateUuid = generateUuid;
  exports.getDefaultProxySettings = getDefaultProxySettings;
  exports.getDefaultUserAgentValue = getDefaultUserAgentValue;
  exports.isDuration = isDuration;
  exports.isNode = isNode;
  exports.isValidUuid = isValidUuid;
  exports.logPolicy = logPolicy;
  exports.promiseToCallback = promiseToCallback;
  exports.promiseToServiceCallback = promiseToServiceCallback;
  exports.proxyPolicy = proxyPolicy;
  exports.redirectPolicy = redirectPolicy;
  exports.serializeObject = serializeObject;
  exports.signingPolicy = signingPolicy;
  exports.stripRequest = stripRequest;
  exports.stripResponse = stripResponse;
  exports.systemErrorRetryPolicy = systemErrorRetryPolicy;
  exports.throttlingRetryPolicy = throttlingRetryPolicy;
  exports.userAgentPolicy = userAgentPolicy;
  //# sourceMappingURL=msRest.node.js.map
  