@ms-cloudpack/remote-cache 0.10.10 → 0.10.12

package/dist/index.js

@@ -5,16 +5,4673 @@ const require = topLevelCreateRequire(import.meta.url);
 const __filename = topLevelUrl.fileURLToPath(import.meta.url);
 const __dirname = topLevelPath.dirname(__filename);
 import {
+  require_commonjs as require_commonjs5,
+  require_commonjs2 as require_commonjs7,
   require_dist
-} from "./chunk-RCTPZOA2.js";
+} from "./chunk-EZBP4ZKN.js";
 import {
-  require_commonjs
-} from "./chunk-AAHKL65V.js";
+  init_tslib_es6,
+  require_commonjs,
+  require_commonjs3 as require_commonjs2,
+  require_commonjs4 as require_commonjs3,
+  require_commonjs5 as require_commonjs4,
+  require_commonjs6,
+  tslib_es6_exports
+} from "./chunk-E464X2TG.js";
 import {
+  __commonJS,
   __name,
+  __require,
+  __toCommonJS,
   __toESM
 } from "./chunk-NFU5RQB4.js";
 
+// ../../node_modules/.store/@azure-data-tables-npm-13.3.0-eaf9124dcc/package/dist/index.js
+var require_dist2 = __commonJS({
+  "../../node_modules/.store/@azure-data-tables-npm-13.3.0-eaf9124dcc/package/dist/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var tslib = (init_tslib_es6(), __toCommonJS(tslib_es6_exports));
+    var coreAuth = require_commonjs5();
+    var coreXml = require_commonjs7();
+    var coreClient = require_commonjs6();
+    var logger$1 = require_commonjs();
+    var coreRestPipeline = require_commonjs4();
+    var crypto = __require("crypto");
+    var coreTracing = require_commonjs3();
+    var coreUtil = require_commonjs2();
+    function _interopNamespaceDefault(e) {
+      var n = /* @__PURE__ */ Object.create(null);
+      if (e) {
+        Object.keys(e).forEach(function(k) {
+          if (k !== "default") {
+            var d = Object.getOwnPropertyDescriptor(e, k);
+            Object.defineProperty(n, k, d.get ? d : {
+              enumerable: true,
+              get: /* @__PURE__ */ __name(function() {
+                return e[k];
+              }, "get")
+            });
+          }
+        });
+      }
+      n.default = e;
+      return Object.freeze(n);
+    }
+    __name(_interopNamespaceDefault, "_interopNamespaceDefault");
+    var coreClient__namespace = /* @__PURE__ */ _interopNamespaceDefault(coreClient);
+    var KnownOdataMetadataFormat;
+    (function(KnownOdataMetadataFormat2) {
+      KnownOdataMetadataFormat2["ApplicationJsonOdataNometadata"] = "application/json;odata=nometadata";
+      KnownOdataMetadataFormat2["ApplicationJsonOdataMinimalmetadata"] = "application/json;odata=minimalmetadata";
+      KnownOdataMetadataFormat2["ApplicationJsonOdataFullmetadata"] = "application/json;odata=fullmetadata";
+    })(KnownOdataMetadataFormat || (KnownOdataMetadataFormat = {}));
+    var KnownResponseFormat;
+    (function(KnownResponseFormat2) {
+      KnownResponseFormat2["ReturnNoContent"] = "return-no-content";
+      KnownResponseFormat2["ReturnContent"] = "return-content";
+    })(KnownResponseFormat || (KnownResponseFormat = {}));
+    exports.KnownGeoReplicationStatusType = void 0;
+    (function(KnownGeoReplicationStatusType) {
+      KnownGeoReplicationStatusType["Live"] = "live";
+      KnownGeoReplicationStatusType["Bootstrap"] = "bootstrap";
+      KnownGeoReplicationStatusType["Unavailable"] = "unavailable";
+    })(exports.KnownGeoReplicationStatusType || (exports.KnownGeoReplicationStatusType = {}));
+    function accountSasPermissionsFromString(permissions) {
+      const accountSasPermissions = {};
+      for (const c of permissions) {
+        switch (c) {
+          case "r":
+            accountSasPermissions.query = true;
+            break;
+          case "w":
+            accountSasPermissions.write = true;
+            break;
+          case "d":
+            accountSasPermissions.delete = true;
+            break;
+          case "l":
+            accountSasPermissions.list = true;
+            break;
+          case "a":
+            accountSasPermissions.add = true;
+            break;
+          case "u":
+            accountSasPermissions.update = true;
+            break;
+          default:
+            throw new RangeError(`Invalid permission character: ${c}`);
+        }
+      }
+      return accountSasPermissions;
+    }
+    __name(accountSasPermissionsFromString, "accountSasPermissionsFromString");
+    function accountSasPermissionsToString(permissions) {
+      const permissionString = [];
+      if (permissions.query) {
+        permissionString.push("r");
+      }
+      if (permissions.write) {
+        permissionString.push("w");
+      }
+      if (permissions.delete) {
+        permissionString.push("d");
+      }
+      if (permissions.list) {
+        permissionString.push("l");
+      }
+      if (permissions.add) {
+        permissionString.push("a");
+      }
+      if (permissions.update) {
+        permissionString.push("u");
+      }
+      return permissionString.join("");
+    }
+    __name(accountSasPermissionsToString, "accountSasPermissionsToString");
+    function accountSasServicesFromString(services) {
+      const accountSasServices = {};
+      for (const c of services) {
+        switch (c) {
+          case "b":
+            accountSasServices.blob = true;
+            break;
+          case "f":
+            accountSasServices.file = true;
+            break;
+          case "q":
+            accountSasServices.queue = true;
+            break;
+          case "t":
+            accountSasServices.table = true;
+            break;
+          default:
+            throw new RangeError(`Invalid service character: ${c}`);
+        }
+      }
+      return accountSasServices;
+    }
+    __name(accountSasServicesFromString, "accountSasServicesFromString");
+    function accountSasServicesToString(services = { table: true }) {
+      const servicesString = [];
+      if (services.blob) {
+        servicesString.push("b");
+      }
+      if (services.table) {
+        servicesString.push("t");
+      }
+      if (services.queue) {
+        servicesString.push("q");
+      }
+      if (services.file) {
+        servicesString.push("f");
+      }
+      return servicesString.join("");
+    }
+    __name(accountSasServicesToString, "accountSasServicesToString");
+    function ipRangeToString(ipRange) {
+      if (!ipRange) {
+        return "";
+      }
+      return ipRange.end ? `${ipRange.start}-${ipRange.end}` : ipRange.start;
+    }
+    __name(ipRangeToString, "ipRangeToString");
+    function truncatedISO8061Date(date, withMilliseconds = true) {
+      const dateString = date.toISOString();
+      return withMilliseconds ? dateString.substring(0, dateString.length - 1) + "0000Z" : dateString.substring(0, dateString.length - 5) + "Z";
+    }
+    __name(truncatedISO8061Date, "truncatedISO8061Date");
+    var _SasQueryParameters = class _SasQueryParameters {
+      /**
+       * Optional. IP range allowed for this SAS.
+       *
+       * @readonly
+       */
+      get ipRange() {
+        if (this.ipRangeInner) {
+          return {
+            end: this.ipRangeInner.end,
+            start: this.ipRangeInner.start
+          };
+        }
+        return void 0;
+      }
+      /**
+       * Creates an instance of SASQueryParameters.
+       *
+       * @param version - Representing the table service version
+       * @param signature - Representing the signature for the SAS token
+       * @param options - Optional. Options to construct the SASQueryParameters.
+       */
+      constructor(version2, signature, options = {}) {
+        this.version = version2;
+        this.signature = signature;
+        this.permissions = options.permissions;
+        this.services = options.services;
+        this.resourceTypes = options.resourceTypes;
+        this.protocol = options.protocol;
+        this.startsOn = options.startsOn;
+        this.expiresOn = options.expiresOn;
+        this.ipRangeInner = options.ipRange;
+        this.identifier = options.identifier;
+        this.tableName = options.tableName;
+        this.endPartitionKey = options.endPartitionKey;
+        this.endRowKey = options.endRowKey;
+        this.startPartitionKey = options.startPartitionKey;
+        this.startRowKey = options.startRowKey;
+        if (options.userDelegationKey) {
+          this.signedOid = options.userDelegationKey.signedObjectId;
+          this.signedTenantId = options.userDelegationKey.signedTenantId;
+          this.signedStartsOn = options.userDelegationKey.signedStartsOn;
+          this.signedExpiresOn = options.userDelegationKey.signedExpiresOn;
+          this.signedService = options.userDelegationKey.signedService;
+          this.signedVersion = options.userDelegationKey.signedVersion;
+          this.preauthorizedAgentObjectId = options.preauthorizedAgentObjectId;
+          this.correlationId = options.correlationId;
+        }
+      }
+      /**
+       * Encodes all SAS query parameters into a string that can be appended to a URL.
+       *
+       */
+      toString() {
+        const params = [
+          "sv",
+          // SignedVersion
+          "ss",
+          // SignedServices
+          "srt",
+          // SignedResourceTypes
+          "spr",
+          // SignedProtocol
+          "st",
+          // SignedStart
+          "se",
+          // SignedExpiry
+          "sip",
+          // SignedIP
+          "si",
+          // SignedIdentifier
+          "skoid",
+          // Signed object ID
+          "sktid",
+          // Signed tenant ID
+          "skt",
+          // Signed key start time
+          "ske",
+          // Signed key expiry time
+          "sks",
+          // Signed key service
+          "skv",
+          // Signed key version
+          "sr",
+          // signedResource
+          "sp",
+          // SignedPermission
+          "sig",
+          // Signature
+          "rscc",
+          // Cache-Control
+          "rscd",
+          // Content-Disposition
+          "rsce",
+          // Content-Encoding
+          "rscl",
+          // Content-Language
+          "rsct",
+          // Content-Type
+          "saoid",
+          // signedAuthorizedObjectId
+          "scid",
+          // signedCorrelationId
+          "tn",
+          // TableName,
+          "srk",
+          // StartRowKey
+          "spk",
+          // StartPartitionKey
+          "epk",
+          // EndPartitionKey
+          "erk"
+          // EndRowKey
+        ];
+        const queries = [];
+        for (const param of params) {
+          switch (param) {
+            case "sv":
+              this.tryAppendQueryParameter(queries, param, this.version);
+              break;
+            case "ss":
+              this.tryAppendQueryParameter(queries, param, this.services);
+              break;
+            case "srt":
+              this.tryAppendQueryParameter(queries, param, this.resourceTypes);
+              break;
+            case "spr":
+              this.tryAppendQueryParameter(queries, param, this.protocol);
+              break;
+            case "st":
+              this.tryAppendQueryParameter(queries, param, this.startsOn ? truncatedISO8061Date(this.startsOn, false) : void 0);
+              break;
+            case "se":
+              this.tryAppendQueryParameter(queries, param, this.expiresOn ? truncatedISO8061Date(this.expiresOn, false) : void 0);
+              break;
+            case "sip":
+              this.tryAppendQueryParameter(queries, param, this.ipRange ? ipRangeToString(this.ipRange) : void 0);
+              break;
+            case "si":
+              this.tryAppendQueryParameter(queries, param, this.identifier);
+              break;
+            case "skoid":
+              this.tryAppendQueryParameter(queries, param, this.signedOid);
+              break;
+            case "sktid":
+              this.tryAppendQueryParameter(queries, param, this.signedTenantId);
+              break;
+            case "skt":
+              this.tryAppendQueryParameter(queries, param, this.signedStartsOn ? truncatedISO8061Date(this.signedStartsOn, false) : void 0);
+              break;
+            case "ske":
+              this.tryAppendQueryParameter(queries, param, this.signedExpiresOn ? truncatedISO8061Date(this.signedExpiresOn, false) : void 0);
+              break;
+            case "sks":
+              this.tryAppendQueryParameter(queries, param, this.signedService);
+              break;
+            case "skv":
+              this.tryAppendQueryParameter(queries, param, this.signedVersion);
+              break;
+            case "sp":
+              this.tryAppendQueryParameter(queries, param, this.permissions);
+              break;
+            case "sig":
+              this.tryAppendQueryParameter(queries, param, this.signature);
+              break;
+            case "saoid":
+              this.tryAppendQueryParameter(queries, param, this.preauthorizedAgentObjectId);
+              break;
+            case "scid":
+              this.tryAppendQueryParameter(queries, param, this.correlationId);
+              break;
+            case "tn":
+              this.tryAppendQueryParameter(queries, param, this.tableName);
+              break;
+            case "spk":
+              this.tryAppendQueryParameter(queries, param, this.startPartitionKey);
+              break;
+            case "srk":
+              this.tryAppendQueryParameter(queries, param, this.startRowKey);
+              break;
+            case "epk":
+              this.tryAppendQueryParameter(queries, param, this.endPartitionKey);
+              break;
+            case "erk":
+              this.tryAppendQueryParameter(queries, param, this.endRowKey);
+              break;
+          }
+        }
+        return queries.join("&");
+      }
+      /**
+       * A private helper method used to filter and append query key/value pairs into an array.
+       *
+       * @param queries -
+       * @param key -
+       * @param value -
+       */
+      tryAppendQueryParameter(queries, key, value) {
+        if (!value) {
+          return;
+        }
+        key = encodeURIComponent(key);
+        value = encodeURIComponent(value);
+        if (key.length > 0 && value.length > 0) {
+          queries.push(`${key}=${value}`);
+        }
+      }
+    };
+    __name(_SasQueryParameters, "SasQueryParameters");
+    var SasQueryParameters = _SasQueryParameters;
+    function accountSasResourceTypesFromString(resourceTypes) {
+      const accountSasResourceTypes = {};
+      for (const c of resourceTypes) {
+        switch (c) {
+          case "s":
+            accountSasResourceTypes.service = true;
+            break;
+          case "c":
+            accountSasResourceTypes.container = true;
+            break;
+          case "o":
+            accountSasResourceTypes.object = true;
+            break;
+          default:
+            throw new RangeError(`Invalid resource type: ${c}`);
+        }
+      }
+      return accountSasResourceTypes;
+    }
+    __name(accountSasResourceTypesFromString, "accountSasResourceTypesFromString");
+    function accountSasResourceTypesToString(resourceTypes) {
+      const resourceTypesString = [];
+      if (resourceTypes.service) {
+        resourceTypesString.push("s");
+      }
+      if (resourceTypes.container) {
+        resourceTypesString.push("c");
+      }
+      if (resourceTypes.object) {
+        resourceTypesString.push("o");
+      }
+      return resourceTypesString.join("");
+    }
+    __name(accountSasResourceTypesToString, "accountSasResourceTypesToString");
+    var SERVICE_VERSION = "2019-02-02";
+    var TRANSACTION_HTTP_VERSION_1_1 = "HTTP/1.1";
+    var TRANSACTION_HTTP_LINE_ENDING = "\r\n";
+    var STORAGE_SCOPE = "https://storage.azure.com/.default";
+    var COSMOS_SCOPE = "https://cosmos.azure.com/.default";
+    var HeaderConstants = {
+      AUTHORIZATION: "authorization",
+      CONTENT_LENGTH: "content-length",
+      CONTENT_MD5: "content-md5",
+      CONTENT_TYPE: "content-type",
+      CONTENT_TRANSFER_ENCODING: "content-transfer-encoding",
+      DATE: "date",
+      X_MS_DATE: "x-ms-date",
+      X_MS_VERSION: "x-ms-version"
+    };
+    var TablesLoggingAllowedHeaderNames = [
+      "Access-Control-Allow-Origin",
+      "Cache-Control",
+      "Content-Length",
+      "Content-Type",
+      "Date",
+      "Prefer",
+      "Preference-Applied",
+      "Request-Id",
+      "traceparent",
+      "Transfer-Encoding",
+      "User-Agent",
+      "x-ms-client-request-id",
+      "x-ms-user-agent",
+      "x-ms-date",
+      "x-ms-error-code",
+      "x-ms-request-id",
+      "x-ms-return-client-request-id",
+      "x-ms-version",
+      "Accept-Ranges",
+      "Accept",
+      "Content-Disposition",
+      "Content-Encoding",
+      "Content-Language",
+      "Content-MD5",
+      "Content-Range",
+      "ETag",
+      "Last-Modified",
+      "Server",
+      "Vary",
+      "x-ms-content-crc64",
+      "x-ms-copy-action",
+      "x-ms-copy-completion-time",
+      "x-ms-copy-id",
+      "x-ms-copy-progress",
+      "x-ms-copy-status",
+      "x-ms-continuation-NextTableName",
+      "x-ms-continuation-NextPartitionKey",
+      "x-ms-continuation-NextRowKey",
+      "x-ms-has-immutability-policy",
+      "x-ms-has-legal-hold",
+      "x-ms-lease-state",
+      "x-ms-lease-status",
+      "x-ms-range",
+      "x-ms-request-server-encrypted",
+      "x-ms-server-encrypted",
+      "x-ms-snapshot",
+      "x-ms-source-range",
+      "If-Match",
+      "If-Modified-Since",
+      "If-None-Match",
+      "If-Unmodified-Since",
+      "x-ms-access-tier",
+      "x-ms-access-tier-change-time",
+      "x-ms-access-tier-inferred",
+      "x-ms-account-kind",
+      "x-ms-archive-status",
+      "x-ms-copy-destination-snapshot",
+      "x-ms-creation-time",
+      "x-ms-default-encryption-scope",
+      "x-ms-delete-type-permanent",
+      "x-ms-deny-encryption-scope-override",
+      "x-ms-encryption-algorithm",
+      "x-ms-incremental-copy",
+      "x-ms-lease-action",
+      "x-ms-lease-break-period",
+      "x-ms-lease-duration",
+      "x-ms-lease-id",
+      "x-ms-lease-time",
+      "x-ms-page-write",
+      "x-ms-proposed-lease-id",
+      "x-ms-range-get-content-md5",
+      "x-ms-rehydrate-priority",
+      "x-ms-sequence-number-action",
+      "x-ms-sku-name",
+      "x-ms-source-content-md5",
+      "x-ms-source-if-match",
+      "x-ms-source-if-modified-since",
+      "x-ms-source-if-none-match",
+      "x-ms-source-if-unmodified-since",
+      "x-ms-tag-count",
+      "x-ms-encryption-key-sha256"
+    ];
+    function computeHMACSHA256(stringToSign, accountKey) {
+      const key = Buffer.from(accountKey, "base64");
+      return crypto.createHmac("sha256", key).update(stringToSign, "utf8").digest("base64");
+    }
+    __name(computeHMACSHA256, "computeHMACSHA256");
+    function generateAccountSasQueryParameters(accountSasSignatureValues, credential) {
+      const version2 = accountSasSignatureValues.version ? accountSasSignatureValues.version : SERVICE_VERSION;
+      const parsedPermissions = accountSasPermissionsToString(accountSasSignatureValues.permissions);
+      const parsedServices = accountSasServicesToString(accountSasServicesFromString(accountSasSignatureValues.services));
+      const parsedResourceTypes = accountSasResourceTypesToString(accountSasResourceTypesFromString(accountSasSignatureValues.resourceTypes));
+      const stringToSign = [
+        credential.name,
+        parsedPermissions,
+        parsedServices,
+        parsedResourceTypes,
+        accountSasSignatureValues.startsOn ? truncatedISO8061Date(accountSasSignatureValues.startsOn, false) : "",
+        truncatedISO8061Date(accountSasSignatureValues.expiresOn, false),
+        accountSasSignatureValues.ipRange ? ipRangeToString(accountSasSignatureValues.ipRange) : "",
+        accountSasSignatureValues.protocol ? accountSasSignatureValues.protocol : "",
+        version2,
+        ""
+        // Account SAS requires an additional newline character
+      ].join("\n");
+      const signature = computeHMACSHA256(stringToSign, credential.key);
+      return new SasQueryParameters(version2, signature, {
+        permissions: parsedPermissions.toString(),
+        services: parsedServices,
+        resourceTypes: parsedResourceTypes,
+        protocol: accountSasSignatureValues.protocol,
+        startsOn: accountSasSignatureValues.startsOn,
+        expiresOn: accountSasSignatureValues.expiresOn,
+        ipRange: accountSasSignatureValues.ipRange
+      });
+    }
+    __name(generateAccountSasQueryParameters, "generateAccountSasQueryParameters");
+    function generateAccountSas(credential, options = {}) {
+      const { expiresOn, permissions = accountSasPermissionsFromString("rl"), resourceTypes = "sco", services = accountSasServicesFromString("t") } = options, rest = tslib.__rest(options, ["expiresOn", "permissions", "resourceTypes", "services"]);
+      if (!coreAuth.isNamedKeyCredential(credential)) {
+        throw RangeError("Can only generate the account SAS when the client is initialized with a shared key credential");
+      }
+      let expiry = expiresOn;
+      if (expiry === void 0) {
+        const now = /* @__PURE__ */ new Date();
+        expiry = new Date(now.getTime() + 3600 * 1e3);
+      }
+      const sas = generateAccountSasQueryParameters(Object.assign({ permissions, expiresOn: expiry, resourceTypes, services: accountSasServicesToString(services) }, rest), credential).toString();
+      return sas;
+    }
+    __name(generateAccountSas, "generateAccountSas");
+    function tableSasPermissionsFromString(permissions) {
+      const tableSasPermissions = {};
+      for (const char of permissions) {
+        switch (char) {
+          case "r":
+            tableSasPermissions.query = true;
+            break;
+          case "a":
+            tableSasPermissions.add = true;
+            break;
+          case "u":
+            tableSasPermissions.update = true;
+            break;
+          case "d":
+            tableSasPermissions.delete = true;
+            break;
+          default:
+            throw new RangeError(`Invalid permission: ${char}`);
+        }
+      }
+      return tableSasPermissions;
+    }
+    __name(tableSasPermissionsFromString, "tableSasPermissionsFromString");
+    function tableSasPermissionsToString(permissions) {
+      if (!permissions) {
+        return "";
+      }
+      const permissionsString = [];
+      if (permissions.query) {
+        permissionsString.push("r");
+      }
+      if (permissions.add) {
+        permissionsString.push("a");
+      }
+      if (permissions.update) {
+        permissionsString.push("u");
+      }
+      if (permissions.delete) {
+        permissionsString.push("d");
+      }
+      return permissionsString.join("");
+    }
+    __name(tableSasPermissionsToString, "tableSasPermissionsToString");
+    function generateTableSasQueryParameters(tableName, credential, tableSasSignatureValues) {
+      var _a, _b, _c, _d, _e, _f;
+      const version2 = (_a = tableSasSignatureValues.version) !== null && _a !== void 0 ? _a : SERVICE_VERSION;
+      if (credential === void 0) {
+        throw TypeError("Invalid NamedKeyCredential");
+      }
+      if (!tableName) {
+        throw new Error("Must provide a 'tableName'");
+      }
+      const signedPermissions = tableSasPermissionsToString(tableSasSignatureValues.permissions);
+      const signedStart = tableSasSignatureValues.startsOn ? truncatedISO8061Date(
+        tableSasSignatureValues.startsOn,
+        false
+        /** withMilliseconds */
+      ) : "";
+      const signedExpiry = tableSasSignatureValues.expiresOn ? truncatedISO8061Date(
+        tableSasSignatureValues.expiresOn,
+        false
+        /** withMilliseconds */
+      ) : "";
+      const canonicalizedResource = getCanonicalName(credential.name, tableName);
+      const signedIdentifier = (_b = tableSasSignatureValues.identifier) !== null && _b !== void 0 ? _b : "";
+      const signedIP = ipRangeToString(tableSasSignatureValues.ipRange);
+      const signedProtocol = tableSasSignatureValues.protocol || "";
+      const startingPartitionKey = (_c = tableSasSignatureValues.startPartitionKey) !== null && _c !== void 0 ? _c : "";
+      const startingRowKey = (_d = tableSasSignatureValues.startRowKey) !== null && _d !== void 0 ? _d : "";
+      const endingPartitionKey = (_e = tableSasSignatureValues.endPartitionKey) !== null && _e !== void 0 ? _e : "";
+      const endingRowKey = (_f = tableSasSignatureValues.endRowKey) !== null && _f !== void 0 ? _f : "";
+      const stringToSign = [
+        signedPermissions,
+        signedStart,
+        signedExpiry,
+        canonicalizedResource,
+        signedIdentifier,
+        signedIP,
+        signedProtocol,
+        version2,
+        startingPartitionKey,
+        startingRowKey,
+        endingPartitionKey,
+        endingRowKey
+      ].join("\n");
+      const signature = computeHMACSHA256(stringToSign, credential.key);
+      return new SasQueryParameters(version2, signature, {
+        permissions: signedPermissions,
+        protocol: tableSasSignatureValues.protocol,
+        startsOn: tableSasSignatureValues.startsOn,
+        expiresOn: tableSasSignatureValues.expiresOn,
+        ipRange: tableSasSignatureValues.ipRange,
+        identifier: tableSasSignatureValues.identifier,
+        tableName,
+        startPartitionKey: tableSasSignatureValues.startPartitionKey,
+        startRowKey: tableSasSignatureValues.startRowKey,
+        endPartitionKey: tableSasSignatureValues.endPartitionKey,
+        endRowKey: tableSasSignatureValues.endRowKey
+      });
+    }
+    __name(generateTableSasQueryParameters, "generateTableSasQueryParameters");
+    function getCanonicalName(accountName, tableName) {
+      return `/table/${accountName}/${tableName.toLowerCase()}`;
+    }
+    __name(getCanonicalName, "getCanonicalName");
+    function generateTableSas(tableName, credential, options = {}) {
+      let { expiresOn, permissions } = options;
+      if (!coreAuth.isNamedKeyCredential(credential)) {
+        throw RangeError("Can only generate the account SAS when the client is initialized with a shared key credential");
+      }
+      if (!options.identifier) {
+        if (!permissions) {
+          permissions = tableSasPermissionsFromString("r");
+        }
+        if (expiresOn === void 0) {
+          const now = /* @__PURE__ */ new Date();
+          expiresOn = new Date(now.getTime() + 3600 * 1e3);
+        }
+      }
+      const sas = generateTableSasQueryParameters(tableName, credential, Object.assign(Object.assign({}, options), {
+        expiresOn,
+        permissions
+      })).toString();
+      return sas;
+    }
+    __name(generateTableSas, "generateTableSas");
+    var tablesSecondaryEndpointPolicyName = "tablesSecondaryEndpointPolicy";
+    var SecondaryLocationHeaderName = "tables-secondary-endpoint";
+    var SecondaryLocationAccountSuffix = "-secondary";
+    var tablesSecondaryEndpointPolicy = {
+      name: tablesSecondaryEndpointPolicyName,
+      sendRequest: /* @__PURE__ */ __name(async (req, next) => {
+        if (req.headers.get(SecondaryLocationHeaderName)) {
+          req.headers.delete(SecondaryLocationHeaderName);
+          req.url = getSecondaryUrlFromPrimary(req.url);
+        }
+        return next(req);
+      }, "sendRequest")
+    };
+    function injectSecondaryEndpointHeader(options) {
+      var _a;
+      const headerToInject = { [SecondaryLocationHeaderName]: "true" };
+      return Object.assign(Object.assign({}, options), { requestOptions: Object.assign(Object.assign({}, options.requestOptions), { customHeaders: Object.assign(Object.assign({}, (_a = options.requestOptions) === null || _a === void 0 ? void 0 : _a.customHeaders), headerToInject) }) });
+    }
+    __name(injectSecondaryEndpointHeader, "injectSecondaryEndpointHeader");
+    function getSecondaryUrlFromPrimary(primaryUrl) {
+      const parsedPrimaryUrl = new URL(primaryUrl);
+      const host = parsedPrimaryUrl.hostname.split(".");
+      if (host.length > 1) {
+        host[0] = `${host[0]}${SecondaryLocationAccountSuffix}`;
+      }
+      parsedPrimaryUrl.hostname = host.join(".");
+      return parsedPrimaryUrl.toString();
+    }
+    __name(getSecondaryUrlFromPrimary, "getSecondaryUrlFromPrimary");
+    var TableQueryResponse = {
+      serializedName: "TableQueryResponse",
+      type: {
+        name: "Composite",
+        className: "TableQueryResponse",
+        modelProperties: {
+          odataMetadata: {
+            serializedName: "odata\\.metadata",
+            xmlName: "odata\\.metadata",
+            type: {
+              name: "String"
+            }
+          },
+          value: {
+            serializedName: "value",
+            xmlName: "value",
+            xmlElementName: "TableResponseProperties",
+            type: {
+              name: "Sequence",
+              element: {
+                type: {
+                  name: "Composite",
+                  className: "TableResponseProperties"
+                }
+              }
+            }
+          }
+        }
+      }
+    };
+    var TableResponseProperties = {
+      serializedName: "TableResponseProperties",
+      type: {
+        name: "Composite",
+        className: "TableResponseProperties",
+        modelProperties: {
+          name: {
+            serializedName: "TableName",
+            xmlName: "TableName",
+            type: {
+              name: "String"
+            }
+          },
+          odataType: {
+            serializedName: "odata\\.type",
+            xmlName: "odata\\.type",
+            type: {
+              name: "String"
+            }
+          },
+          odataId: {
+            serializedName: "odata\\.id",
+            xmlName: "odata\\.id",
+            type: {
+              name: "String"
+            }
+          },
+          odataEditLink: {
+            serializedName: "odata\\.editLink",
+            xmlName: "odata\\.editLink",
+            type: {
+              name: "String"
+            }
+          }
+        }
+      }
+    };
+    var TableServiceError = {
+      serializedName: "TableServiceError",
+      type: {
+        name: "Composite",
+        className: "TableServiceError",
+        modelProperties: {
+          odataError: {
+            serializedName: "odata\\.error",
+            xmlName: "odata\\.error",
+            type: {
+              name: "Composite",
+              className: "TableServiceErrorOdataError"
+            }
+          }
+        }
+      }
+    };
+    var TableServiceErrorOdataError = {
+      serializedName: "TableServiceErrorOdataError",
+      type: {
+        name: "Composite",
+        className: "TableServiceErrorOdataError",
+        modelProperties: {
+          code: {
+            serializedName: "code",
+            xmlName: "code",
+            type: {
+              name: "String"
+            }
+          },
+          message: {
+            serializedName: "message",
+            xmlName: "message",
+            type: {
+              name: "Composite",
+              className: "TableServiceErrorOdataErrorMessage"
+            }
+          }
+        }
+      }
+    };
+    var TableServiceErrorOdataErrorMessage = {
+      serializedName: "TableServiceErrorOdataErrorMessage",
+      type: {
+        name: "Composite",
+        className: "TableServiceErrorOdataErrorMessage",
+        modelProperties: {
+          lang: {
+            serializedName: "lang",
+            xmlName: "lang",
+            type: {
+              name: "String"
+            }
+          },
+          value: {
+            serializedName: "value",
+            xmlName: "value",
+            type: {
+              name: "String"
+            }
+          }
+        }
+      }
+    };
+    var TableProperties = {
+      serializedName: "TableProperties",
+      type: {
+        name: "Composite",
+        className: "TableProperties",
+        modelProperties: {
+          name: {
+            serializedName: "TableName",
+            xmlName: "TableName",
+            type: {
+              name: "String"
+            }
+          }
+        }
+      }
+    };
+    var TableEntityQueryResponse = {
+      serializedName: "TableEntityQueryResponse",
+      type: {
+        name: "Composite",
+        className: "TableEntityQueryResponse",
+        modelProperties: {
+          odataMetadata: {
+            serializedName: "odata\\.metadata",
+            xmlName: "odata\\.metadata",
+            type: {
+              name: "String"
+            }
+          },
+          value: {
+            serializedName: "value",
+            xmlName: "value",
+            xmlElementName: "TableEntityProperties",
+            type: {
+              name: "Sequence",
+              element: {
+                type: {
+                  name: "Dictionary",
+                  value: { type: { name: "any" } }
+                }
+              }
+            }
+          }
+        }
+      }
+    };
+    var SignedIdentifier = {
+      serializedName: "SignedIdentifier",
+      xmlName: "SignedIdentifier",
+      type: {
+        name: "Composite",
+        className: "SignedIdentifier",
+        modelProperties: {
+          id: {
+            serializedName: "Id",
+            required: true,
+            xmlName: "Id",
+            type: {
+              name: "String"
+            }
+          },
+          accessPolicy: {
+            serializedName: "AccessPolicy",
+            xmlName: "AccessPolicy",
+            type: {
+              name: "Composite",
+              className: "AccessPolicy"
+            }
+          }
+        }
+      }
+    };
+    var AccessPolicy = {
+      serializedName: "AccessPolicy",
+      xmlName: "AccessPolicy",
+      type: {
+        name: "Composite",
+        className: "AccessPolicy",
+        modelProperties: {
+          start: {
+            serializedName: "Start",
+            xmlName: "Start",
+            type: {
+              name: "String"
+            }
+          },
+          expiry: {
+            serializedName: "Expiry",
+            xmlName: "Expiry",
+            type: {
+              name: "String"
+            }
+          },
+          permission: {
+            serializedName: "Permission",
+            xmlName: "Permission",
+            type: {
+              name: "String"
+            }
+          }
+        }
+      }
+    };
+    var TableServiceProperties = {
+      serializedName: "TableServiceProperties",
+      xmlName: "StorageServiceProperties",
+      type: {
+        name: "Composite",
+        className: "TableServiceProperties",
+        modelProperties: {
+          logging: {
+            serializedName: "Logging",
+            xmlName: "Logging",
+            type: {
+              name: "Composite",
+              className: "Logging"
+            }
+          },
+          hourMetrics: {
+            serializedName: "HourMetrics",
+            xmlName: "HourMetrics",
+            type: {
+              name: "Composite",
+              className: "Metrics"
+            }
+          },
+          minuteMetrics: {
+            serializedName: "MinuteMetrics",
+            xmlName: "MinuteMetrics",
+            type: {
+              name: "Composite",
+              className: "Metrics"
+            }
+          },
+          cors: {
+            serializedName: "Cors",
+            xmlName: "Cors",
+            xmlIsWrapped: true,
+            xmlElementName: "CorsRule",
+            type: {
+              name: "Sequence",
+              element: {
+                type: {
+                  name: "Composite",
+                  className: "CorsRule"
+                }
+              }
+            }
+          }
+        }
+      }
+    };
+    var Logging = {
+      serializedName: "Logging",
+      xmlName: "Logging",
+      type: {
+        name: "Composite",
+        className: "Logging",
+        modelProperties: {
+          version: {
+            serializedName: "Version",
+            required: true,
+            xmlName: "Version",
+            type: {
+              name: "String"
+            }
+          },
+          delete: {
+            serializedName: "Delete",
+            required: true,
+            xmlName: "Delete",
+            type: {
+              name: "Boolean"
+            }
+          },
+          read: {
+            serializedName: "Read",
+            required: true,
+            xmlName: "Read",
+            type: {
+              name: "Boolean"
+            }
+          },
+          write: {
+            serializedName: "Write",
+            required: true,
+            xmlName: "Write",
+            type: {
+              name: "Boolean"
+            }
+          },
+          retentionPolicy: {
+            serializedName: "RetentionPolicy",
+            xmlName: "RetentionPolicy",
+            type: {
+              name: "Composite",
+              className: "RetentionPolicy"
+            }
+          }
+        }
+      }
+    };
+    var RetentionPolicy = {
+      serializedName: "RetentionPolicy",
+      xmlName: "RetentionPolicy",
+      type: {
+        name: "Composite",
+        className: "RetentionPolicy",
+        modelProperties: {
+          enabled: {
+            serializedName: "Enabled",
+            required: true,
+            xmlName: "Enabled",
+            type: {
+              name: "Boolean"
+            }
+          },
+          days: {
+            constraints: {
+              InclusiveMinimum: 1
+            },
+            serializedName: "Days",
+            xmlName: "Days",
+            type: {
+              name: "Number"
+            }
+          }
+        }
+      }
+    };
+    var Metrics = {
+      serializedName: "Metrics",
+      type: {
+        name: "Composite",
+        className: "Metrics",
+        modelProperties: {
+          version: {
+            serializedName: "Version",
+            xmlName: "Version",
+            type: {
+              name: "String"
+            }
+          },
+          enabled: {
+            serializedName: "Enabled",
+            required: true,
+            xmlName: "Enabled",
+            type: {
+              name: "Boolean"
+            }
+          },
+          includeAPIs: {
+            serializedName: "IncludeAPIs",
+            xmlName: "IncludeAPIs",
+            type: {
+              name: "Boolean"
+            }
+          },
+          retentionPolicy: {
+            serializedName: "RetentionPolicy",
+            xmlName: "RetentionPolicy",
+            type: {
+              name: "Composite",
+              className: "RetentionPolicy"
+            }
+          }
+        }
+      }
+    };
+    var CorsRule = {
+      serializedName: "CorsRule",
+      xmlName: "CorsRule",
+      type: {
+        name: "Composite",
+        className: "CorsRule",
+        modelProperties: {
+          allowedOrigins: {
+            serializedName: "AllowedOrigins",
+            required: true,
+            xmlName: "AllowedOrigins",
+            type: {
+              name: "String"
+            }
+          },
+          allowedMethods: {
+            serializedName: "AllowedMethods",
+            required: true,
+            xmlName: "AllowedMethods",
+            type: {
+              name: "String"
+            }
+          },
+          allowedHeaders: {
+            serializedName: "AllowedHeaders",
+            required: true,
+            xmlName: "AllowedHeaders",
+            type: {
+              name: "String"
+            }
+          },
+          exposedHeaders: {
+            serializedName: "ExposedHeaders",
+            required: true,
+            xmlName: "ExposedHeaders",
+            type: {
+              name: "String"
+            }
+          },
+          maxAgeInSeconds: {
+            constraints: {
+              InclusiveMinimum: 0
+            },
+            serializedName: "MaxAgeInSeconds",
+            required: true,
+            xmlName: "MaxAgeInSeconds",
+            type: {
+              name: "Number"
+            }
+          }
+        }
+      }
+    };
+    var TableServiceStats = {
+      serializedName: "TableServiceStats",
+      xmlName: "StorageServiceStats",
+      type: {
+        name: "Composite",
+        className: "TableServiceStats",
+        modelProperties: {
+          geoReplication: {
+            serializedName: "GeoReplication",
+            xmlName: "GeoReplication",
+            type: {
+              name: "Composite",
+              className: "GeoReplication"
+            }
+          }
+        }
+      }
+    };
+    var GeoReplication = {
+      serializedName: "GeoReplication",
+      xmlName: "GeoReplication",
+      type: {
+        name: "Composite",
+        className: "GeoReplication",
+        modelProperties: {
+          status: {
+            serializedName: "Status",
+            required: true,
+            xmlName: "Status",
+            type: {
+              name: "String"
+            }
+          },
+          lastSyncTime: {
+            serializedName: "LastSyncTime",
+            required: true,
+            xmlName: "LastSyncTime",
+            type: {
+              name: "DateTimeRfc1123"
+            }
+          }
+        }
+      }
+    };
+    var TableResponse = {
+      serializedName: "TableResponse",
+      type: {
+        name: "Composite",
+        className: "TableResponse",
+        modelProperties: Object.assign(Object.assign({}, TableResponseProperties.type.modelProperties), { odataMetadata: {
+          serializedName: "odata\\.metadata",
+          xmlName: "odata\\.metadata",
+          type: {
+            name: "String"
+          }
+        } })
+      }
+    };
+    var TableQueryHeaders = {
+      serializedName: "Table_queryHeaders",
+      type: {
+        name: "Composite",
+        className: "TableQueryHeaders",
+        modelProperties: {
+          clientRequestId: {
+            serializedName: "x-ms-client-request-id",
+            xmlName: "x-ms-client-request-id",
+            type: {
+              name: "String"
+            }
+          },
+          requestId: {
+            serializedName: "x-ms-request-id",
+            xmlName: "x-ms-request-id",
+            type: {
+              name: "String"
+            }
+          },
+          version: {
+            serializedName: "x-ms-version",
+            xmlName: "x-ms-version",
+            type: {
+              name: "String"
+            }
+          },
+          date: {
+            serializedName: "date",
+            xmlName: "date",
+            type: {
+              name: "DateTimeRfc1123"
+            }
+          },
+          xMsContinuationNextTableName: {
+            serializedName: "x-ms-continuation-nexttablename",
+            xmlName: "x-ms-continuation-nexttablename",
+            type: {
+              name: "String"
+            }
+          }
+        }
+      }
+    };
+    var TableQueryExceptionHeaders = {
+      serializedName: "Table_queryExceptionHeaders",
+      type: {
+        name: "Composite",
+        className: "TableQueryExceptionHeaders",
+        modelProperties: {
+          errorCode: {
+            serializedName: "x-ms-error-code",
+            xmlName: "x-ms-error-code",
+            type: {
+              name: "String"
+            }
+          }
+        }
+      }
+    };
+    var TableCreateHeaders = {
+      serializedName: "Table_createHeaders",
+      type: {
+        name: "Composite",
+        className: "TableCreateHeaders",
+        modelProperties: {
+          clientRequestId: {
+            serializedName: "x-ms-client-request-id",
+            xmlName: "x-ms-client-request-id",
+            type: {
+              name: "String"
+            }
+          },
+          requestId: {
+            serializedName: "x-ms-request-id",
+            xmlName: "x-ms-request-id",
+            type: {
+              name: "String"
+            }
+          },
+          version: {
+            serializedName: "x-ms-version",
+            xmlName: "x-ms-version",
+            type: {
+              name: "String"
+            }
+          },
+          date: {
+            serializedName: "date",
+            xmlName: "date",
+            type: {
+              name: "DateTimeRfc1123"
+            }
+          },
+          preferenceApplied: {
+            serializedName: "preference-applied",
+            xmlName: "preference-applied",
+            type: {
+              name: "String"
+            }
+          }
+        }
+      }
+    };
+    var TableCreateExceptionHeaders = {
+      serializedName: "Table_createExceptionHeaders",
+      type: {
+        name: "Composite",
+        className: "TableCreateExceptionHeaders",
+        modelProperties: {
+          errorCode: {
+            serializedName: "x-ms-error-code",
+            xmlName: "x-ms-error-code",
+            type: {
+              name: "String"
+            }
+          }
+        }
+      }
+    };
+    var TableDeleteHeaders = {
+      serializedName: "Table_deleteHeaders",
+      type: {
+        name: "Composite",
+        className: "TableDeleteHeaders",
+        modelProperties: {
+          clientRequestId: {
+            serializedName: "x-ms-client-request-id",
+            xmlName: "x-ms-client-request-id",
+            type: {
+              name: "String"
+            }
+          },
+          requestId: {
+            serializedName: "x-ms-request-id",
+            xmlName: "x-ms-request-id",
+            type: {
+              name: "String"
+            }
+          },
+          version: {
+            serializedName: "x-ms-version",
+            xmlName: "x-ms-version",
+            type: {
+              name: "String"
+            }
+          },
+          date: {
+            serializedName: "date",
+            xmlName: "date",
+            type: {
+              name: "DateTimeRfc1123"
+            }
+          }
+        }
+      }
+    };
+    var TableDeleteExceptionHeaders = {
+      serializedName: "Table_deleteExceptionHeaders",
+      type: {
+        name: "Composite",
+        className: "TableDeleteExceptionHeaders",
+        modelProperties: {
+          errorCode: {
+            serializedName: "x-ms-error-code",
+            xmlName: "x-ms-error-code",
+            type: {
+              name: "String"
+            }
+          }
+        }
+      }
+    };
+    var TableQueryEntitiesHeaders = {
+      serializedName: "Table_queryEntitiesHeaders",
+      type: {
+        name: "Composite",
+        className: "TableQueryEntitiesHeaders",
+        modelProperties: {
+          clientRequestId: {
+            serializedName: "x-ms-client-request-id",
+            xmlName: "x-ms-client-request-id",
+            type: {
+              name: "String"
+            }
+          },
+          requestId: {
+            serializedName: "x-ms-request-id",
+            xmlName: "x-ms-request-id",
+            type: {
+              name: "String"
+            }
+          },
+          version: {
+            serializedName: "x-ms-version",
+            xmlName: "x-ms-version",
+            type: {
+              name: "String"
+            }
+          },
+          date: {
+            serializedName: "date",
+            xmlName: "date",
+            type: {
+              name: "DateTimeRfc1123"
+            }
+          },
+          xMsContinuationNextPartitionKey: {
+            serializedName: "x-ms-continuation-nextpartitionkey",
+            xmlName: "x-ms-continuation-nextpartitionkey",
+            type: {
+              name: "String"
+            }
+          },
+          xMsContinuationNextRowKey: {
+            serializedName: "x-ms-continuation-nextrowkey",
+            xmlName: "x-ms-continuation-nextrowkey",
+            type: {
+              name: "String"
+            }
+          }
+        }
+      }
+    };
+    var TableQueryEntitiesExceptionHeaders = {
+      serializedName: "Table_queryEntitiesExceptionHeaders",
+      type: {
+        name: "Composite",
+        className: "TableQueryEntitiesExceptionHeaders",
+        modelProperties: {
+          errorCode: {
+            serializedName: "x-ms-error-code",
+            xmlName: "x-ms-error-code",
+            type: {
+              name: "String"
+            }
+          }
+        }
+      }
+    };
+    var TableQueryEntitiesWithPartitionAndRowKeyHeaders = {
+      serializedName: "Table_queryEntitiesWithPartitionAndRowKeyHeaders",
+      type: {
+        name: "Composite",
+        className: "TableQueryEntitiesWithPartitionAndRowKeyHeaders",
+        modelProperties: {
+          clientRequestId: {
+            serializedName: "x-ms-client-request-id",
+            xmlName: "x-ms-client-request-id",
+            type: {
+              name: "String"
+            }
+          },
+          requestId: {
+            serializedName: "x-ms-request-id",
+            xmlName: "x-ms-request-id",
+            type: {
+              name: "String"
+            }
+          },
+          version: {
+            serializedName: "x-ms-version",
+            xmlName: "x-ms-version",
+            type: {
+              name: "String"
+            }
+          },
+          date: {
+            serializedName: "date",
+            xmlName: "date",
+            type: {
+              name: "DateTimeRfc1123"
+            }
+          },
+          etag: {
+            serializedName: "etag",
+            xmlName: "etag",
+            type: {
+              name: "String"
+            }
+          },
+          xMsContinuationNextPartitionKey: {
+            serializedName: "x-ms-continuation-nextpartitionkey",
+            xmlName: "x-ms-continuation-nextpartitionkey",
+            type: {
+              name: "String"
+            }
+          },
+          xMsContinuationNextRowKey: {
+            serializedName: "x-ms-continuation-nextrowkey",
+            xmlName: "x-ms-continuation-nextrowkey",
+            type: {
+              name: "String"
+            }
+          }
+        }
+      }
+    };
+    var TableQueryEntitiesWithPartitionAndRowKeyExceptionHeaders = {
+      serializedName: "Table_queryEntitiesWithPartitionAndRowKeyExceptionHeaders",
+      type: {
+        name: "Composite",
+        className: "TableQueryEntitiesWithPartitionAndRowKeyExceptionHeaders",
+        modelProperties: {
+          errorCode: {
+            serializedName: "x-ms-error-code",
+            xmlName: "x-ms-error-code",
+            type: {
+              name: "String"
+            }
+          }
+        }
+      }
+    };
+    var TableUpdateEntityHeaders = {
+      serializedName: "Table_updateEntityHeaders",
+      type: {
+        name: "Composite",
+        className: "TableUpdateEntityHeaders",
+        modelProperties: {
+          clientRequestId: {
+            serializedName: "x-ms-client-request-id",
+            xmlName: "x-ms-client-request-id",
+            type: {
+              name: "String"
+            }
+          },
+          requestId: {
+            serializedName: "x-ms-request-id",
+            xmlName: "x-ms-request-id",
+            type: {
+              name: "String"
+            }
+          },
+          version: {
+            serializedName: "x-ms-version",
+            xmlName: "x-ms-version",
+            type: {
+              name: "String"
+            }
+          },
+          date: {
+            serializedName: "date",
+            xmlName: "date",
+            type: {
+              name: "DateTimeRfc1123"
+            }
+          },
+          etag: {
+            serializedName: "etag",
+            xmlName: "etag",
+            type: {
+              name: "String"
+            }
+          }
+        }
+      }
+    };
+    var TableUpdateEntityExceptionHeaders = {
+      serializedName: "Table_updateEntityExceptionHeaders",
+      type: {
+        name: "Composite",
+        className: "TableUpdateEntityExceptionHeaders",
+        modelProperties: {
+          errorCode: {
+            serializedName: "x-ms-error-code",
+            xmlName: "x-ms-error-code",
+            type: {
+              name: "String"
+            }
+          }
+        }
+      }
+    };
+    var TableMergeEntityHeaders = {
+      serializedName: "Table_mergeEntityHeaders",
+      type: {
+        name: "Composite",
+        className: "TableMergeEntityHeaders",
+        modelProperties: {
+          clientRequestId: {
+            serializedName: "x-ms-client-request-id",
+            xmlName: "x-ms-client-request-id",
+            type: {
+              name: "String"
+            }
+          },
+          requestId: {
+            serializedName: "x-ms-request-id",
+            xmlName: "x-ms-request-id",
+            type: {
+              name: "String"
+            }
+          },
+          version: {
+            serializedName: "x-ms-version",
+            xmlName: "x-ms-version",
+            type: {
+              name: "String"
+            }
+          },
+          date: {
+            serializedName: "date",
+            xmlName: "date",
+            type: {
+              name: "DateTimeRfc1123"
+            }
+          },
+          etag: {
+            serializedName: "etag",
+            xmlName: "etag",
+            type: {
+              name: "String"
+            }
+          }
+        }
+      }
+    };
+    var TableMergeEntityExceptionHeaders = {
+      serializedName: "Table_mergeEntityExceptionHeaders",
+      type: {
+        name: "Composite",
+        className: "TableMergeEntityExceptionHeaders",
+        modelProperties: {
+          errorCode: {
+            serializedName: "x-ms-error-code",
+            xmlName: "x-ms-error-code",
+            type: {
+              name: "String"
+            }
+          }
+        }
+      }
+    };
+    var TableDeleteEntityHeaders = {
+      serializedName: "Table_deleteEntityHeaders",
+      type: {
+        name: "Composite",
+        className: "TableDeleteEntityHeaders",
+        modelProperties: {
+          clientRequestId: {
+            serializedName: "x-ms-client-request-id",
+            xmlName: "x-ms-client-request-id",
+            type: {
+              name: "String"
+            }
+          },
+          requestId: {
+            serializedName: "x-ms-request-id",
+            xmlName: "x-ms-request-id",
+            type: {
+              name: "String"
+            }
+          },
+          version: {
+            serializedName: "x-ms-version",
+            xmlName: "x-ms-version",
+            type: {
+              name: "String"
+            }
+          },
+          date: {
+            serializedName: "date",
+            xmlName: "date",
+            type: {
+              name: "DateTimeRfc1123"
+            }
+          }
+        }
+      }
+    };
+    var TableDeleteEntityExceptionHeaders = {
+      serializedName: "Table_deleteEntityExceptionHeaders",
+      type: {
+        name: "Composite",
+        className: "TableDeleteEntityExceptionHeaders",
+        modelProperties: {
+          errorCode: {
+            serializedName: "x-ms-error-code",
+            xmlName: "x-ms-error-code",
+            type: {
+              name: "String"
+            }
+          }
+        }
+      }
+    };
+    var TableInsertEntityHeaders = {
+      serializedName: "Table_insertEntityHeaders",
+      type: {
+        name: "Composite",
+        className: "TableInsertEntityHeaders",
+        modelProperties: {
+          clientRequestId: {
+            serializedName: "x-ms-client-request-id",
+            xmlName: "x-ms-client-request-id",
+            type: {
+              name: "String"
+            }
+          },
+          requestId: {
+            serializedName: "x-ms-request-id",
+            xmlName: "x-ms-request-id",
+            type: {
+              name: "String"
+            }
+          },
+          version: {
+            serializedName: "x-ms-version",
+            xmlName: "x-ms-version",
+            type: {
+              name: "String"
+            }
+          },
+          date: {
+            serializedName: "date",
+            xmlName: "date",
+            type: {
+              name: "DateTimeRfc1123"
+            }
+          },
+          etag: {
+            serializedName: "etag",
+            xmlName: "etag",
+            type: {
+              name: "String"
+            }
+          },
+          preferenceApplied: {
+            serializedName: "preference-applied",
+            xmlName: "preference-applied",
+            type: {
+              name: "String"
+            }
+          },
+          contentType: {
+            serializedName: "content-type",
+            xmlName: "content-type",
+            type: {
+              name: "String"
+            }
+          }
+        }
+      }
+    };
+    var TableInsertEntityExceptionHeaders = {
+      serializedName: "Table_insertEntityExceptionHeaders",
+      type: {
+        name: "Composite",
+        className: "TableInsertEntityExceptionHeaders",
+        modelProperties: {
+          errorCode: {
+            serializedName: "x-ms-error-code",
+            xmlName: "x-ms-error-code",
+            type: {
+              name: "String"
+            }
+          }
+        }
+      }
+    };
+    var TableGetAccessPolicyHeaders = {
+      serializedName: "Table_getAccessPolicyHeaders",
+      type: {
+        name: "Composite",
+        className: "TableGetAccessPolicyHeaders",
+        modelProperties: {
+          clientRequestId: {
+            serializedName: "x-ms-client-request-id",
+            xmlName: "x-ms-client-request-id",
+            type: {
+              name: "String"
+            }
+          },
+          requestId: {
+            serializedName: "x-ms-request-id",
+            xmlName: "x-ms-request-id",
+            type: {
+              name: "String"
+            }
+          },
+          version: {
+            serializedName: "x-ms-version",
+            xmlName: "x-ms-version",
+            type: {
+              name: "String"
+            }
+          },
+          date: {
+            serializedName: "date",
+            xmlName: "date",
+            type: {
+              name: "DateTimeRfc1123"
+            }
+          }
+        }
+      }
+    };
+    var TableGetAccessPolicyExceptionHeaders = {
+      serializedName: "Table_getAccessPolicyExceptionHeaders",
+      type: {
+        name: "Composite",
+        className: "TableGetAccessPolicyExceptionHeaders",
+        modelProperties: {
+          errorCode: {
+            serializedName: "x-ms-error-code",
+            xmlName: "x-ms-error-code",
+            type: {
+              name: "String"
+            }
+          }
+        }
+      }
+    };
+    var TableSetAccessPolicyHeaders = {
+      serializedName: "Table_setAccessPolicyHeaders",
+      type: {
+        name: "Composite",
+        className: "TableSetAccessPolicyHeaders",
+        modelProperties: {
+          clientRequestId: {
+            serializedName: "x-ms-client-request-id",
+            xmlName: "x-ms-client-request-id",
+            type: {
+              name: "String"
+            }
+          },
+          requestId: {
+            serializedName: "x-ms-request-id",
+            xmlName: "x-ms-request-id",
+            type: {
+              name: "String"
+            }
+          },
+          version: {
+            serializedName: "x-ms-version",
+            xmlName: "x-ms-version",
+            type: {
+              name: "String"
+            }
+          },
+          date: {
+            serializedName: "date",
+            xmlName: "date",
+            type: {
+              name: "DateTimeRfc1123"
+            }
+          }
+        }
+      }
+    };
+    var TableSetAccessPolicyExceptionHeaders = {
+      serializedName: "Table_setAccessPolicyExceptionHeaders",
+      type: {
+        name: "Composite",
+        className: "TableSetAccessPolicyExceptionHeaders",
+        modelProperties: {
+          errorCode: {
+            serializedName: "x-ms-error-code",
+            xmlName: "x-ms-error-code",
+            type: {
+              name: "String"
+            }
+          }
+        }
+      }
+    };
+    var ServiceSetPropertiesHeaders = {
+      serializedName: "Service_setPropertiesHeaders",
+      type: {
+        name: "Composite",
+        className: "ServiceSetPropertiesHeaders",
+        modelProperties: {
+          clientRequestId: {
+            serializedName: "x-ms-client-request-id",
+            xmlName: "x-ms-client-request-id",
+            type: {
+              name: "String"
+            }
+          },
+          requestId: {
+            serializedName: "x-ms-request-id",
+            xmlName: "x-ms-request-id",
+            type: {
+              name: "String"
+            }
+          },
+          version: {
+            serializedName: "x-ms-version",
+            xmlName: "x-ms-version",
+            type: {
+              name: "String"
+            }
+          }
+        }
+      }
+    };
+    var ServiceSetPropertiesExceptionHeaders = {
+      serializedName: "Service_setPropertiesExceptionHeaders",
+      type: {
+        name: "Composite",
+        className: "ServiceSetPropertiesExceptionHeaders",
+        modelProperties: {
+          errorCode: {
+            serializedName: "x-ms-error-code",
+            xmlName: "x-ms-error-code",
+            type: {
+              name: "String"
+            }
+          }
+        }
+      }
+    };
+    var ServiceGetPropertiesHeaders = {
+      serializedName: "Service_getPropertiesHeaders",
+      type: {
+        name: "Composite",
+        className: "ServiceGetPropertiesHeaders",
+        modelProperties: {
+          clientRequestId: {
+            serializedName: "x-ms-client-request-id",
+            xmlName: "x-ms-client-request-id",
+            type: {
+              name: "String"
+            }
+          },
+          requestId: {
+            serializedName: "x-ms-request-id",
+            xmlName: "x-ms-request-id",
+            type: {
+              name: "String"
+            }
+          },
+          version: {
+            serializedName: "x-ms-version",
+            xmlName: "x-ms-version",
+            type: {
+              name: "String"
+            }
+          }
+        }
+      }
+    };
+    var ServiceGetPropertiesExceptionHeaders = {
+      serializedName: "Service_getPropertiesExceptionHeaders",
+      type: {
+        name: "Composite",
+        className: "ServiceGetPropertiesExceptionHeaders",
+        modelProperties: {
+          errorCode: {
+            serializedName: "x-ms-error-code",
+            xmlName: "x-ms-error-code",
+            type: {
+              name: "String"
+            }
+          }
+        }
+      }
+    };
+    var ServiceGetStatisticsHeaders = {
+      serializedName: "Service_getStatisticsHeaders",
+      type: {
+        name: "Composite",
+        className: "ServiceGetStatisticsHeaders",
+        modelProperties: {
+          clientRequestId: {
+            serializedName: "x-ms-client-request-id",
+            xmlName: "x-ms-client-request-id",
+            type: {
+              name: "String"
+            }
+          },
+          requestId: {
+            serializedName: "x-ms-request-id",
+            xmlName: "x-ms-request-id",
+            type: {
+              name: "String"
+            }
+          },
+          version: {
+            serializedName: "x-ms-version",
+            xmlName: "x-ms-version",
+            type: {
+              name: "String"
+            }
+          },
+          date: {
+            serializedName: "date",
+            xmlName: "date",
+            type: {
+              name: "DateTimeRfc1123"
+            }
+          }
+        }
+      }
+    };
+    var ServiceGetStatisticsExceptionHeaders = {
+      serializedName: "Service_getStatisticsExceptionHeaders",
+      type: {
+        name: "Composite",
+        className: "ServiceGetStatisticsExceptionHeaders",
+        modelProperties: {
+          errorCode: {
+            serializedName: "x-ms-error-code",
+            xmlName: "x-ms-error-code",
+            type: {
+              name: "String"
+            }
+          }
+        }
+      }
+    };
+    var Mappers = /* @__PURE__ */ Object.freeze({
+      __proto__: null,
+      AccessPolicy,
+      CorsRule,
+      GeoReplication,
+      Logging,
+      Metrics,
+      RetentionPolicy,
+      ServiceGetPropertiesExceptionHeaders,
+      ServiceGetPropertiesHeaders,
+      ServiceGetStatisticsExceptionHeaders,
+      ServiceGetStatisticsHeaders,
+      ServiceSetPropertiesExceptionHeaders,
+      ServiceSetPropertiesHeaders,
+      SignedIdentifier,
+      TableCreateExceptionHeaders,
+      TableCreateHeaders,
+      TableDeleteEntityExceptionHeaders,
+      TableDeleteEntityHeaders,
+      TableDeleteExceptionHeaders,
+      TableDeleteHeaders,
+      TableEntityQueryResponse,
+      TableGetAccessPolicyExceptionHeaders,
+      TableGetAccessPolicyHeaders,
+      TableInsertEntityExceptionHeaders,
+      TableInsertEntityHeaders,
+      TableMergeEntityExceptionHeaders,
+      TableMergeEntityHeaders,
+      TableProperties,
+      TableQueryEntitiesExceptionHeaders,
+      TableQueryEntitiesHeaders,
+      TableQueryEntitiesWithPartitionAndRowKeyExceptionHeaders,
+      TableQueryEntitiesWithPartitionAndRowKeyHeaders,
+      TableQueryExceptionHeaders,
+      TableQueryHeaders,
+      TableQueryResponse,
+      TableResponse,
+      TableResponseProperties,
+      TableServiceError,
+      TableServiceErrorOdataError,
+      TableServiceErrorOdataErrorMessage,
+      TableServiceProperties,
+      TableServiceStats,
+      TableSetAccessPolicyExceptionHeaders,
+      TableSetAccessPolicyHeaders,
+      TableUpdateEntityExceptionHeaders,
+      TableUpdateEntityHeaders
+    });
+    var accept = {
+      parameterPath: "accept",
+      mapper: {
+        defaultValue: "application/json;odata=minimalmetadata",
+        isConstant: true,
+        serializedName: "Accept",
+        type: {
+          name: "String"
+        }
+      }
+    };
+    var url = {
+      parameterPath: "url",
+      mapper: {
+        serializedName: "url",
+        required: true,
+        xmlName: "url",
+        type: {
+          name: "String"
+        }
+      },
+      skipEncoding: true
+    };
+    var version = {
+      parameterPath: "version",
+      mapper: {
+        defaultValue: "2019-02-02",
+        isConstant: true,
+        serializedName: "x-ms-version",
+        type: {
+          name: "String"
+        }
+      }
+    };
+    var requestId = {
+      parameterPath: ["options", "requestId"],
+      mapper: {
+        serializedName: "x-ms-client-request-id",
+        xmlName: "x-ms-client-request-id",
+        type: {
+          name: "String"
+        }
+      }
+    };
+    var dataServiceVersion = {
+      parameterPath: "dataServiceVersion",
+      mapper: {
+        defaultValue: "3.0",
+        isConstant: true,
+        serializedName: "DataServiceVersion",
+        type: {
+          name: "String"
+        }
+      }
+    };
+    var format = {
+      parameterPath: ["options", "queryOptions", "format"],
+      mapper: {
+        serializedName: "$format",
+        xmlName: "$format",
+        type: {
+          name: "String"
+        }
+      }
+    };
+    var top = {
+      parameterPath: ["options", "queryOptions", "top"],
+      mapper: {
+        constraints: {
+          InclusiveMinimum: 0
+        },
+        serializedName: "$top",
+        xmlName: "$top",
+        type: {
+          name: "Number"
+        }
+      }
+    };
+    var select = {
+      parameterPath: ["options", "queryOptions", "select"],
+      mapper: {
+        serializedName: "$select",
+        xmlName: "$select",
+        type: {
+          name: "String"
+        }
+      }
+    };
+    var filter = {
+      parameterPath: ["options", "queryOptions", "filter"],
+      mapper: {
+        serializedName: "$filter",
+        xmlName: "$filter",
+        type: {
+          name: "String"
+        }
+      }
+    };
+    var nextTableName = {
+      parameterPath: ["options", "nextTableName"],
+      mapper: {
+        serializedName: "NextTableName",
+        xmlName: "NextTableName",
+        type: {
+          name: "String"
+        }
+      }
+    };
+    var contentType = {
+      parameterPath: ["options", "contentType"],
+      mapper: {
+        defaultValue: "application/json;odata=nometadata",
+        isConstant: true,
+        serializedName: "Content-Type",
+        type: {
+          name: "String"
+        }
+      }
+    };
+    var tableProperties = {
+      parameterPath: "tableProperties",
+      mapper: TableProperties
+    };
+    var responsePreference = {
+      parameterPath: ["options", "responsePreference"],
+      mapper: {
+        serializedName: "Prefer",
+        xmlName: "Prefer",
+        type: {
+          name: "String"
+        }
+      }
+    };
+    var accept1 = {
+      parameterPath: "accept",
+      mapper: {
+        defaultValue: "application/json",
+        isConstant: true,
+        serializedName: "Accept",
+        type: {
+          name: "String"
+        }
+      }
+    };
+    var table = {
+      parameterPath: "table",
+      mapper: {
+        serializedName: "table",
+        required: true,
+        xmlName: "table",
+        type: {
+          name: "String"
+        }
+      }
+    };
+    var timeout = {
+      parameterPath: ["options", "timeout"],
+      mapper: {
+        constraints: {
+          InclusiveMinimum: 0
+        },
+        serializedName: "timeout",
+        xmlName: "timeout",
+        type: {
+          name: "Number"
+        }
+      }
+    };
+    var nextPartitionKey = {
+      parameterPath: ["options", "nextPartitionKey"],
+      mapper: {
+        serializedName: "NextPartitionKey",
+        xmlName: "NextPartitionKey",
+        type: {
+          name: "String"
+        }
+      }
+    };
+    var nextRowKey = {
+      parameterPath: ["options", "nextRowKey"],
+      mapper: {
+        serializedName: "NextRowKey",
+        xmlName: "NextRowKey",
+        type: {
+          name: "String"
+        }
+      }
+    };
+    var partitionKey = {
+      parameterPath: "partitionKey",
+      mapper: {
+        serializedName: "partitionKey",
+        required: true,
+        xmlName: "partitionKey",
+        type: {
+          name: "String"
+        }
+      }
+    };
+    var rowKey = {
+      parameterPath: "rowKey",
+      mapper: {
+        serializedName: "rowKey",
+        required: true,
+        xmlName: "rowKey",
+        type: {
+          name: "String"
+        }
+      }
+    };
+    var contentType1 = {
+      parameterPath: ["options", "contentType"],
+      mapper: {
+        defaultValue: "application/json",
+        isConstant: true,
+        serializedName: "Content-Type",
+        type: {
+          name: "String"
+        }
+      }
+    };
+    var tableEntityProperties = {
+      parameterPath: ["options", "tableEntityProperties"],
+      mapper: {
+        serializedName: "tableEntityProperties",
+        xmlName: "tableEntityProperties",
+        type: {
+          name: "Dictionary",
+          value: { type: { name: "any" } }
+        }
+      }
+    };
+    var ifMatch = {
+      parameterPath: ["options", "ifMatch"],
+      mapper: {
+        serializedName: "If-Match",
+        xmlName: "If-Match",
+        type: {
+          name: "String"
+        }
+      }
+    };
+    var ifMatch1 = {
+      parameterPath: "ifMatch",
+      mapper: {
+        serializedName: "If-Match",
+        required: true,
+        xmlName: "If-Match",
+        type: {
+          name: "String"
+        }
+      }
+    };
+    var accept2 = {
+      parameterPath: "accept",
+      mapper: {
+        defaultValue: "application/xml",
+        isConstant: true,
+        serializedName: "Accept",
+        type: {
+          name: "String"
+        }
+      }
+    };
+    var comp = {
+      parameterPath: "comp",
+      mapper: {
+        defaultValue: "acl",
+        isConstant: true,
+        serializedName: "comp",
+        type: {
+          name: "String"
+        }
+      }
+    };
+    var contentType2 = {
+      parameterPath: ["options", "contentType"],
+      mapper: {
+        defaultValue: "application/xml",
+        isConstant: true,
+        serializedName: "Content-Type",
+        type: {
+          name: "String"
+        }
+      }
+    };
+    var tableAcl = {
+      parameterPath: ["options", "tableAcl"],
+      mapper: {
+        serializedName: "tableAcl",
+        xmlName: "SignedIdentifiers",
+        xmlIsWrapped: true,
+        xmlElementName: "SignedIdentifier",
+        type: {
+          name: "Sequence",
+          element: {
+            type: {
+              name: "Composite",
+              className: "SignedIdentifier"
+            }
+          }
+        }
+      }
+    };
+    var accept3 = {
+      parameterPath: "accept",
+      mapper: {
+        defaultValue: "application/xml",
+        isConstant: true,
+        serializedName: "Accept",
+        type: {
+          name: "String"
+        }
+      }
+    };
+    var tableServiceProperties = {
+      parameterPath: "tableServiceProperties",
+      mapper: TableServiceProperties
+    };
+    var restype = {
+      parameterPath: "restype",
+      mapper: {
+        defaultValue: "service",
+        isConstant: true,
+        serializedName: "restype",
+        type: {
+          name: "String"
+        }
+      }
+    };
+    var comp1 = {
+      parameterPath: "comp",
+      mapper: {
+        defaultValue: "properties",
+        isConstant: true,
+        serializedName: "comp",
+        type: {
+          name: "String"
+        }
+      }
+    };
+    var comp2 = {
+      parameterPath: "comp",
+      mapper: {
+        defaultValue: "stats",
+        isConstant: true,
+        serializedName: "comp",
+        type: {
+          name: "String"
+        }
+      }
+    };
+    var _TableImpl = class _TableImpl {
+      /**
+       * Initialize a new instance of the class Table class.
+       * @param client Reference to the service client
+       */
+      constructor(client) {
+        this.client = client;
+      }
+      /**
+       * Queries tables under the given account.
+       * @param options The options parameters.
+       */
+      query(options) {
+        return this.client.sendOperationRequest({ options }, queryOperationSpec);
+      }
+      /**
+       * Creates a new table under the given account.
+       * @param tableProperties The Table properties.
+       * @param options The options parameters.
+       */
+      create(tableProperties2, options) {
+        return this.client.sendOperationRequest({ tableProperties: tableProperties2, options }, createOperationSpec);
+      }
+      /**
+       * Operation permanently deletes the specified table.
+       * @param table The name of the table.
+       * @param options The options parameters.
+       */
+      delete(table2, options) {
+        return this.client.sendOperationRequest({ table: table2, options }, deleteOperationSpec);
+      }
+      /**
+       * Queries entities in a table.
+       * @param table The name of the table.
+       * @param options The options parameters.
+       */
+      queryEntities(table2, options) {
+        return this.client.sendOperationRequest({ table: table2, options }, queryEntitiesOperationSpec);
+      }
+      /**
+       * Queries entities in a table.
+       * @param table The name of the table.
+       * @param partitionKey The partition key of the entity.
+       * @param rowKey The row key of the entity.
+       * @param options The options parameters.
+       */
+      queryEntitiesWithPartitionAndRowKey(table2, partitionKey2, rowKey2, options) {
+        return this.client.sendOperationRequest({ table: table2, partitionKey: partitionKey2, rowKey: rowKey2, options }, queryEntitiesWithPartitionAndRowKeyOperationSpec);
+      }
+      /**
+       * Update entity in a table.
+       * @param table The name of the table.
+       * @param partitionKey The partition key of the entity.
+       * @param rowKey The row key of the entity.
+       * @param options The options parameters.
+       */
+      updateEntity(table2, partitionKey2, rowKey2, options) {
+        return this.client.sendOperationRequest({ table: table2, partitionKey: partitionKey2, rowKey: rowKey2, options }, updateEntityOperationSpec);
+      }
+      /**
+       * Merge entity in a table.
+       * @param table The name of the table.
+       * @param partitionKey The partition key of the entity.
+       * @param rowKey The row key of the entity.
+       * @param options The options parameters.
+       */
+      mergeEntity(table2, partitionKey2, rowKey2, options) {
+        return this.client.sendOperationRequest({ table: table2, partitionKey: partitionKey2, rowKey: rowKey2, options }, mergeEntityOperationSpec);
+      }
+      /**
+       * Deletes the specified entity in a table.
+       * @param table The name of the table.
+       * @param partitionKey The partition key of the entity.
+       * @param rowKey The row key of the entity.
+       * @param ifMatch Match condition for an entity to be deleted. If specified and a matching entity is
+       *                not found, an error will be raised. To force an unconditional delete, set to the wildcard character
+       *                (*).
+       * @param options The options parameters.
+       */
+      deleteEntity(table2, partitionKey2, rowKey2, ifMatch2, options) {
+        return this.client.sendOperationRequest({ table: table2, partitionKey: partitionKey2, rowKey: rowKey2, ifMatch: ifMatch2, options }, deleteEntityOperationSpec);
+      }
+      /**
+       * Insert entity in a table.
+       * @param table The name of the table.
+       * @param options The options parameters.
+       */
+      insertEntity(table2, options) {
+        return this.client.sendOperationRequest({ table: table2, options }, insertEntityOperationSpec);
+      }
+      /**
+       * Retrieves details about any stored access policies specified on the table that may be used with
+       * Shared Access Signatures.
+       * @param table The name of the table.
+       * @param options The options parameters.
+       */
+      getAccessPolicy(table2, options) {
+        return this.client.sendOperationRequest({ table: table2, options }, getAccessPolicyOperationSpec);
+      }
+      /**
+       * Sets stored access policies for the table that may be used with Shared Access Signatures.
+       * @param table The name of the table.
+       * @param options The options parameters.
+       */
+      setAccessPolicy(table2, options) {
+        return this.client.sendOperationRequest({ table: table2, options }, setAccessPolicyOperationSpec);
+      }
+    };
+    __name(_TableImpl, "TableImpl");
+    var TableImpl = _TableImpl;
+    var xmlSerializer$1 = coreClient__namespace.createSerializer(
+      Mappers,
+      /* isXml */
+      true
+    );
+    var serializer = coreClient__namespace.createSerializer(
+      Mappers,
+      /* isXml */
+      false
+    );
+    var queryOperationSpec = {
+      path: "/Tables",
+      httpMethod: "GET",
+      responses: {
+        200: {
+          bodyMapper: TableQueryResponse,
+          headersMapper: TableQueryHeaders
+        },
+        default: {
+          bodyMapper: TableServiceError,
+          headersMapper: TableQueryExceptionHeaders
+        }
+      },
+      queryParameters: [
+        format,
+        top,
+        select,
+        filter,
+        nextTableName
+      ],
+      urlParameters: [url],
+      headerParameters: [
+        accept,
+        version,
+        requestId,
+        dataServiceVersion
+      ],
+      serializer
+    };
+    var createOperationSpec = {
+      path: "/Tables",
+      httpMethod: "POST",
+      responses: {
+        201: {
+          bodyMapper: TableResponse,
+          headersMapper: TableCreateHeaders
+        },
+        204: {
+          headersMapper: TableCreateHeaders
+        },
+        default: {
+          bodyMapper: TableServiceError,
+          headersMapper: TableCreateExceptionHeaders
+        }
+      },
+      requestBody: tableProperties,
+      queryParameters: [format],
+      urlParameters: [url],
+      headerParameters: [
+        accept,
+        version,
+        requestId,
+        dataServiceVersion,
+        contentType,
+        responsePreference
+      ],
+      mediaType: "json",
+      serializer
+    };
+    var deleteOperationSpec = {
+      path: "/Tables('{table}')",
+      httpMethod: "DELETE",
+      responses: {
+        204: {
+          headersMapper: TableDeleteHeaders
+        },
+        default: {
+          bodyMapper: TableServiceError,
+          headersMapper: TableDeleteExceptionHeaders
+        }
+      },
+      urlParameters: [url, table],
+      headerParameters: [
+        version,
+        requestId,
+        accept1
+      ],
+      serializer
+    };
+    var queryEntitiesOperationSpec = {
+      path: "/{table}()",
+      httpMethod: "GET",
+      responses: {
+        200: {
+          bodyMapper: TableEntityQueryResponse,
+          headersMapper: TableQueryEntitiesHeaders
+        },
+        default: {
+          bodyMapper: TableServiceError,
+          headersMapper: TableQueryEntitiesExceptionHeaders
+        }
+      },
+      queryParameters: [
+        format,
+        top,
+        select,
+        filter,
+        timeout,
+        nextPartitionKey,
+        nextRowKey
+      ],
+      urlParameters: [url, table],
+      headerParameters: [
+        accept,
+        version,
+        requestId,
+        dataServiceVersion
+      ],
+      serializer
+    };
+    var queryEntitiesWithPartitionAndRowKeyOperationSpec = {
+      path: "/{table}(PartitionKey='{partitionKey}',RowKey='{rowKey}')",
+      httpMethod: "GET",
+      responses: {
+        200: {
+          bodyMapper: {
+            type: { name: "Dictionary", value: { type: { name: "any" } } }
+          },
+          headersMapper: TableQueryEntitiesWithPartitionAndRowKeyHeaders
+        },
+        default: {
+          bodyMapper: TableServiceError,
+          headersMapper: TableQueryEntitiesWithPartitionAndRowKeyExceptionHeaders
+        }
+      },
+      queryParameters: [
+        format,
+        select,
+        filter,
+        timeout
+      ],
+      urlParameters: [
+        url,
+        table,
+        partitionKey,
+        rowKey
+      ],
+      headerParameters: [
+        accept,
+        version,
+        requestId,
+        dataServiceVersion
+      ],
+      serializer
+    };
+    var updateEntityOperationSpec = {
+      path: "/{table}(PartitionKey='{partitionKey}',RowKey='{rowKey}')",
+      httpMethod: "PUT",
+      responses: {
+        204: {
+          headersMapper: TableUpdateEntityHeaders
+        },
+        default: {
+          bodyMapper: TableServiceError,
+          headersMapper: TableUpdateEntityExceptionHeaders
+        }
+      },
+      requestBody: tableEntityProperties,
+      queryParameters: [format, timeout],
+      urlParameters: [
+        url,
+        table,
+        partitionKey,
+        rowKey
+      ],
+      headerParameters: [
+        version,
+        requestId,
+        dataServiceVersion,
+        accept1,
+        contentType1,
+        ifMatch
+      ],
+      mediaType: "json",
+      serializer
+    };
+    var mergeEntityOperationSpec = {
+      path: "/{table}(PartitionKey='{partitionKey}',RowKey='{rowKey}')",
+      httpMethod: "PATCH",
+      responses: {
+        204: {
+          headersMapper: TableMergeEntityHeaders
+        },
+        default: {
+          bodyMapper: TableServiceError,
+          headersMapper: TableMergeEntityExceptionHeaders
+        }
+      },
+      requestBody: tableEntityProperties,
+      queryParameters: [format, timeout],
+      urlParameters: [
+        url,
+        table,
+        partitionKey,
+        rowKey
+      ],
+      headerParameters: [
+        version,
+        requestId,
+        dataServiceVersion,
+        accept1,
+        contentType1,
+        ifMatch
+      ],
+      mediaType: "json",
+      serializer
+    };
+    var deleteEntityOperationSpec = {
+      path: "/{table}(PartitionKey='{partitionKey}',RowKey='{rowKey}')",
+      httpMethod: "DELETE",
+      responses: {
+        204: {
+          headersMapper: TableDeleteEntityHeaders
+        },
+        default: {
+          bodyMapper: TableServiceError,
+          headersMapper: TableDeleteEntityExceptionHeaders
+        }
+      },
+      queryParameters: [format, timeout],
+      urlParameters: [
+        url,
+        table,
+        partitionKey,
+        rowKey
+      ],
+      headerParameters: [
+        accept,
+        version,
+        requestId,
+        dataServiceVersion,
+        ifMatch1
+      ],
+      serializer
+    };
+    var insertEntityOperationSpec = {
+      path: "/{table}",
+      httpMethod: "POST",
+      responses: {
+        201: {
+          bodyMapper: {
+            type: { name: "Dictionary", value: { type: { name: "any" } } }
+          },
+          headersMapper: TableInsertEntityHeaders
+        },
+        204: {
+          headersMapper: TableInsertEntityHeaders
+        },
+        default: {
+          bodyMapper: TableServiceError,
+          headersMapper: TableInsertEntityExceptionHeaders
+        }
+      },
+      requestBody: tableEntityProperties,
+      queryParameters: [format, timeout],
+      urlParameters: [url, table],
+      headerParameters: [
+        accept,
+        version,
+        requestId,
+        dataServiceVersion,
+        contentType,
+        responsePreference
+      ],
+      mediaType: "json",
+      serializer
+    };
+    var getAccessPolicyOperationSpec = {
+      path: "/{table}",
+      httpMethod: "GET",
+      responses: {
+        200: {
+          bodyMapper: {
+            type: {
+              name: "Sequence",
+              element: {
+                type: { name: "Composite", className: "SignedIdentifier" }
+              }
+            },
+            serializedName: "SignedIdentifiers",
+            xmlName: "SignedIdentifiers",
+            xmlIsWrapped: true,
+            xmlElementName: "SignedIdentifier"
+          },
+          headersMapper: TableGetAccessPolicyHeaders
+        },
+        default: {
+          bodyMapper: TableServiceError,
+          headersMapper: TableGetAccessPolicyExceptionHeaders
+        }
+      },
+      queryParameters: [timeout, comp],
+      urlParameters: [url, table],
+      headerParameters: [
+        version,
+        requestId,
+        accept2
+      ],
+      isXML: true,
+      serializer: xmlSerializer$1
+    };
+    var setAccessPolicyOperationSpec = {
+      path: "/{table}",
+      httpMethod: "PUT",
+      responses: {
+        204: {
+          headersMapper: TableSetAccessPolicyHeaders
+        },
+        default: {
+          bodyMapper: TableServiceError,
+          headersMapper: TableSetAccessPolicyExceptionHeaders
+        }
+      },
+      requestBody: tableAcl,
+      queryParameters: [timeout, comp],
+      urlParameters: [url, table],
+      headerParameters: [
+        version,
+        requestId,
+        contentType2,
+        accept3
+      ],
+      isXML: true,
+      contentType: "application/xml; charset=utf-8",
+      mediaType: "xml",
+      serializer: xmlSerializer$1
+    };
+    var _ServiceImpl = class _ServiceImpl {
+      /**
+       * Initialize a new instance of the class Service class.
+       * @param client Reference to the service client
+       */
+      constructor(client) {
+        this.client = client;
+      }
+      /**
+       * Sets properties for an account's Table service endpoint, including properties for Analytics and CORS
+       * (Cross-Origin Resource Sharing) rules.
+       * @param tableServiceProperties The Table Service properties.
+       * @param options The options parameters.
+       */
+      setProperties(tableServiceProperties2, options) {
+        return this.client.sendOperationRequest({ tableServiceProperties: tableServiceProperties2, options }, setPropertiesOperationSpec);
+      }
+      /**
+       * Gets the properties of an account's Table service, including properties for Analytics and CORS
+       * (Cross-Origin Resource Sharing) rules.
+       * @param options The options parameters.
+       */
+      getProperties(options) {
+        return this.client.sendOperationRequest({ options }, getPropertiesOperationSpec);
+      }
+      /**
+       * Retrieves statistics related to replication for the Table service. It is only available on the
+       * secondary location endpoint when read-access geo-redundant replication is enabled for the account.
+       * @param options The options parameters.
+       */
+      getStatistics(options) {
+        return this.client.sendOperationRequest({ options }, getStatisticsOperationSpec);
+      }
+    };
+    __name(_ServiceImpl, "ServiceImpl");
+    var ServiceImpl = _ServiceImpl;
+    var xmlSerializer = coreClient__namespace.createSerializer(
+      Mappers,
+      /* isXml */
+      true
+    );
+    var setPropertiesOperationSpec = {
+      path: "/",
+      httpMethod: "PUT",
+      responses: {
+        202: {
+          headersMapper: ServiceSetPropertiesHeaders
+        },
+        default: {
+          bodyMapper: TableServiceError,
+          headersMapper: ServiceSetPropertiesExceptionHeaders
+        }
+      },
+      requestBody: tableServiceProperties,
+      queryParameters: [timeout, restype, comp1],
+      urlParameters: [url],
+      headerParameters: [
+        version,
+        requestId,
+        contentType2,
+        accept3
+      ],
+      isXML: true,
+      contentType: "application/xml; charset=utf-8",
+      mediaType: "xml",
+      serializer: xmlSerializer
+    };
+    var getPropertiesOperationSpec = {
+      path: "/",
+      httpMethod: "GET",
+      responses: {
+        200: {
+          bodyMapper: TableServiceProperties,
+          headersMapper: ServiceGetPropertiesHeaders
+        },
+        default: {
+          bodyMapper: TableServiceError,
+          headersMapper: ServiceGetPropertiesExceptionHeaders
+        }
+      },
+      queryParameters: [timeout, restype, comp1],
+      urlParameters: [url],
+      headerParameters: [
+        version,
+        requestId,
+        accept2
+      ],
+      isXML: true,
+      serializer: xmlSerializer
+    };
+    var getStatisticsOperationSpec = {
+      path: "/",
+      httpMethod: "GET",
+      responses: {
+        200: {
+          bodyMapper: TableServiceStats,
+          headersMapper: ServiceGetStatisticsHeaders
+        },
+        default: {
+          bodyMapper: TableServiceError,
+          headersMapper: ServiceGetStatisticsExceptionHeaders
+        }
+      },
+      queryParameters: [timeout, restype, comp2],
+      urlParameters: [url],
+      headerParameters: [
+        version,
+        requestId,
+        accept2
+      ],
+      isXML: true,
+      serializer: xmlSerializer
+    };
+    var _GeneratedClient = class _GeneratedClient extends coreClient__namespace.ServiceClient {
+      /**
+       * Initializes a new instance of the GeneratedClient class.
+       * @param url The URL of the service account or table that is the target of the desired operation.
+       * @param options The parameter options
+       */
+      constructor(url2, options) {
+        var _a, _b;
+        if (url2 === void 0) {
+          throw new Error("'url' cannot be null");
+        }
+        if (!options) {
+          options = {};
+        }
+        const defaults = {
+          requestContentType: "application/json; charset=utf-8"
+        };
+        const packageDetails = `azsdk-js-data-tables/13.1.2`;
+        const userAgentPrefix = options.userAgentOptions && options.userAgentOptions.userAgentPrefix ? `${options.userAgentOptions.userAgentPrefix} ${packageDetails}` : `${packageDetails}`;
+        const optionsWithDefaults = Object.assign(Object.assign(Object.assign({}, defaults), options), { userAgentOptions: {
+          userAgentPrefix
+        }, baseUri: (_b = (_a = options.endpoint) !== null && _a !== void 0 ? _a : options.baseUri) !== null && _b !== void 0 ? _b : "{url}" });
+        super(optionsWithDefaults);
+        this.url = url2;
+        this.version = options.version || "2019-02-02";
+        this.table = new TableImpl(this);
+        this.service = new ServiceImpl(this);
+      }
+    };
+    __name(_GeneratedClient, "GeneratedClient");
+    var GeneratedClient = _GeneratedClient;
+    var apiVersionPolicyName = "apiVersionPolicy";
+    var apiVersionPolicy = /* @__PURE__ */ __name((apiVersion) => {
+      return {
+        name: apiVersionPolicyName,
+        sendRequest: /* @__PURE__ */ __name(async (req, next) => {
+          req.headers.set("x-ms-version", apiVersion);
+          return next(req);
+        }, "sendRequest")
+      };
+    }, "apiVersionPolicy");
+    function fromAccountConnectionString(extractedCreds, options = {}) {
+      const sharedKeyCredential = new coreAuth.AzureNamedKeyCredential(extractedCreds.accountName, extractedCreds.accountKey);
+      return {
+        url: extractedCreds.url,
+        options,
+        credential: sharedKeyCredential
+      };
+    }
+    __name(fromAccountConnectionString, "fromAccountConnectionString");
+    function getAccountConnectionString(accountName, accountKey, defaultEndpointsProtocol, endpointSuffix, tableEndpoint) {
+      if (!tableEndpoint) {
+        const protocol = defaultEndpointsProtocol.toLowerCase();
+        if (protocol !== "https" && protocol !== "http") {
+          throw new Error("Invalid DefaultEndpointsProtocol in the provided Connection String. Expecting 'https' or 'http'");
+        }
+        if (!endpointSuffix) {
+          throw new Error("Invalid EndpointSuffix in the provided Connection String");
+        }
+        tableEndpoint = `${defaultEndpointsProtocol}://${accountName}.table.${endpointSuffix}`;
+      }
+      if (!accountName) {
+        throw new Error("Invalid AccountName in the provided Connection String");
+      } else if (accountKey.length === 0) {
+        throw new Error("Invalid AccountKey in the provided Connection String");
+      }
+      return {
+        kind: "AccountConnString",
+        url: tableEndpoint,
+        accountName,
+        accountKey
+      };
+    }
+    __name(getAccountConnectionString, "getAccountConnectionString");
+    var DevelopmentConnectionString = "DefaultEndpointsProtocol=http;AccountName=devstoreaccount1;AccountKey=Eby8vdM02xNOcqFlqUwJPLlmEtlCDXJ1OUzFT50uSRZ6IFsuFq2UVErCz4I6tq/K1SZFPTOtr/KBHBeksoGMGw==;TableEndpoint=http://127.0.0.1:10002/devstoreaccount1";
+    function getClientParamsFromConnectionString(connectionString, options = {}) {
+      if (connectionString.toLowerCase().indexOf("usedevelopmentstorage=true") !== -1) {
+        connectionString = DevelopmentConnectionString;
+        options.allowInsecureConnection = true;
+      }
+      const extractedCreds = extractConnectionStringParts(connectionString);
+      if (extractedCreds.kind === "AccountConnString") {
+        return fromAccountConnectionString(extractedCreds, options);
+      } else if (extractedCreds.kind === "SASConnString") {
+        return {
+          url: `${extractedCreds.url}?${extractedCreds.accountSas}`,
+          options
+        };
+      } else {
+        throw new Error("Connection string must be either an Account connection string or a SAS connection string");
+      }
+    }
+    __name(getClientParamsFromConnectionString, "getClientParamsFromConnectionString");
+    function extractConnectionStringParts(connectionString) {
+      let tableEndpoint = getValueInConnString(connectionString, "TableEndpoint");
+      tableEndpoint = tableEndpoint.endsWith("/") ? tableEndpoint.slice(0, -1) : tableEndpoint;
+      if (isAccountConnectionString(connectionString)) {
+        return getAccountConnectionString(getValueInConnString(connectionString, "AccountName"), getValueInConnString(connectionString, "AccountKey"), getValueInConnString(connectionString, "DefaultEndpointsProtocol"), getValueInConnString(connectionString, "EndpointSuffix"), tableEndpoint);
+      } else {
+        return getSASConnectionString(connectionString, tableEndpoint);
+      }
+    }
+    __name(extractConnectionStringParts, "extractConnectionStringParts");
+    function isAccountConnectionString(connectionString) {
+      const lowercaseConnectionString = connectionString.toLowerCase();
+      return lowercaseConnectionString.search("defaultendpointsprotocol=") !== -1 && lowercaseConnectionString.search("accountkey=") !== -1;
+    }
+    __name(isAccountConnectionString, "isAccountConnectionString");
+    function getSASConnectionString(connectionString, tableEndpoint) {
+      const accountName = getAccountNameFromUrl(tableEndpoint);
+      const accountSas = getValueInConnString(connectionString, "SharedAccessSignature");
+      if (!tableEndpoint) {
+        throw new Error("Invalid TableEndpoint in the provided SAS Connection String");
+      } else if (!accountSas) {
+        throw new Error("Invalid SharedAccessSignature in the provided SAS Connection String");
+      } else if (!accountName) {
+        throw new Error("Invalid AccountName in the provided SAS Connection String");
+      }
+      return { kind: "SASConnString", url: tableEndpoint, accountName, accountSas };
+    }
+    __name(getSASConnectionString, "getSASConnectionString");
+    function getValueInConnString(connectionString, argument) {
+      const searchKey = argument.toLowerCase();
+      const elements = connectionString.split(";").filter((e) => Boolean(e));
+      for (const element of elements) {
+        const trimmedElement = element.trim();
+        const [elementKey, value] = getValuePair(trimmedElement);
+        const key = elementKey.toLowerCase();
+        if (key === searchKey) {
+          return value;
+        }
+      }
+      return "";
+    }
+    __name(getValueInConnString, "getValueInConnString");
+    function getValuePair(kvp) {
+      if (!kvp || kvp.indexOf("=") === -1) {
+        return [];
+      }
+      const key = kvp.substr(0, kvp.indexOf("="));
+      const value = kvp.substr(kvp.indexOf("=") + 1);
+      return [key, value];
+    }
+    __name(getValuePair, "getValuePair");
+    function getAccountNameFromUrl(url2) {
+      if (!url2) {
+        return url2;
+      }
+      const parsedUrl = new URL(url2);
+      let accountName;
+      const host = parsedUrl.host || "";
+      const path = parsedUrl.pathname || "";
+      const hostParts = host.split(".");
+      const pathParts = path.split("/");
+      if (hostParts.length >= 1 && hostParts[1] === "table") {
+        url2 = url2.endsWith("/") ? url2.slice(0, -1) : url2;
+        accountName = host.split(".")[0];
+      } else if (pathParts.length >= 1) {
+        accountName = pathParts[1];
+      } else {
+        throw new Error("Unable to extract accountName with provided information.");
+      }
+      return accountName;
+    }
+    __name(getAccountNameFromUrl, "getAccountNameFromUrl");
+    function handleTableAlreadyExists(error, options = {}) {
+      var _a, _b;
+      const responseError = getErrorResponse(error);
+      if (responseError && responseError.status === 409 && ((_a = responseError.parsedBody.odataError) === null || _a === void 0 ? void 0 : _a.code) === "TableAlreadyExists") {
+        (_b = options.logger) === null || _b === void 0 ? void 0 : _b.info(`Table ${options.tableName} already Exists`);
+        if (options.onResponse) {
+          options.onResponse(responseError, {});
+        }
+      } else {
+        throw error;
+      }
+    }
+    __name(handleTableAlreadyExists, "handleTableAlreadyExists");
+    function getErrorResponse(error) {
+      if (!isRestError(error)) {
+        return void 0;
+      }
+      const errorResponse = error.response;
+      if (!errorResponse || !isTableServiceErrorResponse(errorResponse.parsedBody)) {
+        return void 0;
+      }
+      return errorResponse;
+    }
+    __name(getErrorResponse, "getErrorResponse");
+    function isRestError(error) {
+      return error.name === "RestError";
+    }
+    __name(isRestError, "isRestError");
+    function isTableServiceErrorResponse(errorResponseBody) {
+      return Boolean(errorResponseBody === null || errorResponseBody === void 0 ? void 0 : errorResponseBody.odataError);
+    }
+    __name(isTableServiceErrorResponse, "isTableServiceErrorResponse");
+    function isCredential(credential) {
+      return coreAuth.isSASCredential(credential) || coreAuth.isNamedKeyCredential(credential) || coreAuth.isTokenCredential(credential);
+    }
+    __name(isCredential, "isCredential");
+    var logger2 = logger$1.createClientLogger("data-tables");
+    function setTokenChallengeAuthenticationPolicy(pipeline, credential, scopes) {
+      pipeline.removePolicy({ name: "bearerTokenPolicy" });
+      pipeline.addPolicy(coreRestPipeline.bearerTokenAuthenticationPolicy({
+        credential,
+        scopes,
+        challengeCallbacks: { authorizeRequestOnChallenge: coreClient.authorizeRequestOnTenantChallenge }
+      }), {
+        phase: "Sign"
+      });
+    }
+    __name(setTokenChallengeAuthenticationPolicy, "setTokenChallengeAuthenticationPolicy");
+    var tablesNamedKeyCredentialPolicyName = "tablesNamedKeyCredentialPolicy";
+    function tablesNamedKeyCredentialPolicy(credential) {
+      function signRequest(request) {
+        const headerValue = getAuthorizationHeader(request, credential);
+        request.headers.set(HeaderConstants.AUTHORIZATION, headerValue);
+      }
+      __name(signRequest, "signRequest");
+      return {
+        name: tablesNamedKeyCredentialPolicyName,
+        async sendRequest(request, next) {
+          signRequest(request);
+          return next(request);
+        }
+      };
+    }
+    __name(tablesNamedKeyCredentialPolicy, "tablesNamedKeyCredentialPolicy");
+    function getAuthorizationHeader(request, credential) {
+      if (!request.headers.has(HeaderConstants.X_MS_DATE)) {
+        request.headers.set(HeaderConstants.X_MS_DATE, (/* @__PURE__ */ new Date()).toUTCString());
+      }
+      if (request.body && typeof request.body === "string" && request.body.length > 0) {
+        request.headers.set(HeaderConstants.CONTENT_LENGTH, Buffer.byteLength(request.body));
+      }
+      const dateHeader = getHeaderValueToSign(request, HeaderConstants.X_MS_DATE);
+      if (!dateHeader) {
+        throw new Error("Failed to sign request: x-ms-date or date header must be present");
+      }
+      const stringToSign = [
+        dateHeader,
+        getCanonicalizedResourceString(request, credential)
+      ].join("\n");
+      const signature = computeHMACSHA256(stringToSign, credential.key);
+      return `SharedKeyLite ${credential.name}:${signature}`;
+    }
+    __name(getAuthorizationHeader, "getAuthorizationHeader");
+    function getHeaderValueToSign(request, headerName) {
+      const value = request.headers.get(headerName);
+      if (!value) {
+        return "";
+      }
+      return value;
+    }
+    __name(getHeaderValueToSign, "getHeaderValueToSign");
+    function getCanonicalizedResourceString(request, credential) {
+      const url2 = new URL(request.url);
+      const path = url2.pathname || "/";
+      let canonicalizedResourceString = "/" + credential.name + path;
+      const comp3 = url2.searchParams.get("comp");
+      if (comp3) {
+        canonicalizedResourceString = `${canonicalizedResourceString}?comp=${comp3}`;
+      }
+      return canonicalizedResourceString;
+    }
+    __name(getCanonicalizedResourceString, "getCanonicalizedResourceString");
+    var tablesSASTokenPolicyName = "tablesSASTokenPolicy";
+    function tablesSASTokenPolicy(credential) {
+      return {
+        name: tablesSASTokenPolicyName,
+        async sendRequest(request, next) {
+          signURLWithSAS(request, credential);
+          return next(request);
+        }
+      };
+    }
+    __name(tablesSASTokenPolicy, "tablesSASTokenPolicy");
+    function signURLWithSAS(request, credential) {
+      const sasParams = new URLSearchParams(credential.signature);
+      const url2 = new URL(request.url);
+      for (const [name, value] of sasParams) {
+        url2.searchParams.append(name, value);
+      }
+      request.url = url2.toString();
+    }
+    __name(signURLWithSAS, "signURLWithSAS");
+    var tracingClient = coreTracing.createTracingClient({
+      namespace: "Microsoft.Data.Tables",
+      packageName: "@azure/data-tables",
+      packageVersion: "13.3.0"
+    });
+    function isCosmosEndpoint(url2) {
+      const parsedURL = new URL(url2);
+      if (parsedURL.hostname.indexOf(".table.cosmosdb.") !== -1) {
+        return true;
+      }
+      if (parsedURL.hostname.indexOf(".table.cosmos.") !== -1) {
+        return true;
+      }
+      if (parsedURL.hostname === "localhost" && parsedURL.port !== "10002") {
+        return true;
+      }
+      return false;
+    }
+    __name(isCosmosEndpoint, "isCosmosEndpoint");
+    var _TableServiceClient = class _TableServiceClient {
+      constructor(url2, credentialOrOptions, options) {
+        this.url = url2;
+        const isCosmos = isCosmosEndpoint(this.url);
+        const credential = isCredential(credentialOrOptions) ? credentialOrOptions : void 0;
+        const clientOptions = (!isCredential(credentialOrOptions) ? credentialOrOptions : options) || {};
+        const internalPipelineOptions = Object.assign(Object.assign({}, clientOptions), { endpoint: clientOptions.endpoint || this.url, loggingOptions: {
+          logger: logger2.info,
+          additionalAllowedHeaderNames: [...TablesLoggingAllowedHeaderNames]
+        }, deserializationOptions: {
+          parseXML: coreXml.parseXML
+        }, serializationOptions: {
+          stringifyXML: coreXml.stringifyXML
+        } });
+        const client = new GeneratedClient(this.url, internalPipelineOptions);
+        client.pipeline.addPolicy(tablesSecondaryEndpointPolicy);
+        if (coreAuth.isNamedKeyCredential(credential)) {
+          client.pipeline.addPolicy(tablesNamedKeyCredentialPolicy(credential));
+        } else if (coreAuth.isSASCredential(credential)) {
+          client.pipeline.addPolicy(tablesSASTokenPolicy(credential));
+        }
+        if (coreAuth.isTokenCredential(credential)) {
+          const scope = isCosmos ? COSMOS_SCOPE : STORAGE_SCOPE;
+          setTokenChallengeAuthenticationPolicy(client.pipeline, credential, scope);
+        }
+        if (options === null || options === void 0 ? void 0 : options.version) {
+          client.pipeline.addPolicy(apiVersionPolicy(options.version));
+        }
+        this.pipeline = client.pipeline;
+        this.table = client.table;
+        this.service = client.service;
+      }
+      /**
+       * Retrieves statistics related to replication for the Table service. It is only available on the
+       * secondary location endpoint when read-access geo-redundant replication is enabled for the account.
+       * @param options - The options parameters.
+       */
+      // eslint-disable-next-line @azure/azure-sdk/ts-naming-options
+      async getStatistics(options = {}) {
+        return tracingClient.withSpan("TableServiceClient.getStatistics", options, (updatedOptions) => this.service.getStatistics(injectSecondaryEndpointHeader(updatedOptions)));
+      }
+      /**
+       * Gets the properties of an account's Table service, including properties for Analytics and CORS
+       * (Cross-Origin Resource Sharing) rules.
+       * @param options - The options parameters.
+       */
+      // eslint-disable-next-line @azure/azure-sdk/ts-naming-options
+      getProperties(options = {}) {
+        return tracingClient.withSpan("TableServiceClient.getProperties", options, (updatedOptions) => this.service.getProperties(updatedOptions));
+      }
+      /**
+       * Sets properties for an account's Table service endpoint, including properties for Analytics and CORS
+       * (Cross-Origin Resource Sharing) rules.
+       * @param properties - The Table Service properties.
+       * @param options - The options parameters.
+       */
+      setProperties(properties, options = {}) {
+        return tracingClient.withSpan("TableServiceClient.setProperties", options, (updatedOptions) => this.service.setProperties(properties, updatedOptions));
+      }
+      /**
+       * Creates a new table under the given account.
+       * @param name - The name of the table.
+       * @param options - The options parameters.
+       */
+      // eslint-disable-next-line @azure/azure-sdk/ts-naming-options
+      createTable(name, options = {}) {
+        return tracingClient.withSpan("TableServiceClient.createTable", options, async (updatedOptions) => {
+          try {
+            await this.table.create({ name }, updatedOptions);
+          } catch (e) {
+            handleTableAlreadyExists(e, Object.assign(Object.assign({}, updatedOptions), { logger: logger2, tableName: name }));
+          }
+        });
+      }
+      /**
+       * Operation permanently deletes the specified table.
+       * @param name - The name of the table.
+       * @param options - The options parameters.
+       */
+      // eslint-disable-next-line @azure/azure-sdk/ts-naming-options
+      deleteTable(name, options = {}) {
+        return tracingClient.withSpan("TableServiceClient.deleteTable", options, async (updatedOptions) => {
+          try {
+            await this.table.delete(name, updatedOptions);
+          } catch (e) {
+            if (e.statusCode === 404) {
+              logger2.info("TableServiceClient.deleteTable: Table doesn't exist");
+            } else {
+              throw e;
+            }
+          }
+        });
+      }
+      /**
+       * Queries tables under the given account.
+       * @param options - The options parameters.
+       */
+      listTables(options) {
+        const iter = this.listTablesAll(options);
+        return {
+          next() {
+            return iter.next();
+          },
+          [Symbol.asyncIterator]() {
+            return this;
+          },
+          byPage: /* @__PURE__ */ __name((settings) => {
+            const pageOptions = Object.assign(Object.assign({}, options), { queryOptions: Object.assign(Object.assign({}, options === null || options === void 0 ? void 0 : options.queryOptions), { top: settings === null || settings === void 0 ? void 0 : settings.maxPageSize }) });
+            if (settings === null || settings === void 0 ? void 0 : settings.continuationToken) {
+              pageOptions.continuationToken = settings.continuationToken;
+            }
+            return this.listTablesPage(pageOptions);
+          }, "byPage")
+        };
+      }
+      listTablesAll(options) {
+        return tslib.__asyncGenerator(this, arguments, /* @__PURE__ */ __name(function* listTablesAll_1() {
+          var _a, e_1, _b, _c;
+          const firstPage = yield tslib.__await(this._listTables(options));
+          const { continuationToken } = firstPage;
+          yield tslib.__await(yield* tslib.__asyncDelegator(tslib.__asyncValues(firstPage)));
+          if (continuationToken) {
+            const optionsWithContinuation = Object.assign(Object.assign({}, options), { continuationToken });
+            try {
+              for (var _d = true, _e = tslib.__asyncValues(this.listTablesPage(optionsWithContinuation)), _f; _f = yield tslib.__await(_e.next()), _a = _f.done, !_a; _d = true) {
+                _c = _f.value;
+                _d = false;
+                const page = _c;
+                yield tslib.__await(yield* tslib.__asyncDelegator(tslib.__asyncValues(page)));
+              }
+            } catch (e_1_1) {
+              e_1 = { error: e_1_1 };
+            } finally {
+              try {
+                if (!_d && !_a && (_b = _e.return)) yield tslib.__await(_b.call(_e));
+              } finally {
+                if (e_1) throw e_1.error;
+              }
+            }
+          }
+        }, "listTablesAll_1"));
+      }
+      listTablesPage() {
+        return tslib.__asyncGenerator(this, arguments, /* @__PURE__ */ __name(function* listTablesPage_1(options = {}) {
+          let result = yield tslib.__await(tracingClient.withSpan("TableServiceClient.listTablesPage", options, (updatedOptions) => this._listTables(updatedOptions)));
+          yield yield tslib.__await(result);
+          while (result.continuationToken) {
+            const optionsWithContinuation = Object.assign(Object.assign({}, options), { continuationToken: result.continuationToken });
+            result = yield tslib.__await(tracingClient.withSpan("TableServiceClient.listTablesPage", optionsWithContinuation, async (updatedOptions, span) => {
+              span.setAttribute("continuationToken", updatedOptions.continuationToken);
+              return this._listTables(updatedOptions);
+            }));
+            yield yield tslib.__await(result);
+          }
+        }, "listTablesPage_1"));
+      }
+      async _listTables(options = {}) {
+        const { continuationToken: nextTableName2 } = options, listOptions = tslib.__rest(options, ["continuationToken"]);
+        const { xMsContinuationNextTableName: continuationToken, value = [] } = await this.table.query(Object.assign(Object.assign({}, listOptions), { nextTableName: nextTableName2 }));
+        return Object.assign([...value], { continuationToken });
+      }
+      /**
+       *
+       * Creates an instance of TableServiceClient from connection string.
+       *
+       * @param connectionString - Account connection string or a SAS connection string of an Azure storage account.
+       *                           [ Note - Account connection string can only be used in NODE.JS runtime. ]
+       *                           Account connection string example -
+       *                           `DefaultEndpointsProtocol=https;AccountName=myaccount;AccountKey=accountKey;EndpointSuffix=core.windows.net`
+       *                           SAS connection string example -
+       *                           `BlobEndpoint=https://myaccount.table.core.windows.net/;QueueEndpoint=https://myaccount.queue.core.windows.net/;FileEndpoint=https://myaccount.file.core.windows.net/;TableEndpoint=https://myaccount.table.core.windows.net/;SharedAccessSignature=sasString`
+       * @param options - Options to configure the HTTP pipeline.
+       * @returns A new TableServiceClient from the given connection string.
+       */
+      static fromConnectionString(connectionString, options) {
+        const { url: url2, options: clientOptions, credential } = getClientParamsFromConnectionString(connectionString, options);
+        if (credential) {
+          return new _TableServiceClient(url2, credential, clientOptions);
+        } else {
+          return new _TableServiceClient(url2, clientOptions);
+        }
+      }
+    };
+    __name(_TableServiceClient, "TableServiceClient");
+    var TableServiceClient = _TableServiceClient;
+    function getChangeSetBoundary(changesetId) {
+      return `changeset_${changesetId}`;
+    }
+    __name(getChangeSetBoundary, "getChangeSetBoundary");
+    function getTransactionBoundary(transactionId) {
+      return `batch_${transactionId}`;
+    }
+    __name(getTransactionBoundary, "getTransactionBoundary");
+    function getInitialTransactionBody(transactionId, changesetId) {
+      const transactionBoundary = `batch_${transactionId}`;
+      return [
+        `--${transactionBoundary}${TRANSACTION_HTTP_LINE_ENDING}${HeaderConstants.CONTENT_TYPE}: multipart/mixed; boundary=changeset_${changesetId}${TRANSACTION_HTTP_LINE_ENDING}${TRANSACTION_HTTP_LINE_ENDING}`
+      ];
+    }
+    __name(getInitialTransactionBody, "getInitialTransactionBody");
+    function getTransactionHttpRequestBody(bodyParts, transactionId, changesetId) {
+      const transactionBoundary = getTransactionBoundary(transactionId);
+      const changesetBoundary = getChangeSetBoundary(changesetId);
+      const changesetEnding = `--${changesetBoundary}--`;
+      const transactionEnding = `--${transactionBoundary}--`;
+      const bodyContent = bodyParts.join(TRANSACTION_HTTP_LINE_ENDING);
+      return `${bodyContent}${TRANSACTION_HTTP_LINE_ENDING}${changesetEnding}${TRANSACTION_HTTP_LINE_ENDING}${transactionEnding}${TRANSACTION_HTTP_LINE_ENDING}`;
+    }
+    __name(getTransactionHttpRequestBody, "getTransactionHttpRequestBody");
+    var transactionRequestAssemblePolicyName = "transactionRequestAssemblePolicy";
+    var dummyResponse = {
+      request: coreRestPipeline.createPipelineRequest({ url: "FAKE" }),
+      status: 200,
+      headers: coreRestPipeline.createHttpHeaders()
+    };
+    function transactionRequestAssemblePolicy(bodyParts, changesetId) {
+      return {
+        name: transactionRequestAssemblePolicyName,
+        async sendRequest(request) {
+          const subRequest = getNextSubrequestBodyPart(request, changesetId);
+          bodyParts.push(subRequest);
+          return dummyResponse;
+        }
+      };
+    }
+    __name(transactionRequestAssemblePolicy, "transactionRequestAssemblePolicy");
+    var transactionHeaderFilterPolicyName = "transactionHeaderFilterPolicy";
+    function transactionHeaderFilterPolicy() {
+      return {
+        name: transactionHeaderFilterPolicyName,
+        async sendRequest(request, next) {
+          request.headers.delete(HeaderConstants.X_MS_VERSION);
+          return next(request);
+        }
+      };
+    }
+    __name(transactionHeaderFilterPolicy, "transactionHeaderFilterPolicy");
+    function getSubRequestUrl(url2) {
+      const sasTokenParts = ["sv", "ss", "srt", "sp", "se", "st", "spr", "sig"];
+      const urlParsed = new URL(url2);
+      sasTokenParts.forEach((part) => urlParsed.searchParams.delete(part));
+      return urlParsed.toString();
+    }
+    __name(getSubRequestUrl, "getSubRequestUrl");
+    function getNextSubrequestBodyPart(request, changesetId) {
+      const changesetBoundary = getChangeSetBoundary(changesetId);
+      const subRequestPrefix = `--${changesetBoundary}${TRANSACTION_HTTP_LINE_ENDING}${HeaderConstants.CONTENT_TYPE}: application/http${TRANSACTION_HTTP_LINE_ENDING}${HeaderConstants.CONTENT_TRANSFER_ENCODING}: binary`;
+      const subRequestUrl = getSubRequestUrl(request.url);
+      const subRequest = [
+        subRequestPrefix,
+        // sub request constant prefix
+        "",
+        // empty line after sub request's content ID
+        `${request.method.toString()} ${subRequestUrl} ${TRANSACTION_HTTP_VERSION_1_1}`
+        // sub request start line with method,
+      ];
+      for (const [name, value] of request.headers) {
+        subRequest.push(`${name}: ${value}`);
+      }
+      subRequest.push(`${TRANSACTION_HTTP_LINE_ENDING}`);
+      if (request.body) {
+        subRequest.push(String(request.body));
+      }
+      return subRequest.join(TRANSACTION_HTTP_LINE_ENDING);
+    }
+    __name(getNextSubrequestBodyPart, "getNextSubrequestBodyPart");
+    var cosmosPatchPolicyName = "cosmosPatchPolicy";
+    function cosmosPatchPolicy() {
+      return {
+        name: cosmosPatchPolicyName,
+        sendRequest: /* @__PURE__ */ __name((request, next) => {
+          if (request.method === "PATCH") {
+            request.method = "POST";
+            request.headers.set("X-HTTP-Method", "MERGE");
+          }
+          return next(request);
+        }, "sendRequest")
+      };
+    }
+    __name(cosmosPatchPolicy, "cosmosPatchPolicy");
+    function getBaseTransactionHeaders(transactionGuid) {
+      return {
+        accept: "application/json",
+        "x-ms-version": "2019-02-02",
+        DataServiceVersion: "3.0;",
+        MaxDataServiceVersion: "3.0;NetFx",
+        "Content-Type": `multipart/mixed; boundary=batch_${transactionGuid}`
+      };
+    }
+    __name(getBaseTransactionHeaders, "getBaseTransactionHeaders");
+    function getTransactionHeaders(transactionGuid) {
+      const baseHeaders = getBaseTransactionHeaders(transactionGuid);
+      return Object.assign(Object.assign({}, baseHeaders), {
+        // The below headers are not supported in the browser as they are flagged as "unsafe headers"
+        "Accept-Charset": "UTF-8",
+        Connection: "Keep-Alive"
+      });
+    }
+    __name(getTransactionHeaders, "getTransactionHeaders");
+    var _TableTransaction = class _TableTransaction {
+      constructor(actions) {
+        this.actions = actions !== null && actions !== void 0 ? actions : [];
+      }
+      /**
+       * Adds a create action to the transaction
+       * @param entity - entity to create
+       */
+      createEntity(entity) {
+        this.actions.push(["create", entity]);
+      }
+      /**
+       * Adds a delete action to the transaction
+       * @param partitionKey - partition key of the entity to delete
+       * @param rowKey - rowKey of the entity to delete
+       */
+      deleteEntity(partitionKey2, rowKey2) {
+        this.actions.push(["delete", { partitionKey: partitionKey2, rowKey: rowKey2 }]);
+      }
+      /**
+       * Adds an update action to the transaction
+       * @param entity - entity to update
+       * @param updateModeOrOptions - update mode or update options
+       * @param updateOptions - options for the update operation
+       */
+      updateEntity(entity, updateModeOrOptions, updateOptions) {
+        const realUpdateMode = typeof updateModeOrOptions === "string" ? updateModeOrOptions : void 0;
+        const realUpdateOptions = typeof updateModeOrOptions === "object" ? updateModeOrOptions : updateOptions;
+        this.actions.push(["update", entity, realUpdateMode !== null && realUpdateMode !== void 0 ? realUpdateMode : "Merge", realUpdateOptions !== null && realUpdateOptions !== void 0 ? realUpdateOptions : {}]);
+      }
+      /**
+       * Adds an upsert action to the transaction, which inserts if the entity doesn't exist or updates the existing one
+       * @param entity - entity to upsert
+       * @param updateMode - update mode
+       */
+      upsertEntity(entity, updateMode = "Merge") {
+        this.actions.push(["upsert", entity, updateMode]);
+      }
+    };
+    __name(_TableTransaction, "TableTransaction");
+    var TableTransaction = _TableTransaction;
+    var _InternalTableTransaction = class _InternalTableTransaction {
+      /**
+       * @param url - Tables account url
+       * @param partitionKey - partition key
+       * @param credential - credential to authenticate the transaction request
+       */
+      constructor(url2, partitionKey2, transactionId, changesetId, client, interceptClient, credential, allowInsecureConnection = false) {
+        this.client = client;
+        this.url = url2;
+        this.interceptClient = interceptClient;
+        this.allowInsecureConnection = allowInsecureConnection;
+        this.state = this.initializeState(transactionId, changesetId, partitionKey2);
+        if (!credential) {
+          const urlParts = url2.split("?");
+          this.url = urlParts[0];
+          const sas = urlParts.length > 1 ? `?${urlParts[1]}` : "";
+          this.url = `${this.getUrlWithSlash()}$batch${sas}`;
+        } else {
+          this.url = `${this.getUrlWithSlash()}$batch`;
+        }
+      }
+      initializeState(transactionId, changesetId, partitionKey2) {
+        const pendingOperations = [];
+        const bodyParts = getInitialTransactionBody(transactionId, changesetId);
+        const isCosmos = isCosmosEndpoint(this.url);
+        prepateTransactionPipeline(this.interceptClient.pipeline, bodyParts, changesetId, isCosmos);
+        return {
+          transactionId,
+          changesetId,
+          partitionKey: partitionKey2,
+          pendingOperations,
+          bodyParts
+        };
+      }
+      /**
+       * Adds a createEntity operation to the transaction
+       * @param entity - Entity to create
+       */
+      createEntity(entity) {
+        this.checkPartitionKey(entity.partitionKey);
+        this.state.pendingOperations.push(this.interceptClient.createEntity(entity));
+      }
+      /**
+       * Adds a createEntity operation to the transaction per each entity in the entities array
+       * @param entities - Array of entities to create
+       */
+      createEntities(entities) {
+        for (const entity of entities) {
+          this.checkPartitionKey(entity.partitionKey);
+          this.state.pendingOperations.push(this.interceptClient.createEntity(entity));
+        }
+      }
+      /**
+       * Adds a deleteEntity operation to the transaction
+       * @param partitionKey - Partition key of the entity to delete
+       * @param rowKey - Row key of the entity to delete
+       * @param options - Options for the delete operation
+       */
+      deleteEntity(partitionKey2, rowKey2, options) {
+        this.checkPartitionKey(partitionKey2);
+        this.state.pendingOperations.push(this.interceptClient.deleteEntity(partitionKey2, rowKey2, options));
+      }
+      /**
+       * Adds an updateEntity operation to the transaction
+       * @param entity - Entity to update
+       * @param mode - Update mode (Merge or Replace)
+       * @param options - Options for the update operation
+       */
+      updateEntity(entity, mode, options) {
+        this.checkPartitionKey(entity.partitionKey);
+        this.state.pendingOperations.push(this.interceptClient.updateEntity(entity, mode, options));
+      }
+      /**
+       * Adds an upsertEntity operation to the transaction
+       * @param entity - The properties for the table entity.
+       * @param mode   - The different modes for updating the entity:
+       *               - Merge: Updates an entity by updating the entity's properties without replacing the existing entity.
+       *               - Replace: Updates an existing entity by replacing the entire entity.
+       * @param options - The options parameters.
+       */
+      upsertEntity(entity, mode, options) {
+        this.checkPartitionKey(entity.partitionKey);
+        this.state.pendingOperations.push(this.interceptClient.upsertEntity(entity, mode, options));
+      }
+      /**
+       * Submits the operations in the transaction
+       */
+      async submitTransaction() {
+        await Promise.all(this.state.pendingOperations);
+        const body = getTransactionHttpRequestBody(this.state.bodyParts, this.state.transactionId, this.state.changesetId);
+        const headers = getTransactionHeaders(this.state.transactionId);
+        return tracingClient.withSpan("TableTransaction.submitTransaction", {}, async (updatedOptions) => {
+          const request = coreRestPipeline.createPipelineRequest({
+            url: this.url,
+            method: "POST",
+            body,
+            headers: coreRestPipeline.createHttpHeaders(headers),
+            tracingOptions: updatedOptions.tracingOptions,
+            allowInsecureConnection: this.allowInsecureConnection
+          });
+          const rawTransactionResponse = await this.client.sendRequest(request);
+          return parseTransactionResponse(rawTransactionResponse);
+        });
+      }
+      checkPartitionKey(partitionKey2) {
+        if (this.state.partitionKey !== partitionKey2) {
+          throw new Error("All operations in a transaction must target the same partitionKey");
+        }
+      }
+      getUrlWithSlash() {
+        return this.url.endsWith("/") ? this.url : `${this.url}/`;
+      }
+    };
+    __name(_InternalTableTransaction, "InternalTableTransaction");
+    var InternalTableTransaction = _InternalTableTransaction;
+    function parseTransactionResponse(transactionResponse) {
+      const subResponsePrefix = `--changesetresponse_`;
+      const status = transactionResponse.status;
+      const rawBody = transactionResponse.bodyAsText || "";
+      const splitBody = rawBody.split(subResponsePrefix);
+      const isSuccessByStatus = 200 <= status && status < 300;
+      if (!isSuccessByStatus) {
+        handleBodyError(rawBody, status, transactionResponse.request, transactionResponse);
+      }
+      const subResponses = splitBody.slice(1, splitBody.length - 1);
+      const responses = subResponses.map((subResponse) => {
+        const statusMatch = subResponse.match(/HTTP\/1.1 ([0-9]*)/);
+        if ((statusMatch === null || statusMatch === void 0 ? void 0 : statusMatch.length) !== 2) {
+          throw new Error(`Couldn't extract status from sub-response:
+ ${subResponse}`);
+        }
+        const subResponseStatus = Number.parseInt(statusMatch[1]);
+        if (!Number.isInteger(subResponseStatus)) {
+          throw new Error(`Expected sub-response status to be an integer ${subResponseStatus}`);
+        }
+        const bodyMatch = subResponse.match(/\{(.*)\}/);
+        if ((bodyMatch === null || bodyMatch === void 0 ? void 0 : bodyMatch.length) === 2) {
+          handleBodyError(bodyMatch[0], subResponseStatus, transactionResponse.request, transactionResponse);
+        }
+        const etagMatch = subResponse.match(/ETag: (.*)/);
+        const rowKeyMatch = subResponse.match(/RowKey='(.*)'/);
+        return Object.assign(Object.assign({ status: subResponseStatus }, (rowKeyMatch === null || rowKeyMatch === void 0 ? void 0 : rowKeyMatch.length) === 2 && { rowKey: rowKeyMatch[1] }), (etagMatch === null || etagMatch === void 0 ? void 0 : etagMatch.length) === 2 && { etag: etagMatch[1] });
+      });
+      return {
+        status,
+        subResponses: responses,
+        getResponseForEntity: /* @__PURE__ */ __name((rowKey2) => responses.find((r) => r.rowKey === rowKey2), "getResponseForEntity")
+      };
+    }
+    __name(parseTransactionResponse, "parseTransactionResponse");
+    function handleBodyError(bodyAsText, statusCode, request, response) {
+      var _a, _b;
+      let parsedError;
+      try {
+        parsedError = JSON.parse(bodyAsText);
+      } catch (_c) {
+        parsedError = {};
+      }
+      let message = "Transaction Failed";
+      let code;
+      if (parsedError && parsedError["odata.error"]) {
+        const error = parsedError["odata.error"];
+        message = (_b = (_a = error.message) === null || _a === void 0 ? void 0 : _a.value) !== null && _b !== void 0 ? _b : message;
+        code = error.code;
+      }
+      throw new coreRestPipeline.RestError(message, {
+        code,
+        statusCode,
+        request,
+        response
+      });
+    }
+    __name(handleBodyError, "handleBodyError");
+    function prepateTransactionPipeline(pipeline, bodyParts, changesetId, isCosmos) {
+      const policies = pipeline.getOrderedPolicies();
+      for (const policy of policies) {
+        pipeline.removePolicy({
+          name: policy.name
+        });
+      }
+      pipeline.addPolicy(coreClient.serializationPolicy(), { phase: "Serialize" });
+      pipeline.addPolicy(transactionHeaderFilterPolicy());
+      pipeline.addPolicy(transactionRequestAssemblePolicy(bodyParts, changesetId));
+      if (isCosmos) {
+        pipeline.addPolicy(cosmosPatchPolicy(), {
+          afterPolicies: [transactionHeaderFilterPolicyName],
+          beforePolicies: [coreClient.serializationPolicyName, transactionRequestAssemblePolicyName]
+        });
+      }
+    }
+    __name(prepateTransactionPipeline, "prepateTransactionPipeline");
+    function base64Encode(value) {
+      if (value instanceof Uint8Array) {
+        const bufferValue = value instanceof Buffer ? value : Buffer.from(value.buffer);
+        return bufferValue.toString("base64");
+      } else {
+        return Buffer.from(value).toString("base64");
+      }
+    }
+    __name(base64Encode, "base64Encode");
+    function base64Decode(value) {
+      return Buffer.from(value, "base64");
+    }
+    __name(base64Decode, "base64Decode");
+    function encodeContinuationToken(nextPartitionKey2, nextRowKey2) {
+      if (!nextPartitionKey2) {
+        return void 0;
+      }
+      const continuationToken = Object.assign({ nextPartitionKey: nextPartitionKey2 }, nextRowKey2 && { nextRowKey: nextRowKey2 });
+      return base64Encode(JSON.stringify(continuationToken));
+    }
+    __name(encodeContinuationToken, "encodeContinuationToken");
+    function decodeContinuationToken(encodedToken) {
+      const decodedToken = base64Decode(encodedToken);
+      let tokenStr = "";
+      for (const byte of decodedToken) {
+        tokenStr += String.fromCharCode(byte);
+      }
+      const continuationToken = JSON.parse(tokenStr);
+      return continuationToken;
+    }
+    __name(decodeContinuationToken, "decodeContinuationToken");
+    var propertyCaseMap = /* @__PURE__ */ new Map([
+      ["PartitionKey", "partitionKey"],
+      ["RowKey", "rowKey"],
+      ["odata.etag", "etag"],
+      ["Timestamp", "timestamp"]
+    ]);
+    var Edm = {
+      Binary: "Edm.Binary",
+      Boolean: "Edm.Boolean",
+      DateTime: "Edm.DateTime",
+      Double: "Edm.Double",
+      Guid: "Edm.Guid",
+      Int32: "Edm.Int32",
+      Int64: "Edm.Int64",
+      String: "Edm.String"
+    };
+    function serializePrimitive(value) {
+      const serializedValue = { value };
+      if (value === void 0 || value === null || typeof value === "boolean" || typeof value === "string" || typeof value === "number") {
+        serializedValue.value = value;
+      } else if (typeof value === "bigint") {
+        serializedValue.value = value.toString();
+        serializedValue.type = Edm.Int64;
+      } else if (value instanceof Date) {
+        serializedValue.value = value;
+        serializedValue.type = Edm.DateTime;
+      } else if (value instanceof Uint8Array) {
+        serializedValue.value = base64Encode(value);
+        serializedValue.type = Edm.Binary;
+      } else {
+        throw new Error(`Unknown EDM type ${typeof value}`);
+      }
+      return serializedValue;
+    }
+    __name(serializePrimitive, "serializePrimitive");
+    function serializeObject(obj) {
+      const serializedValue = { value: obj.value };
+      if (obj.type === "Boolean" || obj.type === "DateTime" || obj.type === "Double" || obj.type === "Guid" || obj.type === "Int32" || obj.type === "Int64" || obj.type === "String" || obj.type === "Binary") {
+        serializedValue.value = obj.value;
+        serializedValue.type = Edm[obj.type];
+      } else {
+        throw new Error(`Unknown EDM type ${typeof obj.value}`);
+      }
+      return serializedValue;
+    }
+    __name(serializeObject, "serializeObject");
+    function getSerializedValue(value) {
+      if (typeof value === "object" && (value === null || value === void 0 ? void 0 : value.value) !== void 0 && (value === null || value === void 0 ? void 0 : value.type) !== void 0) {
+        return serializeObject(value);
+      } else {
+        return serializePrimitive(value);
+      }
+    }
+    __name(getSerializedValue, "getSerializedValue");
+    function translatePropertyNameForSerialization(propertyName) {
+      for (const [original, internal] of propertyCaseMap) {
+        if (internal === propertyName) {
+          return original;
+        }
+      }
+      return propertyName;
+    }
+    __name(translatePropertyNameForSerialization, "translatePropertyNameForSerialization");
+    function serialize(obj) {
+      const serialized = {};
+      for (const [propertyName, propertyValue] of Object.entries(obj)) {
+        const transformedKey = translatePropertyNameForSerialization(propertyName);
+        const serializedVal = getSerializedValue(propertyValue);
+        serialized[transformedKey] = serializedVal.value;
+        if (serializedVal.type) {
+          serialized[`${transformedKey}@odata.type`] = serializedVal.type;
+        }
+      }
+      return serialized;
+    }
+    __name(serialize, "serialize");
+    function getTypedObject(value, type, disableTypeConversion) {
+      switch (type) {
+        case Edm.Boolean:
+          return disableTypeConversion ? { value, type: "Boolean" } : value;
+        case Edm.Double:
+          return disableTypeConversion ? { value, type: "Double" } : value;
+        case Edm.Int32:
+          return disableTypeConversion ? { value, type: "Int32" } : value;
+        case Edm.String:
+          return disableTypeConversion ? { value, type: "String" } : value;
+        case Edm.DateTime:
+          return disableTypeConversion ? { value, type: "DateTime" } : new Date(value);
+        case Edm.Int64:
+          return disableTypeConversion ? { value, type: "Int64" } : BigInt(value);
+        case Edm.Guid:
+          return { value, type: "Guid" };
+        case Edm.Binary:
+          return disableTypeConversion ? { value, type: "Binary" } : base64Decode(value);
+        default:
+          throw new Error(`Unknown EDM type ${type}`);
+      }
+    }
+    __name(getTypedObject, "getTypedObject");
+    function deserialize(obj, disableTypeConversion = false) {
+      var _a;
+      const deserialized = {};
+      for (const [key, value] of Object.entries(obj)) {
+        if (key.indexOf("@odata.type") === -1) {
+          const transformedKey = (_a = propertyCaseMap.get(key)) !== null && _a !== void 0 ? _a : key;
+          let typedValue = value;
+          if (`${key}@odata.type` in obj) {
+            const type = obj[`${key}@odata.type`];
+            typedValue = getTypedObject(value, type, disableTypeConversion);
+          } else if (disableTypeConversion && ["number", "string", "boolean"].includes(typeof value)) {
+            typedValue = inferTypedObject(key, value);
+          }
+          deserialized[transformedKey] = typedValue;
+        }
+      }
+      return deserialized;
+    }
+    __name(deserialize, "deserialize");
+    function inferTypedObject(propertyName, value) {
+      if (propertyCaseMap.has(propertyName)) {
+        return value;
+      }
+      switch (typeof value) {
+        case "boolean":
+          return { value: String(value), type: "Boolean" };
+        case "number":
+          return getTypedNumber(value);
+        case "string":
+          return { value, type: "String" };
+        default:
+          return value;
+      }
+    }
+    __name(inferTypedObject, "inferTypedObject");
+    function getTypedNumber(value) {
+      const valueStr = String(value);
+      if (Number.isSafeInteger(value)) {
+        return { value: valueStr, type: "Int32" };
+      } else {
+        return { value: valueStr, type: "Double" };
+      }
+    }
+    __name(getTypedNumber, "getTypedNumber");
+    function deserializeObjectsArray(objArray, disableTypeConversion) {
+      return objArray.map((obj) => deserialize(obj, disableTypeConversion));
+    }
+    __name(deserializeObjectsArray, "deserializeObjectsArray");
+    function serializeSignedIdentifiers(signedIdentifiers) {
+      return signedIdentifiers.map((acl) => {
+        const { id, accessPolicy } = acl;
+        const _a = accessPolicy !== null && accessPolicy !== void 0 ? accessPolicy : {}, { start, expiry } = _a, rest = tslib.__rest(_a, ["start", "expiry"]);
+        const serializedStart = start ? truncatedISO8061Date(
+          start,
+          false
+          /** withMilliseconds */
+        ) : void 0;
+        const serializedExpiry = expiry ? truncatedISO8061Date(
+          expiry,
+          false
+          /** withMilliseconds */
+        ) : void 0;
+        return {
+          id,
+          accessPolicy: Object.assign(Object.assign(Object.assign({}, serializedExpiry && { expiry: serializedExpiry }), serializedStart && { start: serializedStart }), rest)
+        };
+      });
+    }
+    __name(serializeSignedIdentifiers, "serializeSignedIdentifiers");
+    function deserializeSignedIdentifier(signedIdentifiers) {
+      return signedIdentifiers.map((si) => {
+        const { id, accessPolicy } = si;
+        const _a = accessPolicy !== null && accessPolicy !== void 0 ? accessPolicy : {}, { start, expiry } = _a, restAcl = tslib.__rest(_a, ["start", "expiry"]);
+        const deserializedStart = start ? new Date(start) : void 0;
+        const deserializedExpiry = expiry ? new Date(expiry) : void 0;
+        return {
+          id,
+          accessPolicy: Object.assign(Object.assign(Object.assign({}, deserializedExpiry && { expiry: deserializedExpiry }), deserializedStart && { start: deserializedStart }), restAcl)
+        };
+      });
+    }
+    __name(deserializeSignedIdentifier, "deserializeSignedIdentifier");
+    function serializeQueryOptions(query) {
+      const { select: select2 } = query, queryOptions = tslib.__rest(query, ["select"]);
+      const mappedQuery = Object.assign({}, queryOptions);
+      const excludeFromSelect = ["etag", "odata.etag"];
+      if (select2) {
+        mappedQuery.select = select2.filter((p) => !excludeFromSelect.includes(p)).map(translatePropertyNameForSerialization).join(",");
+      }
+      return mappedQuery;
+    }
+    __name(serializeQueryOptions, "serializeQueryOptions");
+    var _Uuid = class _Uuid {
+      static generateUuid() {
+        return coreUtil.randomUUID();
+      }
+    };
+    __name(_Uuid, "Uuid");
+    var Uuid = _Uuid;
+    function escapeQuotesIfString(input, previous) {
+      let result = input;
+      if (typeof input === "string") {
+        result = escapeQuotes(input);
+        if (previous !== "" && !previous.trim().endsWith("'")) {
+          result = `'${result}'`;
+        }
+      }
+      return result;
+    }
+    __name(escapeQuotesIfString, "escapeQuotesIfString");
+    function escapeQuotes(input) {
+      return input.replace(/'/g, "''");
+    }
+    __name(escapeQuotes, "escapeQuotes");
+    function encodeDate(input) {
+      return input instanceof Date ? `datetime'${input.toISOString()}'` : input;
+    }
+    __name(encodeDate, "encodeDate");
+    function odata(strings, ...values) {
+      const fixEncoding = /* @__PURE__ */ __name((value, string) => {
+        return encodeDate(escapeQuotesIfString(value, string));
+      }, "fixEncoding");
+      const results = [];
+      for (let i = 0; i < strings.length; i++) {
+        results.push(strings[i]);
+        if (i < values.length) {
+          results.push(fixEncoding(values[i], strings[i]));
+        }
+      }
+      return results.join("");
+    }
+    __name(odata, "odata");
+    var _TableClient = class _TableClient {
+      constructor(url2, tableName, credentialOrOptions, options = {}) {
+        var _a;
+        this.url = url2;
+        this.tableName = tableName;
+        const isCosmos = isCosmosEndpoint(this.url);
+        const credential = isCredential(credentialOrOptions) ? credentialOrOptions : void 0;
+        this.credential = credential;
+        this.clientOptions = (!isCredential(credentialOrOptions) ? credentialOrOptions : options) || {};
+        this.allowInsecureConnection = (_a = this.clientOptions.allowInsecureConnection) !== null && _a !== void 0 ? _a : false;
+        const internalPipelineOptions = Object.assign(Object.assign({}, this.clientOptions), { endpoint: this.clientOptions.endpoint || this.url, loggingOptions: {
+          logger: logger2.info,
+          additionalAllowedHeaderNames: [...TablesLoggingAllowedHeaderNames]
+        }, deserializationOptions: {
+          parseXML: coreXml.parseXML
+        }, serializationOptions: {
+          stringifyXML: coreXml.stringifyXML
+        } });
+        const generatedClient = new GeneratedClient(this.url, internalPipelineOptions);
+        if (coreAuth.isNamedKeyCredential(credential)) {
+          generatedClient.pipeline.addPolicy(tablesNamedKeyCredentialPolicy(credential));
+        } else if (coreAuth.isSASCredential(credential)) {
+          generatedClient.pipeline.addPolicy(tablesSASTokenPolicy(credential));
+        }
+        if (coreAuth.isTokenCredential(credential)) {
+          const scope = isCosmos ? COSMOS_SCOPE : STORAGE_SCOPE;
+          setTokenChallengeAuthenticationPolicy(generatedClient.pipeline, credential, scope);
+        }
+        if (isCosmos) {
+          generatedClient.pipeline.addPolicy(cosmosPatchPolicy());
+        }
+        if (options.version) {
+          generatedClient.pipeline.addPolicy(apiVersionPolicy(options.version));
+        }
+        this.generatedClient = generatedClient;
+        this.table = generatedClient.table;
+        this.pipeline = generatedClient.pipeline;
+      }
+      /**
+       * Permanently deletes the current table with all of its entities.
+       * @param options - The options parameters.
+       *
+       * ### Example deleting a table
+       * ```js
+       * const { AzureNamedKeyCredential, TableClient } = require("@azure/data-tables")
+       * const account = "<storage account name>";
+       * const accountKey = "<account key>"
+       * const tableName = "<table name>";
+       * const sharedKeyCredential = new AzureNamedKeyCredential(account, accountKey);
+       *
+       * const client = new TableClient(
+       *   `https://${account}.table.core.windows.net`,
+       *   `${tableName}`,
+       *   sharedKeyCredential
+       * );
+       *
+       * // calling deleteTable will delete the table used
+       * // to instantiate the TableClient.
+       * // Note: If the table doesn't exist this function doesn't fail.
+       * await client.deleteTable();
+       * ```
+       */
+      // eslint-disable-next-line @azure/azure-sdk/ts-naming-options
+      deleteTable(options = {}) {
+        return tracingClient.withSpan("TableClient.deleteTable", options, async (updatedOptions) => {
+          try {
+            await this.table.delete(this.tableName, updatedOptions);
+          } catch (e) {
+            if (e.statusCode === 404) {
+              logger2.info("TableClient.deleteTable: Table doesn't exist");
+            } else {
+              throw e;
+            }
+          }
+        });
+      }
+      /**
+       *  Creates a table with the tableName passed to the client constructor
+       * @param options - The options parameters.
+       *
+       * ### Example creating a table
+       * ```js
+       * const { AzureNamedKeyCredential, TableClient } = require("@azure/data-tables")
+       * const account = "<storage account name>";
+       * const accountKey = "<account key>"
+       * const tableName = "<table name>";
+       * const sharedKeyCredential = new AzureNamedKeyCredential(account, accountKey);
+       *
+       * const client = new TableClient(
+       *   `https://${account}.table.core.windows.net`,
+       *   `${tableName}`,
+       *   sharedKeyCredential
+       * );
+       *
+       * // calling create table will create the table used
+       * // to instantiate the TableClient.
+       * // Note: If the table already
+       * // exists this function doesn't throw.
+       * await client.createTable();
+       * ```
+       */
+      // eslint-disable-next-line @azure/azure-sdk/ts-naming-options
+      createTable(options = {}) {
+        return tracingClient.withSpan("TableClient.createTable", options, async (updatedOptions) => {
+          try {
+            await this.table.create({ name: this.tableName }, updatedOptions);
+          } catch (e) {
+            handleTableAlreadyExists(e, Object.assign(Object.assign({}, updatedOptions), { logger: logger2, tableName: this.tableName }));
+          }
+        });
+      }
+      /**
+       * Returns a single entity in the table.
+       * @param partitionKey - The partition key of the entity.
+       * @param rowKey - The row key of the entity.
+       * @param options - The options parameters.
+       *
+       * ### Example getting an entity
+       * ```js
+       * const { AzureNamedKeyCredential, TableClient } = require("@azure/data-tables")
+       * const account = "<storage account name>";
+       * const accountKey = "<account key>"
+       * const tableName = "<table name>";
+       * const sharedKeyCredential = new AzureNamedKeyCredential(account, accountKey);
+       *
+       * const client = new TableClient(
+       *   `https://${account}.table.core.windows.net`,
+       *   `${tableName}`,
+       *   sharedKeyCredential
+       * );
+       *
+       * // getEntity will get a single entity stored in the service that
+       * // matches exactly the partitionKey and rowKey used as parameters
+       * // to the method.
+       * const entity = await client.getEntity("<partitionKey>", "<rowKey>");
+       * console.log(entity);
+       * ```
+       */
+      getEntity(partitionKey2, rowKey2, options = {}) {
+        return tracingClient.withSpan("TableClient.getEntity", options, async (updatedOptions) => {
+          let parsedBody;
+          function onResponse(rawResponse, flatResponse) {
+            parsedBody = rawResponse.parsedBody;
+            if (updatedOptions.onResponse) {
+              updatedOptions.onResponse(rawResponse, flatResponse);
+            }
+          }
+          __name(onResponse, "onResponse");
+          const { disableTypeConversion, queryOptions } = updatedOptions, getEntityOptions = tslib.__rest(updatedOptions, ["disableTypeConversion", "queryOptions"]);
+          await this.table.queryEntitiesWithPartitionAndRowKey(this.tableName, escapeQuotes(partitionKey2), escapeQuotes(rowKey2), Object.assign(Object.assign({}, getEntityOptions), { queryOptions: serializeQueryOptions(queryOptions || {}), onResponse }));
+          const tableEntity = deserialize(parsedBody, disableTypeConversion !== null && disableTypeConversion !== void 0 ? disableTypeConversion : false);
+          return tableEntity;
+        });
+      }
+      /**
+       * Queries entities in a table.
+       * @param options - The options parameters.
+       *
+       * Example listing entities
+       * ```js
+       * const { AzureNamedKeyCredential, TableClient } = require("@azure/data-tables")
+       * const account = "<storage account name>";
+       * const accountKey = "<account key>"
+       * const tableName = "<table name>";
+       * const sharedKeyCredential = new AzureNamedKeyCredential(account, accountKey);
+       *
+       * const client = new TableClient(
+       *   `https://${account}.table.core.windows.net`,
+       *   `${tableName}`,
+       *   sharedKeyCredential
+       * );
+       *
+       * // list entities returns a AsyncIterableIterator
+       * // this helps consuming paginated responses by
+       * // automatically handling getting the next pages
+       * const entities = client.listEntities();
+       *
+       * // this loop will get all the entities from all the pages
+       * // returned by the service
+       * for await (const entity of entities) {
+       *    console.log(entity);
+       * }
+       * ```
+       */
+      listEntities(options = {}) {
+        const tableName = this.tableName;
+        const iter = this.listEntitiesAll(tableName, options);
+        return {
+          next() {
+            return iter.next();
+          },
+          [Symbol.asyncIterator]() {
+            return this;
+          },
+          byPage: /* @__PURE__ */ __name((settings) => {
+            const pageOptions = Object.assign(Object.assign({}, options), { queryOptions: Object.assign(Object.assign({}, options.queryOptions), { top: settings === null || settings === void 0 ? void 0 : settings.maxPageSize }) });
+            if (settings === null || settings === void 0 ? void 0 : settings.continuationToken) {
+              pageOptions.continuationToken = settings.continuationToken;
+            }
+            return this.listEntitiesPage(tableName, pageOptions);
+          }, "byPage")
+        };
+      }
+      listEntitiesAll(tableName, options) {
+        return tslib.__asyncGenerator(this, arguments, /* @__PURE__ */ __name(function* listEntitiesAll_1() {
+          var _a, e_1, _b, _c;
+          const firstPage = yield tslib.__await(this._listEntities(tableName, options));
+          yield tslib.__await(yield* tslib.__asyncDelegator(tslib.__asyncValues(firstPage)));
+          if (firstPage.continuationToken) {
+            const optionsWithContinuation = Object.assign(Object.assign({}, options), { continuationToken: firstPage.continuationToken });
+            try {
+              for (var _d = true, _e = tslib.__asyncValues(this.listEntitiesPage(tableName, optionsWithContinuation)), _f; _f = yield tslib.__await(_e.next()), _a = _f.done, !_a; _d = true) {
+                _c = _f.value;
+                _d = false;
+                const page = _c;
+                yield tslib.__await(yield* tslib.__asyncDelegator(tslib.__asyncValues(page)));
+              }
+            } catch (e_1_1) {
+              e_1 = { error: e_1_1 };
+            } finally {
+              try {
+                if (!_d && !_a && (_b = _e.return)) yield tslib.__await(_b.call(_e));
+              } finally {
+                if (e_1) throw e_1.error;
+              }
+            }
+          }
+        }, "listEntitiesAll_1"));
+      }
+      listEntitiesPage(tableName_1) {
+        return tslib.__asyncGenerator(this, arguments, /* @__PURE__ */ __name(function* listEntitiesPage_1(tableName, options = {}) {
+          let result = yield tslib.__await(tracingClient.withSpan("TableClient.listEntitiesPage", options, (updatedOptions) => this._listEntities(tableName, updatedOptions)));
+          yield yield tslib.__await(result);
+          while (result.continuationToken) {
+            const optionsWithContinuation = Object.assign(Object.assign({}, options), { continuationToken: result.continuationToken });
+            result = yield tslib.__await(tracingClient.withSpan("TableClient.listEntitiesPage", optionsWithContinuation, (updatedOptions, span) => {
+              span.setAttribute("continuationToken", result.continuationToken);
+              return this._listEntities(tableName, updatedOptions);
+            }));
+            yield yield tslib.__await(result);
+          }
+        }, "listEntitiesPage_1"));
+      }
+      async _listEntities(tableName, options = {}) {
+        const { disableTypeConversion = false } = options;
+        const queryOptions = serializeQueryOptions(options.queryOptions || {});
+        const listEntitiesOptions = Object.assign(Object.assign({}, options), { queryOptions });
+        if (options.continuationToken) {
+          const continuationToken2 = decodeContinuationToken(options.continuationToken);
+          listEntitiesOptions.nextRowKey = continuationToken2.nextRowKey;
+          listEntitiesOptions.nextPartitionKey = continuationToken2.nextPartitionKey;
+        }
+        const { xMsContinuationNextPartitionKey: nextPartitionKey2, xMsContinuationNextRowKey: nextRowKey2, value } = await this.table.queryEntities(tableName, listEntitiesOptions);
+        const tableEntities = deserializeObjectsArray(value !== null && value !== void 0 ? value : [], disableTypeConversion);
+        const continuationToken = encodeContinuationToken(nextPartitionKey2, nextRowKey2);
+        const page = Object.assign([...tableEntities], {
+          continuationToken
+        });
+        return page;
+      }
+      /**
+       * Insert entity in the table.
+       * @param entity - The properties for the table entity.
+       * @param options - The options parameters.
+       *
+       * ### Example creating an entity
+       * ```js
+       * const { AzureNamedKeyCredential, TableClient } = require("@azure/data-tables")
+       * const account = "<storage account name>";
+       * const accountKey = "<account key>"
+       * const tableName = "<table name>";
+       * const sharedKeyCredential = new AzureNamedKeyCredential(account, accountKey);
+       *
+       * const client = new TableClient(
+       *   `https://${account}.table.core.windows.net`,
+       *   `${tableName}`,
+       *   sharedKeyCredential
+       * );
+       *
+       * // partitionKey and rowKey are required properties of the entity to create
+       * // and accepts any other properties
+       * await client.createEntity({partitionKey: "p1", rowKey: "r1", foo: "Hello!"});
+       * ```
+       */
+      createEntity(entity, options = {}) {
+        return tracingClient.withSpan("TableClient.createEntity", options, (updatedOptions) => {
+          const createTableEntity = tslib.__rest(updatedOptions || {}, []);
+          return this.table.insertEntity(this.tableName, Object.assign(Object.assign({}, createTableEntity), { tableEntityProperties: serialize(entity), responsePreference: "return-no-content" }));
+        });
+      }
+      /**
+       * Deletes the specified entity in the table.
+       * @param partitionKey - The partition key of the entity.
+       * @param rowKey - The row key of the entity.
+       * @param options - The options parameters.
+       *
+       * ### Example deleting an entity
+       * ```js
+       * const { AzureNamedKeyCredential, TableClient } = require("@azure/data-tables")
+       * const account = "<storage account name>";
+       * const accountKey = "<account key>"
+       * const tableName = "<table name>";
+       * const sharedKeyCredential = new AzureNamedKeyCredential(account, accountKey);
+       *
+       * const client = new TableClient(
+       *   `https://${account}.table.core.windows.net`,
+       *   `${tableName}`,
+       *   sharedKeyCredential
+       * );
+       *
+       * // deleteEntity deletes the entity that matches
+       * // exactly the partitionKey and rowKey passed as parameters
+       * await client.deleteEntity("<partitionKey>", "<rowKey>")
+       * ```
+       */
+      deleteEntity(partitionKey2, rowKey2, options = {}) {
+        return tracingClient.withSpan("TableClient.deleteEntity", options, (updatedOptions) => {
+          const { etag = "*" } = updatedOptions, rest = tslib.__rest(updatedOptions, ["etag"]);
+          const deleteOptions = Object.assign({}, rest);
+          return this.table.deleteEntity(this.tableName, escapeQuotes(partitionKey2), escapeQuotes(rowKey2), etag, deleteOptions);
+        });
+      }
+      /**
+       * Update an entity in the table.
+       * @param entity - The properties of the entity to be updated.
+       * @param mode - The different modes for updating the entity:
+       *               - Merge: Updates an entity by updating the entity's properties without replacing the existing entity.
+       *               - Replace: Updates an existing entity by replacing the entire entity.
+       * @param options - The options parameters.
+       *
+       * ### Example updating an entity
+       * ```js
+       * const { AzureNamedKeyCredential, TableClient } = require("@azure/data-tables")
+       * const account = "<storage account name>";
+       * const accountKey = "<account key>"
+       * const tableName = "<table name>";
+       * const sharedKeyCredential = new AzureNamedKeyCredential(account, accountKey);
+       *
+       * const client = new TableClient(
+       *   `https://${account}.table.core.windows.net`,
+       *   `${tableName}`,
+       *   sharedKeyCredential
+       * );
+       *
+       * const entity = {partitionKey: "p1", rowKey: "r1", bar: "updatedBar"};
+       *
+       * // Update uses update mode "Merge" as default
+       * // merge means that update will match a stored entity
+       * // that has the same partitionKey and rowKey as the entity
+       * // passed to the method and then will only update the properties present in it.
+       * // Any other properties that are not defined in the entity passed to updateEntity
+       * // will remain as they are in the service
+       * await client.updateEntity(entity)
+       *
+       * // We can also set the update mode to Replace, which will match the entity passed
+       * // to updateEntity with one stored in the service and replace with the new one.
+       * // If there are any missing properties in the entity passed to updateEntity, they
+       * // will be removed from the entity stored in the service
+       * await client.updateEntity(entity, "Replace")
+       * ```
+       */
+      updateEntity(entity, mode = "Merge", options = {}) {
+        return tracingClient.withSpan("TableClient.updateEntity", options, async (updatedOptions) => {
+          const partitionKey2 = escapeQuotes(entity.partitionKey);
+          const rowKey2 = escapeQuotes(entity.rowKey);
+          const _a = updatedOptions || {}, { etag = "*" } = _a, updateEntityOptions = tslib.__rest(_a, ["etag"]);
+          if (mode === "Merge") {
+            return this.table.mergeEntity(this.tableName, partitionKey2, rowKey2, Object.assign({ tableEntityProperties: serialize(entity), ifMatch: etag }, updateEntityOptions));
+          }
+          if (mode === "Replace") {
+            return this.table.updateEntity(this.tableName, partitionKey2, rowKey2, Object.assign({ tableEntityProperties: serialize(entity), ifMatch: etag }, updateEntityOptions));
+          }
+          throw new Error(`Unexpected value for update mode: ${mode}`);
+        }, {
+          spanAttributes: {
+            updateEntityMode: mode
+          }
+        });
+      }
+      /**
+       * Upsert an entity in the table.
+       * @param entity - The properties for the table entity.
+       * @param mode - The different modes for updating the entity:
+       *               - Merge: Updates an entity by updating the entity's properties without replacing the existing entity.
+       *               - Replace: Updates an existing entity by replacing the entire entity.
+       * @param options - The options parameters.
+       *
+       * ### Example upserting an entity
+       * ```js
+       * const { AzureNamedKeyCredential, TableClient } = require("@azure/data-tables")
+       * const account = "<storage account name>";
+       * const accountKey = "<account key>"
+       * const tableName = "<table name>";
+       * const sharedKeyCredential = new AzureNamedKeyCredential(account, accountKey);
+       *
+       * const client = new TableClient(
+       *   `https://${account}.table.core.windows.net`,
+       *   `${tableName}`,
+       *   sharedKeyCredential
+       * );
+       *
+       * const entity = {partitionKey: "p1", rowKey: "r1", bar: "updatedBar"};
+       *
+       * // Upsert uses update mode "Merge" as default.
+       * // This behaves similarly to update but creates the entity
+       * // if it doesn't exist in the service
+       * await client.upsertEntity(entity)
+       *
+       * // We can also set the update mode to Replace.
+       * // This behaves similarly to update but creates the entity
+       * // if it doesn't exist in the service
+       * await client.upsertEntity(entity, "Replace")
+       * ```
+       */
+      upsertEntity(entity, mode = "Merge", options = {}) {
+        return tracingClient.withSpan("TableClient.upsertEntity", options, async (updatedOptions) => {
+          const partitionKey2 = escapeQuotes(entity.partitionKey);
+          const rowKey2 = escapeQuotes(entity.rowKey);
+          if (mode === "Merge") {
+            return this.table.mergeEntity(this.tableName, partitionKey2, rowKey2, Object.assign({ tableEntityProperties: serialize(entity) }, updatedOptions));
+          }
+          if (mode === "Replace") {
+            return this.table.updateEntity(this.tableName, partitionKey2, rowKey2, Object.assign({ tableEntityProperties: serialize(entity) }, updatedOptions));
+          }
+          throw new Error(`Unexpected value for update mode: ${mode}`);
+        }, {
+          spanAttributes: {
+            upsertEntityMode: mode
+          }
+        });
+      }
+      /**
+       * Retrieves details about any stored access policies specified on the table that may be used with
+       * Shared Access Signatures.
+       * @param options - The options parameters.
+       */
+      // eslint-disable-next-line @azure/azure-sdk/ts-naming-options
+      getAccessPolicy(options = {}) {
+        return tracingClient.withSpan("TableClient.getAccessPolicy", options, async (updatedOptions) => {
+          const signedIdentifiers = await this.table.getAccessPolicy(this.tableName, updatedOptions);
+          return deserializeSignedIdentifier(signedIdentifiers);
+        });
+      }
+      /**
+       * Sets stored access policies for the table that may be used with Shared Access Signatures.
+       * @param tableAcl - The Access Control List for the table.
+       * @param options - The options parameters.
+       */
+      setAccessPolicy(tableAcl2, options = {}) {
+        return tracingClient.withSpan("TableClient.setAccessPolicy", options, (updatedOptions) => {
+          const serlializedAcl = serializeSignedIdentifiers(tableAcl2);
+          return this.table.setAccessPolicy(this.tableName, Object.assign(Object.assign({}, updatedOptions), { tableAcl: serlializedAcl }));
+        });
+      }
+      /**
+       * Submits a Transaction which is composed of a set of actions. You can provide the actions as a list
+       * or you can use {@link TableTransaction} to help building the transaction.
+       *
+       * Example usage:
+       * ```typescript
+       * const { TableClient } = require("@azure/data-tables");
+       * const connectionString = "<connection-string>"
+       * const tableName = "<tableName>"
+       * const client = TableClient.fromConnectionString(connectionString, tableName);
+       * const actions = [
+       *    ["create", {partitionKey: "p1", rowKey: "1", data: "test1"}],
+       *    ["delete", {partitionKey: "p1", rowKey: "2"}],
+       *    ["update", {partitionKey: "p1", rowKey: "3", data: "newTest"}, "Merge"]
+       * ]
+       * const result = await client.submitTransaction(actions);
+       * ```
+       *
+       * Example usage with TableTransaction:
+       * ```js
+       * const { TableClient } = require("@azure/data-tables");
+       * const connectionString = "<connection-string>"
+       * const tableName = "<tableName>"
+       * const client = TableClient.fromConnectionString(connectionString, tableName);
+       * const transaction = new TableTransaction();
+       * // Call the available action in the TableTransaction object
+       * transaction.create({partitionKey: "p1", rowKey: "1", data: "test1"});
+       * transaction.delete("p1", "2");
+       * transaction.update({partitionKey: "p1", rowKey: "3", data: "newTest"}, "Merge")
+       * // submitTransaction with the actions list on the transaction.
+       * const result = await client.submitTransaction(transaction.actions);
+       * ```
+       *
+       * @param actions - tuple that contains the action to perform, and the entity to perform the action with
+       */
+      async submitTransaction(actions) {
+        const partitionKey2 = actions[0][1].partitionKey;
+        const transactionId = Uuid.generateUuid();
+        const changesetId = Uuid.generateUuid();
+        const transactionClient = new InternalTableTransaction(this.url, partitionKey2, transactionId, changesetId, this.generatedClient, new _TableClient(this.url, this.tableName), this.credential, this.allowInsecureConnection);
+        for (const item of actions) {
+          const [action, entity, updateMode = "Merge", updateOptions] = item;
+          switch (action) {
+            case "create":
+              transactionClient.createEntity(entity);
+              break;
+            case "delete":
+              transactionClient.deleteEntity(entity.partitionKey, entity.rowKey);
+              break;
+            case "update":
+              transactionClient.updateEntity(entity, updateMode, updateOptions);
+              break;
+            case "upsert":
+              transactionClient.upsertEntity(entity, updateMode);
+          }
+        }
+        return transactionClient.submitTransaction();
+      }
+      /**
+       *
+       * Creates an instance of TableClient from connection string.
+       *
+       * @param connectionString - Account connection string or a SAS connection string of an Azure storage account.
+       *                           [ Note - Account connection string can only be used in NODE.JS runtime. ]
+       *                           Account connection string example -
+       *                           `DefaultEndpointsProtocol=https;AccountName=myaccount;AccountKey=accountKey;EndpointSuffix=core.windows.net`
+       *                           SAS connection string example -
+       *                           `BlobEndpoint=https://myaccount.table.core.windows.net/;QueueEndpoint=https://myaccount.queue.core.windows.net/;FileEndpoint=https://myaccount.file.core.windows.net/;TableEndpoint=https://myaccount.table.core.windows.net/;SharedAccessSignature=sasString`
+       * @param options - Options to configure the HTTP pipeline.
+       * @returns A new TableClient from the given connection string.
+       */
+      static fromConnectionString(connectionString, tableName, options) {
+        const { url: url2, options: clientOptions, credential } = getClientParamsFromConnectionString(connectionString, options);
+        if (credential) {
+          return new _TableClient(url2, tableName, credential, clientOptions);
+        } else {
+          return new _TableClient(url2, tableName, clientOptions);
+        }
+      }
+    };
+    __name(_TableClient, "TableClient");
+    var TableClient2 = _TableClient;
+    Object.defineProperty(exports, "AzureNamedKeyCredential", {
+      enumerable: true,
+      get: /* @__PURE__ */ __name(function() {
+        return coreAuth.AzureNamedKeyCredential;
+      }, "get")
+    });
+    Object.defineProperty(exports, "AzureSASCredential", {
+      enumerable: true,
+      get: /* @__PURE__ */ __name(function() {
+        return coreAuth.AzureSASCredential;
+      }, "get")
+    });
+    Object.defineProperty(exports, "RestError", {
+      enumerable: true,
+      get: /* @__PURE__ */ __name(function() {
+        return coreRestPipeline.RestError;
+      }, "get")
+    });
+    exports.TableClient = TableClient2;
+    exports.TableServiceClient = TableServiceClient;
+    exports.TableTransaction = TableTransaction;
+    exports.generateAccountSas = generateAccountSas;
+    exports.generateTableSas = generateTableSas;
+    exports.odata = odata;
+  }
+});
+
 // src/registerAzureLogger.ts
 import EventEmitter from "events";
 var logger = require_commonjs();
@@ -99,11 +4756,15 @@ var blockListIsInvalidRetryPolicy = {
 // src/createRemoteCacheClient.ts
 import { RetryManager } from "@ms-cloudpack/retry";
 
-// src/createBlobStorageUrl.ts
+// src/createStorageUrl.ts
 function createBlobStorageUrl(storageAccount) {
   return `https://${storageAccount}.blob.core.windows.net`;
 }
 __name(createBlobStorageUrl, "createBlobStorageUrl");
+function createTableStorageUrl(storageAccount) {
+  return `https://${storageAccount}.table.core.windows.net`;
+}
+__name(createTableStorageUrl, "createTableStorageUrl");
 
 // src/createRemoteCacheClient.ts
 var import_storage_blob = __toESM(require_dist(), 1);
@@ -111,8 +4772,8 @@ async function createRemoteCacheClient(params) {
   const azureLogEventHandler = registerAzureLogger();
   const { context, options } = params;
   const { container, loginMethod, storageAccount, cachePath, tenantId } = options;
-  const { getCredential } = await import("./getCredential-GVAO2BWN.js");
-  const { AzureRemoteCacheClient } = await import("./AzureRemoteCacheClient-GTJWKYFP.js");
+  const { getCredential } = await import("./getCredential-OSAAVWZC.js");
+  const { AzureRemoteCacheClient } = await import("./AzureRemoteCacheClient-AY675HJK.js");
   const { ReporterDecorator } = await import("./ReporterDecorator-VYNWC6CL.js");
   const { getListOfBlobs } = await import("./getListOfBlobs-EY2E5AZT.js");
   const credential = await getCredential(
@@ -135,6 +4796,143 @@ async function createRemoteCacheClient(params) {
   return client;
 }
 __name(createRemoteCacheClient, "createRemoteCacheClient");
+
+// src/AzureAppRegistryClient.ts
+var import_data_tables = __toESM(require_dist2(), 1);
+
+// src/utils/safeEncodeURIComponent.ts
+function safeEncodeURIComponent(value) {
+  try {
+    return decodeURIComponent(value) !== value ? value : encodeURIComponent(value);
+  } catch (e) {
+    return encodeURIComponent(value);
+  }
+}
+__name(safeEncodeURIComponent, "safeEncodeURIComponent");
+
+// src/utils/safeDecodeURIComponent.ts
+function safeDecodeURIComponent(value) {
+  try {
+    return encodeURIComponent(decodeURIComponent(value)) === value ? decodeURIComponent(value) : value;
+  } catch (e) {
+    return value;
+  }
+}
+__name(safeDecodeURIComponent, "safeDecodeURIComponent");
+
+// src/utils/getReverseSortedTimestamp.ts
+function getReverseSortedTimestamp() {
+  const maxTimestamp = 9999999999999;
+  const currentTimestamp = Math.floor(Date.now() / 1e3);
+  const reverseTimestamp = maxTimestamp - currentTimestamp;
+  return reverseTimestamp.toString().padStart(13, "0");
+}
+__name(getReverseSortedTimestamp, "getReverseSortedTimestamp");
+
+// src/AzureAppRegistryClient.ts
+var _AzureAppRegistryClient = class _AzureAppRegistryClient {
+  constructor(storageUrl, credential) {
+    this.storageUrl = storageUrl;
+    this.credential = credential;
+    this.appsTableClient = new import_data_tables.TableClient(storageUrl, "apps", credential);
+    this.appVersionsTableClient = new import_data_tables.TableClient(storageUrl, "appVersions", credential);
+  }
+  /**
+   * Registers an application and its version details in the table storage.
+   */
+  async registerApp({
+    name,
+    version,
+    description,
+    ...rest
+  }) {
+    await Promise.all([
+      // Register the app
+      this.appsTableClient.upsertEntity(
+        {
+          partitionKey: "apps",
+          rowKey: safeEncodeURIComponent(name),
+          latestVersion: safeDecodeURIComponent(version),
+          description
+        },
+        "Replace"
+      ),
+      // Register the app version details
+      this.appVersionsTableClient.upsertEntity(
+        {
+          partitionKey: safeEncodeURIComponent(name),
+          // Using a reverse-sorted timestamp as the RowKey ensures newer items appear first,
+          // since Azure Table Storage only sorts by PartitionKey/RowKey and lacks custom ordering capabilities.
+          rowKey: safeEncodeURIComponent(getReverseSortedTimestamp()),
+          ...rest,
+          version
+        },
+        "Replace"
+      )
+    ]);
+  }
+  async getApps(appName, pageSettings) {
+    const pages = this.appsTableClient.listEntities({
+      queryOptions: appName ? {
+        filter: `RowKey eq '${safeEncodeURIComponent(appName)}'`
+      } : void 0
+    }).byPage(pageSettings);
+    const pageResult = await pages.next();
+    if (pageResult.done || !pageResult.value) {
+      return { items: [] };
+    }
+    const items = pageResult.value;
+    const continuationToken = pageResult.value.continuationToken;
+    return {
+      items: items.map(({ partitionKey, rowKey, ...rest }) => ({
+        ...rest,
+        name: safeDecodeURIComponent(rowKey)
+      })),
+      continuationToken
+    };
+  }
+  async getVersions(appName, pageSettings) {
+    const pages = this.appVersionsTableClient.listEntities({
+      queryOptions: {
+        filter: `PartitionKey eq '${safeEncodeURIComponent(appName)}'`
+      }
+    }).byPage(pageSettings);
+    const pageResult = await pages.next();
+    if (pageResult.done || !pageResult.value) {
+      return { items: [] };
+    }
+    const items = pageResult.value;
+    const continuationToken = pageResult.value.continuationToken;
+    return {
+      items: items.map(({ partitionKey, ...rest }) => ({
+        name: safeDecodeURIComponent(partitionKey),
+        ...rest
+      })),
+      continuationToken
+    };
+  }
+};
+__name(_AzureAppRegistryClient, "AzureAppRegistryClient");
+var AzureAppRegistryClient = _AzureAppRegistryClient;
+
+// src/createAppRegistryClient.ts
+var defaultTenantId = "72f988bf-86f1-41af-91ab-2d7cd011db47";
+var defaultStorageAccount = "cloudpackstorage";
+async function createAppRegistryClient(params) {
+  const { context, options } = params;
+  const { loginMethod, cachePath, tenantId = defaultTenantId, storageAccount = defaultStorageAccount } = options;
+  const azureLogEventHandler = registerAzureLogger();
+  const { getCredential } = await import("./getCredential-OSAAVWZC.js");
+  const credential = await getCredential(
+    { loginMethod, cachePath, tenantId },
+    { ...context, azureLogger: azureLogEventHandler }
+  );
+  const url = createTableStorageUrl(storageAccount);
+  const client = new AzureAppRegistryClient(url, credential);
+  return client;
+}
+__name(createAppRegistryClient, "createAppRegistryClient");
 export {
+  createAppRegistryClient,
   createRemoteCacheClient
 };