@monolayer/sdk 1.2.5 → 1.3.0-canary.2

package/dist/bin/esm-ID5USS7G.js

@@ -0,0 +1,4773 @@
+import { createRequire } from 'module';
+import { ENV_KEY as ENV_KEY$1, ENV_SECRET as ENV_SECRET$1, fromEnv as fromEnv$1 } from './chunk-UKX3KEC2.js';
+import { parseJsonBody as parseJsonBody$1, parseJsonErrorBody as parseJsonErrorBody$1, loadRestJsonErrorCode as loadRestJsonErrorCode$1 } from './chunk-2DM36AIF.js';
+import { awsEndpointFunctions as awsEndpointFunctions$1, resolveUserAgentConfig as resolveUserAgentConfig$1, resolveHostHeaderConfig as resolveHostHeaderConfig$1, getUserAgentPlugin as getUserAgentPlugin$1, getHostHeaderPlugin as getHostHeaderPlugin$1, getLoggerPlugin as getLoggerPlugin$1, getRecursionDetectionPlugin as getRecursionDetectionPlugin$1, emitWarningIfUnsupportedVersion as emitWarningIfUnsupportedVersion$2, NODE_APP_ID_CONFIG_OPTIONS as NODE_APP_ID_CONFIG_OPTIONS$1, createDefaultUserAgentProvider as createDefaultUserAgentProvider$1, NODE_AUTH_SCHEME_PREFERENCE_OPTIONS, resolveAwsSdkSigV4Config as resolveAwsSdkSigV4Config$1, getAwsRegionExtensionConfiguration as getAwsRegionExtensionConfiguration$1, resolveAwsRegionExtensionConfiguration as resolveAwsRegionExtensionConfiguration$1, AwsSdkSigV4Signer as AwsSdkSigV4Signer$1 } from './chunk-KHQQRHZY.js';
+import './chunk-KW25ZB6Z.js';
+import { ENV_KEY, ENV_SECRET, fromEnv } from './chunk-ASIK3ESJ.js';
+import { parseJsonBody, parseJsonErrorBody, loadRestJsonErrorCode } from './chunk-GE4ESXBP.js';
+import { awsEndpointFunctions, resolveUserAgentConfig, resolveHostHeaderConfig, getUserAgentPlugin, getHostHeaderPlugin, getLoggerPlugin, getRecursionDetectionPlugin, emitWarningIfUnsupportedVersion as emitWarningIfUnsupportedVersion$1, NODE_APP_ID_CONFIG_OPTIONS, createDefaultUserAgentProvider, resolveAwsSdkSigV4Config, getAwsRegionExtensionConfiguration, resolveAwsRegionExtensionConfiguration, AwsSdkSigV4Signer } from './chunk-KSHJCBUY.js';
+import { EndpointCache, customEndpointFunctions, getSerdePlugin, getEndpointPlugin, createPaginator, resolveRetryConfig, resolveRegionConfig, resolveEndpointConfig, getRetryPlugin, getContentLengthPlugin, getHttpAuthSchemeEndpointRuleSetPlugin, DefaultIdentityProviderConfig, getHttpSigningPlugin, resolveDefaultsModeConfig, calculateBodyLength, NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS, NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS, Hash, DEFAULT_RETRY_MODE, NODE_RETRY_MODE_CONFIG_OPTIONS, NODE_REGION_CONFIG_OPTIONS, NODE_REGION_CONFIG_FILE_OPTIONS, NODE_MAX_ATTEMPT_CONFIG_OPTIONS, normalizeProvider, getSmithyContext, resolveEndpoint } from './chunk-AKHG66MJ.js';
+import { loadConfig, parseUrl } from './chunk-3TV5KLB7.js';
+import { withBaseException, Command, ServiceException, collectBody, _json, Client, take, HttpRequest, toUint8Array, toHex, emitWarningIfUnsupportedVersion, streamCollector, NodeHttpHandler, getDefaultExtensionConfiguration, getHttpHandlerExtensionConfiguration, resolveDefaultRuntimeConfig, resolveHttpHandlerRuntimeConfig, expectInt32, decorateServiceException, toUtf8, fromUtf8, NoOpLogger, toBase64, fromBase64, loadConfigsForDefaultMode, limitedParseDouble, expectString, expectBoolean, expectUnion } from './chunk-U43L2J36.js';
+import { ENV_PROFILE } from './chunk-X7GJVU6X.js';
+import './chunk-AV7FB56K.js';
+import './chunk-D6MRFOU6.js';
+import { memoize, chain, CredentialsProviderError } from './chunk-54HDPH52.js';
+import { __commonJS, __toESM } from './chunk-DQ2PXUF5.js';
+import { randomUUID } from 'node:crypto';
+
+createRequire(import.meta.url);
+
+// ../../node_modules/obliterator/iterator.js
+var require_iterator = __commonJS({
+  "../../node_modules/obliterator/iterator.js"(exports$1, module) {
+    function Iterator(next) {
+      Object.defineProperty(this, "_next", {
+        writable: false,
+        enumerable: false,
+        value: next
+      });
+      this.done = false;
+    }
+    Iterator.prototype.next = function() {
+      if (this.done)
+        return { done: true };
+      var step = this._next();
+      if (step.done)
+        this.done = true;
+      return step;
+    };
+    if (typeof Symbol !== "undefined")
+      Iterator.prototype[Symbol.iterator] = function() {
+        return this;
+      };
+    Iterator.of = function() {
+      var args = arguments, l3 = args.length, i3 = 0;
+      return new Iterator(function() {
+        if (i3 >= l3)
+          return { done: true };
+        return { done: false, value: args[i3++] };
+      });
+    };
+    Iterator.empty = function() {
+      var iterator = new Iterator(null);
+      iterator.done = true;
+      return iterator;
+    };
+    Iterator.is = function(value) {
+      if (value instanceof Iterator)
+        return true;
+      return typeof value === "object" && value !== null && typeof value.next === "function";
+    };
+    module.exports = Iterator;
+  }
+});
+
+// ../../node_modules/obliterator/foreach.js
+var require_foreach = __commonJS({
+  "../../node_modules/obliterator/foreach.js"(exports$1, module) {
+    var ARRAY_BUFFER_SUPPORT = typeof ArrayBuffer !== "undefined";
+    var SYMBOL_SUPPORT = typeof Symbol !== "undefined";
+    function forEach(iterable, callback) {
+      var iterator, k3, i3, l3, s3;
+      if (!iterable)
+        throw new Error("obliterator/forEach: invalid iterable.");
+      if (typeof callback !== "function")
+        throw new Error("obliterator/forEach: expecting a callback.");
+      if (Array.isArray(iterable) || ARRAY_BUFFER_SUPPORT && ArrayBuffer.isView(iterable) || typeof iterable === "string" || iterable.toString() === "[object Arguments]") {
+        for (i3 = 0, l3 = iterable.length; i3 < l3; i3++)
+          callback(iterable[i3], i3);
+        return;
+      }
+      if (typeof iterable.forEach === "function") {
+        iterable.forEach(callback);
+        return;
+      }
+      if (SYMBOL_SUPPORT && Symbol.iterator in iterable && typeof iterable.next !== "function") {
+        iterable = iterable[Symbol.iterator]();
+      }
+      if (typeof iterable.next === "function") {
+        iterator = iterable;
+        i3 = 0;
+        while (s3 = iterator.next(), s3.done !== true) {
+          callback(s3.value, i3);
+          i3++;
+        }
+        return;
+      }
+      for (k3 in iterable) {
+        if (iterable.hasOwnProperty(k3)) {
+          callback(iterable[k3], k3);
+        }
+      }
+      return;
+    }
+    forEach.forEachWithNullKeys = function(iterable, callback) {
+      var iterator, k3, i3, l3, s3;
+      if (!iterable)
+        throw new Error("obliterator/forEachWithNullKeys: invalid iterable.");
+      if (typeof callback !== "function")
+        throw new Error("obliterator/forEachWithNullKeys: expecting a callback.");
+      if (Array.isArray(iterable) || ARRAY_BUFFER_SUPPORT && ArrayBuffer.isView(iterable) || typeof iterable === "string" || iterable.toString() === "[object Arguments]") {
+        for (i3 = 0, l3 = iterable.length; i3 < l3; i3++)
+          callback(iterable[i3], null);
+        return;
+      }
+      if (iterable instanceof Set) {
+        iterable.forEach(function(value) {
+          callback(value, null);
+        });
+        return;
+      }
+      if (typeof iterable.forEach === "function") {
+        iterable.forEach(callback);
+        return;
+      }
+      if (SYMBOL_SUPPORT && Symbol.iterator in iterable && typeof iterable.next !== "function") {
+        iterable = iterable[Symbol.iterator]();
+      }
+      if (typeof iterable.next === "function") {
+        iterator = iterable;
+        i3 = 0;
+        while (s3 = iterator.next(), s3.done !== true) {
+          callback(s3.value, null);
+          i3++;
+        }
+        return;
+      }
+      for (k3 in iterable) {
+        if (iterable.hasOwnProperty(k3)) {
+          callback(iterable[k3], k3);
+        }
+      }
+      return;
+    };
+    module.exports = forEach;
+  }
+});
+
+// ../../node_modules/mnemonist/utils/typed-arrays.js
+var require_typed_arrays = __commonJS({
+  "../../node_modules/mnemonist/utils/typed-arrays.js"(exports$1) {
+    var MAX_8BIT_INTEGER = Math.pow(2, 8) - 1;
+    var MAX_16BIT_INTEGER = Math.pow(2, 16) - 1;
+    var MAX_32BIT_INTEGER = Math.pow(2, 32) - 1;
+    var MAX_SIGNED_8BIT_INTEGER = Math.pow(2, 7) - 1;
+    var MAX_SIGNED_16BIT_INTEGER = Math.pow(2, 15) - 1;
+    var MAX_SIGNED_32BIT_INTEGER = Math.pow(2, 31) - 1;
+    exports$1.getPointerArray = function(size) {
+      var maxIndex = size - 1;
+      if (maxIndex <= MAX_8BIT_INTEGER)
+        return Uint8Array;
+      if (maxIndex <= MAX_16BIT_INTEGER)
+        return Uint16Array;
+      if (maxIndex <= MAX_32BIT_INTEGER)
+        return Uint32Array;
+      return Float64Array;
+    };
+    exports$1.getSignedPointerArray = function(size) {
+      var maxIndex = size - 1;
+      if (maxIndex <= MAX_SIGNED_8BIT_INTEGER)
+        return Int8Array;
+      if (maxIndex <= MAX_SIGNED_16BIT_INTEGER)
+        return Int16Array;
+      if (maxIndex <= MAX_SIGNED_32BIT_INTEGER)
+        return Int32Array;
+      return Float64Array;
+    };
+    exports$1.getNumberType = function(value) {
+      if (value === (value | 0)) {
+        if (Math.sign(value) === -1) {
+          if (value <= 127 && value >= -128)
+            return Int8Array;
+          if (value <= 32767 && value >= -32768)
+            return Int16Array;
+          return Int32Array;
+        } else {
+          if (value <= 255)
+            return Uint8Array;
+          if (value <= 65535)
+            return Uint16Array;
+          return Uint32Array;
+        }
+      }
+      return Float64Array;
+    };
+    var TYPE_PRIORITY = {
+      Uint8Array: 1,
+      Int8Array: 2,
+      Uint16Array: 3,
+      Int16Array: 4,
+      Uint32Array: 5,
+      Int32Array: 6,
+      Float32Array: 7,
+      Float64Array: 8
+    };
+    exports$1.getMinimalRepresentation = function(array, getter) {
+      var maxType = null, maxPriority = 0, p3, t3, v3, i3, l3;
+      for (i3 = 0, l3 = array.length; i3 < l3; i3++) {
+        v3 = getter ? getter(array[i3]) : array[i3];
+        t3 = exports$1.getNumberType(v3);
+        p3 = TYPE_PRIORITY[t3.name];
+        if (p3 > maxPriority) {
+          maxPriority = p3;
+          maxType = t3;
+        }
+      }
+      return maxType;
+    };
+    exports$1.isTypedArray = function(value) {
+      return typeof ArrayBuffer !== "undefined" && ArrayBuffer.isView(value);
+    };
+    exports$1.concat = function() {
+      var length = 0, i3, o3, l3;
+      for (i3 = 0, l3 = arguments.length; i3 < l3; i3++)
+        length += arguments[i3].length;
+      var array = new arguments[0].constructor(length);
+      for (i3 = 0, o3 = 0; i3 < l3; i3++) {
+        array.set(arguments[i3], o3);
+        o3 += arguments[i3].length;
+      }
+      return array;
+    };
+    exports$1.indices = function(length) {
+      var PointerArray = exports$1.getPointerArray(length);
+      var array = new PointerArray(length);
+      for (var i3 = 0; i3 < length; i3++)
+        array[i3] = i3;
+      return array;
+    };
+  }
+});
+
+// ../../node_modules/mnemonist/utils/iterables.js
+var require_iterables = __commonJS({
+  "../../node_modules/mnemonist/utils/iterables.js"(exports$1) {
+    var forEach = require_foreach();
+    var typed = require_typed_arrays();
+    function isArrayLike(target) {
+      return Array.isArray(target) || typed.isTypedArray(target);
+    }
+    function guessLength(target) {
+      if (typeof target.length === "number")
+        return target.length;
+      if (typeof target.size === "number")
+        return target.size;
+      return;
+    }
+    function toArray(target) {
+      var l3 = guessLength(target);
+      var array = typeof l3 === "number" ? new Array(l3) : [];
+      var i3 = 0;
+      forEach(target, function(value) {
+        array[i3++] = value;
+      });
+      return array;
+    }
+    function toArrayWithIndices(target) {
+      var l3 = guessLength(target);
+      var IndexArray = typeof l3 === "number" ? typed.getPointerArray(l3) : Array;
+      var array = typeof l3 === "number" ? new Array(l3) : [];
+      var indices = typeof l3 === "number" ? new IndexArray(l3) : [];
+      var i3 = 0;
+      forEach(target, function(value) {
+        array[i3] = value;
+        indices[i3] = i3++;
+      });
+      return [array, indices];
+    }
+    exports$1.isArrayLike = isArrayLike;
+    exports$1.guessLength = guessLength;
+    exports$1.toArray = toArray;
+    exports$1.toArrayWithIndices = toArrayWithIndices;
+  }
+});
+
+// ../../node_modules/mnemonist/lru-cache.js
+var require_lru_cache = __commonJS({
+  "../../node_modules/mnemonist/lru-cache.js"(exports$1, module) {
+    var Iterator = require_iterator();
+    var forEach = require_foreach();
+    var typed = require_typed_arrays();
+    var iterables = require_iterables();
+    function LRUCache2(Keys, Values, capacity) {
+      if (arguments.length < 2) {
+        capacity = Keys;
+        Keys = null;
+        Values = null;
+      }
+      this.capacity = capacity;
+      if (typeof this.capacity !== "number" || this.capacity <= 0)
+        throw new Error("mnemonist/lru-cache: capacity should be positive number.");
+      var PointerArray = typed.getPointerArray(capacity);
+      this.forward = new PointerArray(capacity);
+      this.backward = new PointerArray(capacity);
+      this.K = typeof Keys === "function" ? new Keys(capacity) : new Array(capacity);
+      this.V = typeof Values === "function" ? new Values(capacity) : new Array(capacity);
+      this.size = 0;
+      this.head = 0;
+      this.tail = 0;
+      this.items = {};
+    }
+    LRUCache2.prototype.clear = function() {
+      this.size = 0;
+      this.head = 0;
+      this.tail = 0;
+      this.items = {};
+    };
+    LRUCache2.prototype.splayOnTop = function(pointer) {
+      var oldHead = this.head;
+      if (this.head === pointer)
+        return this;
+      var previous = this.backward[pointer], next = this.forward[pointer];
+      if (this.tail === pointer) {
+        this.tail = previous;
+      } else {
+        this.backward[next] = previous;
+      }
+      this.forward[previous] = next;
+      this.backward[oldHead] = pointer;
+      this.head = pointer;
+      this.forward[pointer] = oldHead;
+      return this;
+    };
+    LRUCache2.prototype.set = function(key, value) {
+      var pointer = this.items[key];
+      if (typeof pointer !== "undefined") {
+        this.splayOnTop(pointer);
+        this.V[pointer] = value;
+        return;
+      }
+      if (this.size < this.capacity) {
+        pointer = this.size++;
+      } else {
+        pointer = this.tail;
+        this.tail = this.backward[pointer];
+        delete this.items[this.K[pointer]];
+      }
+      this.items[key] = pointer;
+      this.K[pointer] = key;
+      this.V[pointer] = value;
+      this.forward[pointer] = this.head;
+      this.backward[this.head] = pointer;
+      this.head = pointer;
+    };
+    LRUCache2.prototype.setpop = function(key, value) {
+      var oldValue = null;
+      var oldKey = null;
+      var pointer = this.items[key];
+      if (typeof pointer !== "undefined") {
+        this.splayOnTop(pointer);
+        oldValue = this.V[pointer];
+        this.V[pointer] = value;
+        return { evicted: false, key, value: oldValue };
+      }
+      if (this.size < this.capacity) {
+        pointer = this.size++;
+      } else {
+        pointer = this.tail;
+        this.tail = this.backward[pointer];
+        oldValue = this.V[pointer];
+        oldKey = this.K[pointer];
+        delete this.items[this.K[pointer]];
+      }
+      this.items[key] = pointer;
+      this.K[pointer] = key;
+      this.V[pointer] = value;
+      this.forward[pointer] = this.head;
+      this.backward[this.head] = pointer;
+      this.head = pointer;
+      if (oldKey) {
+        return { evicted: true, key: oldKey, value: oldValue };
+      } else {
+        return null;
+      }
+    };
+    LRUCache2.prototype.has = function(key) {
+      return key in this.items;
+    };
+    LRUCache2.prototype.get = function(key) {
+      var pointer = this.items[key];
+      if (typeof pointer === "undefined")
+        return;
+      this.splayOnTop(pointer);
+      return this.V[pointer];
+    };
+    LRUCache2.prototype.peek = function(key) {
+      var pointer = this.items[key];
+      if (typeof pointer === "undefined")
+        return;
+      return this.V[pointer];
+    };
+    LRUCache2.prototype.forEach = function(callback, scope) {
+      scope = arguments.length > 1 ? scope : this;
+      var i3 = 0, l3 = this.size;
+      var pointer = this.head, keys = this.K, values = this.V, forward = this.forward;
+      while (i3 < l3) {
+        callback.call(scope, values[pointer], keys[pointer], this);
+        pointer = forward[pointer];
+        i3++;
+      }
+    };
+    LRUCache2.prototype.keys = function() {
+      var i3 = 0, l3 = this.size;
+      var pointer = this.head, keys = this.K, forward = this.forward;
+      return new Iterator(function() {
+        if (i3 >= l3)
+          return { done: true };
+        var key = keys[pointer];
+        i3++;
+        if (i3 < l3)
+          pointer = forward[pointer];
+        return {
+          done: false,
+          value: key
+        };
+      });
+    };
+    LRUCache2.prototype.values = function() {
+      var i3 = 0, l3 = this.size;
+      var pointer = this.head, values = this.V, forward = this.forward;
+      return new Iterator(function() {
+        if (i3 >= l3)
+          return { done: true };
+        var value = values[pointer];
+        i3++;
+        if (i3 < l3)
+          pointer = forward[pointer];
+        return {
+          done: false,
+          value
+        };
+      });
+    };
+    LRUCache2.prototype.entries = function() {
+      var i3 = 0, l3 = this.size;
+      var pointer = this.head, keys = this.K, values = this.V, forward = this.forward;
+      return new Iterator(function() {
+        if (i3 >= l3)
+          return { done: true };
+        var key = keys[pointer], value = values[pointer];
+        i3++;
+        if (i3 < l3)
+          pointer = forward[pointer];
+        return {
+          done: false,
+          value: [key, value]
+        };
+      });
+    };
+    if (typeof Symbol !== "undefined")
+      LRUCache2.prototype[Symbol.iterator] = LRUCache2.prototype.entries;
+    LRUCache2.prototype.inspect = function() {
+      var proxy = /* @__PURE__ */ new Map();
+      var iterator = this.entries(), step;
+      while (step = iterator.next(), !step.done)
+        proxy.set(step.value[0], step.value[1]);
+      Object.defineProperty(proxy, "constructor", {
+        value: LRUCache2,
+        enumerable: false
+      });
+      return proxy;
+    };
+    if (typeof Symbol !== "undefined")
+      LRUCache2.prototype[Symbol.for("nodejs.util.inspect.custom")] = LRUCache2.prototype.inspect;
+    LRUCache2.from = function(iterable, Keys, Values, capacity) {
+      if (arguments.length < 2) {
+        capacity = iterables.guessLength(iterable);
+        if (typeof capacity !== "number")
+          throw new Error("mnemonist/lru-cache.from: could not guess iterable length. Please provide desired capacity as last argument.");
+      } else if (arguments.length === 2) {
+        capacity = Keys;
+        Keys = null;
+        Values = null;
+      }
+      var cache3 = new LRUCache2(Keys, Values, capacity);
+      forEach(iterable, function(value, key) {
+        cache3.set(key, value);
+      });
+      return cache3;
+    };
+    module.exports = LRUCache2;
+  }
+});
+
+// ../../node_modules/@aws-sdk/middleware-sdk-sqs/dist-es/queue-url.js
+var resolveQueueUrlConfig = (config) => {
+  return Object.assign(config, {
+    useQueueUrlAsEndpoint: config.useQueueUrlAsEndpoint ?? true
+  });
+};
+function queueUrlMiddleware({ useQueueUrlAsEndpoint, endpoint }) {
+  return (next, context) => {
+    return async (args) => {
+      const { input } = args;
+      const resolvedEndpoint = context.endpointV2;
+      if (!endpoint && input.QueueUrl && resolvedEndpoint && useQueueUrlAsEndpoint) {
+        const logger = context.logger instanceof NoOpLogger || !context.logger?.warn ? console : context.logger;
+        try {
+          const queueUrl = new URL(input.QueueUrl);
+          const queueUrlOrigin = new URL(queueUrl.origin);
+          if (resolvedEndpoint.url.origin !== queueUrlOrigin.origin) {
+            logger.warn(`QueueUrl=${input.QueueUrl} differs from SQSClient resolved endpoint=${resolvedEndpoint.url.toString()}, using QueueUrl host as endpoint.
+Set [endpoint=string] or [useQueueUrlAsEndpoint=false] on the SQSClient.`);
+            context.endpointV2 = {
+              ...resolvedEndpoint,
+              url: queueUrlOrigin
+            };
+          }
+        } catch (e3) {
+          logger.warn(e3);
+        }
+      }
+      return next(args);
+    };
+  };
+}
+var queueUrlMiddlewareOptions = {
+  name: "queueUrlMiddleware",
+  relation: "after",
+  toMiddleware: "endpointV2Middleware",
+  override: true
+};
+var getQueueUrlPlugin = (config) => ({
+  applyToStack: (clientStack) => {
+    clientStack.addRelativeTo(queueUrlMiddleware(config), queueUrlMiddlewareOptions);
+  }
+});
+
+// ../../node_modules/@aws-sdk/middleware-sdk-sqs/dist-es/send-message.js
+var sendMessageMiddleware = (options) => (next) => async (args) => {
+  const resp = await next({ ...args });
+  if (options.md5 === false) {
+    return resp;
+  }
+  const output = resp.output;
+  const hash = new options.md5();
+  hash.update(toUint8Array(args.input.MessageBody || ""));
+  if (output.MD5OfMessageBody !== toHex(await hash.digest())) {
+    throw new Error("InvalidChecksumError");
+  }
+  return resp;
+};
+var sendMessageMiddlewareOptions = {
+  step: "initialize",
+  tags: ["VALIDATE_BODY_MD5"],
+  name: "sendMessageMiddleware",
+  override: true
+};
+var getSendMessagePlugin = (config) => ({
+  applyToStack: (clientStack) => {
+    clientStack.add(sendMessageMiddleware(config), sendMessageMiddlewareOptions);
+  }
+});
+
+// ../../node_modules/@aws-sdk/middleware-sdk-sqs/dist-es/send-message-batch.js
+var sendMessageBatchMiddleware = (options) => (next) => async (args) => {
+  const resp = await next({ ...args });
+  if (options.md5 === false) {
+    return resp;
+  }
+  const output = resp.output;
+  const messageIds = [];
+  const entries = {};
+  if (output.Successful !== void 0) {
+    for (const entry of output.Successful) {
+      if (entry.Id !== void 0) {
+        entries[entry.Id] = entry;
+      }
+    }
+  }
+  for (const entry of args.input.Entries) {
+    if (entries[entry.Id]) {
+      const md5 = entries[entry.Id].MD5OfMessageBody;
+      const hash = new options.md5();
+      hash.update(toUint8Array(entry.MessageBody || ""));
+      if (md5 !== toHex(await hash.digest())) {
+        messageIds.push(entries[entry.Id].MessageId);
+      }
+    }
+  }
+  if (messageIds.length > 0) {
+    throw new Error("Invalid MD5 checksum on messages: " + messageIds.join(", "));
+  }
+  return resp;
+};
+var sendMessageBatchMiddlewareOptions = {
+  step: "initialize",
+  tags: ["VALIDATE_BODY_MD5"],
+  name: "sendMessageBatchMiddleware",
+  override: true
+};
+var getSendMessageBatchPlugin = (config) => ({
+  applyToStack: (clientStack) => {
+    clientStack.add(sendMessageBatchMiddleware(config), sendMessageBatchMiddlewareOptions);
+  }
+});
+
+// ../../node_modules/@aws-sdk/core/dist-es/submodules/protocols/coercing-serializers.js
+var _toStr = (val) => {
+  if (val == null) {
+    return val;
+  }
+  if (typeof val === "number" || typeof val === "bigint") {
+    const warning = new Error(`Received number ${val} where a string was expected.`);
+    warning.name = "Warning";
+    console.warn(warning);
+    return String(val);
+  }
+  if (typeof val === "boolean") {
+    const warning = new Error(`Received boolean ${val} where a string was expected.`);
+    warning.name = "Warning";
+    console.warn(warning);
+    return String(val);
+  }
+  return val;
+};
+var _toNum = (val) => {
+  if (val == null) {
+    return val;
+  }
+  if (typeof val === "string") {
+    const num = Number(val);
+    if (num.toString() !== val) {
+      const warning = new Error(`Received string "${val}" where a number was expected.`);
+      warning.name = "Warning";
+      console.warn(warning);
+      return val;
+    }
+    return num;
+  }
+  return val;
+};
+
+// ../../node_modules/@aws-sdk/client-sqs/dist-es/auth/httpAuthSchemeProvider.js
+var defaultSQSHttpAuthSchemeParametersProvider = async (config, context, input) => {
+  return {
+    operation: getSmithyContext(context).operation,
+    region: await normalizeProvider(config.region)() || (() => {
+      throw new Error("expected `region` to be configured for `aws.auth#sigv4`");
+    })()
+  };
+};
+function createAwsAuthSigv4HttpAuthOption(authParameters) {
+  return {
+    schemeId: "aws.auth#sigv4",
+    signingProperties: {
+      name: "sqs",
+      region: authParameters.region
+    },
+    propertiesExtractor: (config, context) => ({
+      signingProperties: {
+        config,
+        context
+      }
+    })
+  };
+}
+var defaultSQSHttpAuthSchemeProvider = (authParameters) => {
+  const options = [];
+  switch (authParameters.operation) {
+    default: {
+      options.push(createAwsAuthSigv4HttpAuthOption(authParameters));
+    }
+  }
+  return options;
+};
+var resolveHttpAuthSchemeConfig = (config) => {
+  const config_0 = resolveAwsSdkSigV4Config(config);
+  return Object.assign(config_0, {
+    authSchemePreference: normalizeProvider(config.authSchemePreference ?? [])
+  });
+};
+
+// ../../node_modules/@aws-sdk/client-sqs/dist-es/endpoint/EndpointParameters.js
+var resolveClientEndpointParameters = (options) => {
+  return Object.assign(options, {
+    useDualstackEndpoint: options.useDualstackEndpoint ?? false,
+    useFipsEndpoint: options.useFipsEndpoint ?? false,
+    defaultSigningName: "sqs"
+  });
+};
+var commonParams = {
+  UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+  Endpoint: { type: "builtInParams", name: "endpoint" },
+  Region: { type: "builtInParams", name: "region" },
+  UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
+};
+
+// ../../node_modules/@aws-sdk/client-sqs/package.json
+var package_default = {
+  version: "3.797.0"};
+
+// ../../node_modules/@aws-sdk/credential-provider-node/dist-es/remoteProvider.js
+var ENV_IMDS_DISABLED = "AWS_EC2_METADATA_DISABLED";
+var remoteProvider = async (init) => {
+  const { ENV_CMDS_FULL_URI, ENV_CMDS_RELATIVE_URI, fromContainerMetadata, fromInstanceMetadata } = await import('./dist-es-4ULGGWP4.js');
+  if (process.env[ENV_CMDS_RELATIVE_URI] || process.env[ENV_CMDS_FULL_URI]) {
+    init.logger?.debug("@aws-sdk/credential-provider-node - remoteProvider::fromHttp/fromContainerMetadata");
+    const { fromHttp } = await import('./dist-es-XD3WAN5D.js');
+    return chain(fromHttp(init), fromContainerMetadata(init));
+  }
+  if (process.env[ENV_IMDS_DISABLED] && process.env[ENV_IMDS_DISABLED] !== "false") {
+    return async () => {
+      throw new CredentialsProviderError("EC2 Instance Metadata Service access disabled", { logger: init.logger });
+    };
+  }
+  init.logger?.debug("@aws-sdk/credential-provider-node - remoteProvider::fromInstanceMetadata");
+  return fromInstanceMetadata(init);
+};
+
+// ../../node_modules/@aws-sdk/credential-provider-node/dist-es/defaultProvider.js
+var multipleCredentialSourceWarningEmitted = false;
+var defaultProvider = (init = {}) => memoize(chain(async () => {
+  const profile = init.profile ?? process.env[ENV_PROFILE];
+  if (profile) {
+    const envStaticCredentialsAreSet = process.env[ENV_KEY] && process.env[ENV_SECRET];
+    if (envStaticCredentialsAreSet) {
+      if (!multipleCredentialSourceWarningEmitted) {
+        const warnFn = init.logger?.warn && init.logger?.constructor?.name !== "NoOpLogger" ? init.logger.warn : console.warn;
+        warnFn(`@aws-sdk/credential-provider-node - defaultProvider::fromEnv WARNING:
+    Multiple credential sources detected: 
+    Both AWS_PROFILE and the pair AWS_ACCESS_KEY_ID/AWS_SECRET_ACCESS_KEY static credentials are set.
+    This SDK will proceed with the AWS_PROFILE value.
+    
+    However, a future version may change this behavior to prefer the ENV static credentials.
+    Please ensure that your environment only sets either the AWS_PROFILE or the
+    AWS_ACCESS_KEY_ID/AWS_SECRET_ACCESS_KEY pair.
+`);
+        multipleCredentialSourceWarningEmitted = true;
+      }
+    }
+    throw new CredentialsProviderError("AWS_PROFILE is set, skipping fromEnv provider.", {
+      logger: init.logger,
+      tryNextLink: true
+    });
+  }
+  init.logger?.debug("@aws-sdk/credential-provider-node - defaultProvider::fromEnv");
+  return fromEnv(init)();
+}, async () => {
+  init.logger?.debug("@aws-sdk/credential-provider-node - defaultProvider::fromSSO");
+  const { ssoStartUrl, ssoAccountId, ssoRegion, ssoRoleName, ssoSession } = init;
+  if (!ssoStartUrl && !ssoAccountId && !ssoRegion && !ssoRoleName && !ssoSession) {
+    throw new CredentialsProviderError("Skipping SSO provider in default chain (inputs do not include SSO fields).", { logger: init.logger });
+  }
+  const { fromSSO } = await import('./dist-es-TNZXIBKF.js');
+  return fromSSO(init)();
+}, async () => {
+  init.logger?.debug("@aws-sdk/credential-provider-node - defaultProvider::fromIni");
+  const { fromIni } = await import('./dist-es-ZVXNFAFI.js');
+  return fromIni(init)();
+}, async () => {
+  init.logger?.debug("@aws-sdk/credential-provider-node - defaultProvider::fromProcess");
+  const { fromProcess } = await import('./dist-es-4LCK4BMD.js');
+  return fromProcess(init)();
+}, async () => {
+  init.logger?.debug("@aws-sdk/credential-provider-node - defaultProvider::fromTokenFile");
+  const { fromTokenFile } = await import('./dist-es-ZOY57CKU.js');
+  return fromTokenFile(init)();
+}, async () => {
+  init.logger?.debug("@aws-sdk/credential-provider-node - defaultProvider::remoteProvider");
+  return (await remoteProvider(init))();
+}, async () => {
+  throw new CredentialsProviderError("Could not load credentials from any providers", {
+    tryNextLink: false,
+    logger: init.logger
+  });
+}), credentialsTreatedAsExpired, credentialsWillNeedRefresh);
+var credentialsWillNeedRefresh = (credentials) => credentials?.expiration !== void 0;
+var credentialsTreatedAsExpired = (credentials) => credentials?.expiration !== void 0 && credentials.expiration.getTime() - Date.now() < 3e5;
+
+// ../../node_modules/@aws-sdk/client-sqs/dist-es/endpoint/ruleset.js
+var u = "required";
+var v = "fn";
+var w = "argv";
+var x = "ref";
+var a = true;
+var b = "isSet";
+var c = "booleanEquals";
+var d = "error";
+var e = "endpoint";
+var f = "tree";
+var g = "PartitionResult";
+var h = "getAttr";
+var i = { [u]: false, "type": "String" };
+var j = { [u]: true, "default": false, "type": "Boolean" };
+var k = { [x]: "Endpoint" };
+var l = { [v]: c, [w]: [{ [x]: "UseFIPS" }, true] };
+var m = { [v]: c, [w]: [{ [x]: "UseDualStack" }, true] };
+var n = {};
+var o = { [v]: h, [w]: [{ [x]: g }, "supportsFIPS"] };
+var p = { [x]: g };
+var q = { [v]: c, [w]: [true, { [v]: h, [w]: [p, "supportsDualStack"] }] };
+var r = [l];
+var s = [m];
+var t = [{ [x]: "Region" }];
+var _data = { version: "1.0", parameters: { Region: i, UseDualStack: j, UseFIPS: j, Endpoint: i }, rules: [{ conditions: [{ [v]: b, [w]: [k] }], rules: [{ conditions: r, error: "Invalid Configuration: FIPS and custom endpoint are not supported", type: d }, { conditions: s, error: "Invalid Configuration: Dualstack and custom endpoint are not supported", type: d }, { endpoint: { url: k, properties: n, headers: n }, type: e }], type: f }, { conditions: [{ [v]: b, [w]: t }], rules: [{ conditions: [{ [v]: "aws.partition", [w]: t, assign: g }], rules: [{ conditions: [l, m], rules: [{ conditions: [{ [v]: c, [w]: [a, o] }, q], rules: [{ endpoint: { url: "https://sqs-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", properties: n, headers: n }, type: e }], type: f }, { error: "FIPS and DualStack are enabled, but this partition does not support one or both", type: d }], type: f }, { conditions: r, rules: [{ conditions: [{ [v]: c, [w]: [o, a] }], rules: [{ conditions: [{ [v]: "stringEquals", [w]: [{ [v]: h, [w]: [p, "name"] }, "aws-us-gov"] }], endpoint: { url: "https://sqs.{Region}.amazonaws.com", properties: n, headers: n }, type: e }, { endpoint: { url: "https://sqs-fips.{Region}.{PartitionResult#dnsSuffix}", properties: n, headers: n }, type: e }], type: f }, { error: "FIPS is enabled but this partition does not support FIPS", type: d }], type: f }, { conditions: s, rules: [{ conditions: [q], rules: [{ endpoint: { url: "https://sqs.{Region}.{PartitionResult#dualStackDnsSuffix}", properties: n, headers: n }, type: e }], type: f }, { error: "DualStack is enabled but this partition does not support DualStack", type: d }], type: f }, { endpoint: { url: "https://sqs.{Region}.{PartitionResult#dnsSuffix}", properties: n, headers: n }, type: e }], type: f }], type: f }, { error: "Invalid Configuration: Missing Region", type: d }] };
+var ruleSet = _data;
+
+// ../../node_modules/@aws-sdk/client-sqs/dist-es/endpoint/endpointResolver.js
+var cache = new EndpointCache({
+  size: 50,
+  params: ["Endpoint", "Region", "UseDualStack", "UseFIPS"]
+});
+var defaultEndpointResolver = (endpointParams, context = {}) => {
+  return cache.get(endpointParams, () => resolveEndpoint(ruleSet, {
+    endpointParams,
+    logger: context.logger
+  }));
+};
+customEndpointFunctions.aws = awsEndpointFunctions;
+
+// ../../node_modules/@aws-sdk/client-sqs/dist-es/runtimeConfig.shared.js
+var getRuntimeConfig = (config) => {
+  return {
+    apiVersion: "2012-11-05",
+    base64Decoder: config?.base64Decoder ?? fromBase64,
+    base64Encoder: config?.base64Encoder ?? toBase64,
+    disableHostPrefix: config?.disableHostPrefix ?? false,
+    endpointProvider: config?.endpointProvider ?? defaultEndpointResolver,
+    extensions: config?.extensions ?? [],
+    httpAuthSchemeProvider: config?.httpAuthSchemeProvider ?? defaultSQSHttpAuthSchemeProvider,
+    httpAuthSchemes: config?.httpAuthSchemes ?? [
+      {
+        schemeId: "aws.auth#sigv4",
+        identityProvider: (ipc) => ipc.getIdentityProvider("aws.auth#sigv4"),
+        signer: new AwsSdkSigV4Signer()
+      }
+    ],
+    logger: config?.logger ?? new NoOpLogger(),
+    serviceId: config?.serviceId ?? "SQS",
+    urlParser: config?.urlParser ?? parseUrl,
+    utf8Decoder: config?.utf8Decoder ?? fromUtf8,
+    utf8Encoder: config?.utf8Encoder ?? toUtf8
+  };
+};
+
+// ../../node_modules/@aws-sdk/client-sqs/dist-es/runtimeConfig.js
+var getRuntimeConfig2 = (config) => {
+  emitWarningIfUnsupportedVersion(process.version);
+  const defaultsMode = resolveDefaultsModeConfig(config);
+  const defaultConfigProvider = () => defaultsMode().then(loadConfigsForDefaultMode);
+  const clientSharedValues = getRuntimeConfig(config);
+  emitWarningIfUnsupportedVersion$1(process.version);
+  const profileConfig = { profile: config?.profile };
+  return {
+    ...clientSharedValues,
+    ...config,
+    runtime: "node",
+    defaultsMode,
+    bodyLengthChecker: config?.bodyLengthChecker ?? calculateBodyLength,
+    credentialDefaultProvider: config?.credentialDefaultProvider ?? defaultProvider,
+    defaultUserAgentProvider: config?.defaultUserAgentProvider ?? createDefaultUserAgentProvider({ serviceId: clientSharedValues.serviceId, clientVersion: package_default.version }),
+    maxAttempts: config?.maxAttempts ?? loadConfig(NODE_MAX_ATTEMPT_CONFIG_OPTIONS, config),
+    md5: config?.md5 ?? Hash.bind(null, "md5"),
+    region: config?.region ?? loadConfig(NODE_REGION_CONFIG_OPTIONS, { ...NODE_REGION_CONFIG_FILE_OPTIONS, ...profileConfig }),
+    requestHandler: NodeHttpHandler.create(config?.requestHandler ?? defaultConfigProvider),
+    retryMode: config?.retryMode ?? loadConfig({
+      ...NODE_RETRY_MODE_CONFIG_OPTIONS,
+      default: async () => (await defaultConfigProvider()).retryMode || DEFAULT_RETRY_MODE
+    }, config),
+    sha256: config?.sha256 ?? Hash.bind(null, "sha256"),
+    streamCollector: config?.streamCollector ?? streamCollector,
+    useDualstackEndpoint: config?.useDualstackEndpoint ?? loadConfig(NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS, profileConfig),
+    useFipsEndpoint: config?.useFipsEndpoint ?? loadConfig(NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS, profileConfig),
+    userAgentAppId: config?.userAgentAppId ?? loadConfig(NODE_APP_ID_CONFIG_OPTIONS, profileConfig)
+  };
+};
+
+// ../../node_modules/@aws-sdk/client-sqs/dist-es/auth/httpAuthExtensionConfiguration.js
+var getHttpAuthExtensionConfiguration = (runtimeConfig) => {
+  const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
+  let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
+  let _credentials = runtimeConfig.credentials;
+  return {
+    setHttpAuthScheme(httpAuthScheme) {
+      const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
+      if (index === -1) {
+        _httpAuthSchemes.push(httpAuthScheme);
+      } else {
+        _httpAuthSchemes.splice(index, 1, httpAuthScheme);
+      }
+    },
+    httpAuthSchemes() {
+      return _httpAuthSchemes;
+    },
+    setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
+      _httpAuthSchemeProvider = httpAuthSchemeProvider;
+    },
+    httpAuthSchemeProvider() {
+      return _httpAuthSchemeProvider;
+    },
+    setCredentials(credentials) {
+      _credentials = credentials;
+    },
+    credentials() {
+      return _credentials;
+    }
+  };
+};
+var resolveHttpAuthRuntimeConfig = (config) => {
+  return {
+    httpAuthSchemes: config.httpAuthSchemes(),
+    httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
+    credentials: config.credentials()
+  };
+};
+
+// ../../node_modules/@aws-sdk/client-sqs/dist-es/runtimeExtensions.js
+var resolveRuntimeExtensions = (runtimeConfig, extensions) => {
+  const extensionConfiguration = Object.assign(getAwsRegionExtensionConfiguration(runtimeConfig), getDefaultExtensionConfiguration(runtimeConfig), getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration(runtimeConfig));
+  extensions.forEach((extension) => extension.configure(extensionConfiguration));
+  return Object.assign(runtimeConfig, resolveAwsRegionExtensionConfiguration(extensionConfiguration), resolveDefaultRuntimeConfig(extensionConfiguration), resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig(extensionConfiguration));
+};
+
+// ../../node_modules/@aws-sdk/client-sqs/dist-es/SQSClient.js
+var SQSClient = class extends Client {
+  config;
+  constructor(...[configuration]) {
+    const _config_0 = getRuntimeConfig2(configuration || {});
+    super(_config_0);
+    this.initConfig = _config_0;
+    const _config_1 = resolveClientEndpointParameters(_config_0);
+    const _config_2 = resolveUserAgentConfig(_config_1);
+    const _config_3 = resolveRetryConfig(_config_2);
+    const _config_4 = resolveRegionConfig(_config_3);
+    const _config_5 = resolveHostHeaderConfig(_config_4);
+    const _config_6 = resolveEndpointConfig(_config_5);
+    const _config_7 = resolveQueueUrlConfig(_config_6);
+    const _config_8 = resolveHttpAuthSchemeConfig(_config_7);
+    const _config_9 = resolveRuntimeExtensions(_config_8, configuration?.extensions || []);
+    this.config = _config_9;
+    this.middlewareStack.use(getUserAgentPlugin(this.config));
+    this.middlewareStack.use(getRetryPlugin(this.config));
+    this.middlewareStack.use(getContentLengthPlugin(this.config));
+    this.middlewareStack.use(getHostHeaderPlugin(this.config));
+    this.middlewareStack.use(getLoggerPlugin(this.config));
+    this.middlewareStack.use(getRecursionDetectionPlugin(this.config));
+    this.middlewareStack.use(getQueueUrlPlugin(this.config));
+    this.middlewareStack.use(getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
+      httpAuthSchemeParametersProvider: defaultSQSHttpAuthSchemeParametersProvider,
+      identityProviderConfigProvider: async (config) => new DefaultIdentityProviderConfig({
+        "aws.auth#sigv4": config.credentials
+      })
+    }));
+    this.middlewareStack.use(getHttpSigningPlugin(this.config));
+  }
+  destroy() {
+    super.destroy();
+  }
+};
+
+// ../../node_modules/@aws-sdk/client-sqs/dist-es/models/SQSServiceException.js
+var SQSServiceException = class _SQSServiceException extends ServiceException {
+  constructor(options) {
+    super(options);
+    Object.setPrototypeOf(this, _SQSServiceException.prototype);
+  }
+};
+
+// ../../node_modules/@aws-sdk/client-sqs/dist-es/models/models_0.js
+var InvalidAddress = class _InvalidAddress extends SQSServiceException {
+  name = "InvalidAddress";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "InvalidAddress",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _InvalidAddress.prototype);
+  }
+};
+var InvalidSecurity = class _InvalidSecurity extends SQSServiceException {
+  name = "InvalidSecurity";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "InvalidSecurity",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _InvalidSecurity.prototype);
+  }
+};
+var OverLimit = class _OverLimit extends SQSServiceException {
+  name = "OverLimit";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "OverLimit",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _OverLimit.prototype);
+  }
+};
+var QueueDoesNotExist = class _QueueDoesNotExist extends SQSServiceException {
+  name = "QueueDoesNotExist";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "QueueDoesNotExist",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _QueueDoesNotExist.prototype);
+  }
+};
+var RequestThrottled = class _RequestThrottled extends SQSServiceException {
+  name = "RequestThrottled";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "RequestThrottled",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _RequestThrottled.prototype);
+  }
+};
+var UnsupportedOperation = class _UnsupportedOperation extends SQSServiceException {
+  name = "UnsupportedOperation";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "UnsupportedOperation",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _UnsupportedOperation.prototype);
+  }
+};
+var ResourceNotFoundException = class _ResourceNotFoundException extends SQSServiceException {
+  name = "ResourceNotFoundException";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "ResourceNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _ResourceNotFoundException.prototype);
+  }
+};
+var MessageNotInflight = class _MessageNotInflight extends SQSServiceException {
+  name = "MessageNotInflight";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "MessageNotInflight",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _MessageNotInflight.prototype);
+  }
+};
+var ReceiptHandleIsInvalid = class _ReceiptHandleIsInvalid extends SQSServiceException {
+  name = "ReceiptHandleIsInvalid";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "ReceiptHandleIsInvalid",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _ReceiptHandleIsInvalid.prototype);
+  }
+};
+var BatchEntryIdsNotDistinct = class _BatchEntryIdsNotDistinct extends SQSServiceException {
+  name = "BatchEntryIdsNotDistinct";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "BatchEntryIdsNotDistinct",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _BatchEntryIdsNotDistinct.prototype);
+  }
+};
+var EmptyBatchRequest = class _EmptyBatchRequest extends SQSServiceException {
+  name = "EmptyBatchRequest";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "EmptyBatchRequest",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _EmptyBatchRequest.prototype);
+  }
+};
+var InvalidBatchEntryId = class _InvalidBatchEntryId extends SQSServiceException {
+  name = "InvalidBatchEntryId";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "InvalidBatchEntryId",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _InvalidBatchEntryId.prototype);
+  }
+};
+var TooManyEntriesInBatchRequest = class _TooManyEntriesInBatchRequest extends SQSServiceException {
+  name = "TooManyEntriesInBatchRequest";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "TooManyEntriesInBatchRequest",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _TooManyEntriesInBatchRequest.prototype);
+  }
+};
+var InvalidAttributeName = class _InvalidAttributeName extends SQSServiceException {
+  name = "InvalidAttributeName";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "InvalidAttributeName",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _InvalidAttributeName.prototype);
+  }
+};
+var InvalidAttributeValue = class _InvalidAttributeValue extends SQSServiceException {
+  name = "InvalidAttributeValue";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "InvalidAttributeValue",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _InvalidAttributeValue.prototype);
+  }
+};
+var QueueDeletedRecently = class _QueueDeletedRecently extends SQSServiceException {
+  name = "QueueDeletedRecently";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "QueueDeletedRecently",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _QueueDeletedRecently.prototype);
+  }
+};
+var QueueNameExists = class _QueueNameExists extends SQSServiceException {
+  name = "QueueNameExists";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "QueueNameExists",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _QueueNameExists.prototype);
+  }
+};
+var InvalidIdFormat = class _InvalidIdFormat extends SQSServiceException {
+  name = "InvalidIdFormat";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "InvalidIdFormat",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _InvalidIdFormat.prototype);
+  }
+};
+var PurgeQueueInProgress = class _PurgeQueueInProgress extends SQSServiceException {
+  name = "PurgeQueueInProgress";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "PurgeQueueInProgress",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _PurgeQueueInProgress.prototype);
+  }
+};
+var KmsAccessDenied = class _KmsAccessDenied extends SQSServiceException {
+  name = "KmsAccessDenied";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "KmsAccessDenied",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _KmsAccessDenied.prototype);
+  }
+};
+var KmsDisabled = class _KmsDisabled extends SQSServiceException {
+  name = "KmsDisabled";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "KmsDisabled",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _KmsDisabled.prototype);
+  }
+};
+var KmsInvalidKeyUsage = class _KmsInvalidKeyUsage extends SQSServiceException {
+  name = "KmsInvalidKeyUsage";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "KmsInvalidKeyUsage",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _KmsInvalidKeyUsage.prototype);
+  }
+};
+var KmsInvalidState = class _KmsInvalidState extends SQSServiceException {
+  name = "KmsInvalidState";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "KmsInvalidState",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _KmsInvalidState.prototype);
+  }
+};
+var KmsNotFound = class _KmsNotFound extends SQSServiceException {
+  name = "KmsNotFound";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "KmsNotFound",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _KmsNotFound.prototype);
+  }
+};
+var KmsOptInRequired = class _KmsOptInRequired extends SQSServiceException {
+  name = "KmsOptInRequired";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "KmsOptInRequired",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _KmsOptInRequired.prototype);
+  }
+};
+var KmsThrottled = class _KmsThrottled extends SQSServiceException {
+  name = "KmsThrottled";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "KmsThrottled",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _KmsThrottled.prototype);
+  }
+};
+var InvalidMessageContents = class _InvalidMessageContents extends SQSServiceException {
+  name = "InvalidMessageContents";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "InvalidMessageContents",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _InvalidMessageContents.prototype);
+  }
+};
+var BatchRequestTooLong = class _BatchRequestTooLong extends SQSServiceException {
+  name = "BatchRequestTooLong";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "BatchRequestTooLong",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _BatchRequestTooLong.prototype);
+  }
+};
+
+// ../../node_modules/@aws-sdk/client-sqs/dist-es/protocols/Aws_json1_0.js
+var se_ChangeMessageVisibilityCommand = async (input, context) => {
+  const headers = sharedHeaders("ChangeMessageVisibility");
+  let body;
+  body = JSON.stringify(se_ChangeMessageVisibilityRequest(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+};
+var se_SendMessageCommand = async (input, context) => {
+  const headers = sharedHeaders("SendMessage");
+  let body;
+  body = JSON.stringify(se_SendMessageRequest(input, context));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+};
+var se_SendMessageBatchCommand = async (input, context) => {
+  const headers = sharedHeaders("SendMessageBatch");
+  let body;
+  body = JSON.stringify(se_SendMessageBatchRequest(input, context));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+};
+var de_ChangeMessageVisibilityCommand = async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  await collectBody(output.body, context);
+  const response = {
+    $metadata: deserializeMetadata(output)
+  };
+  return response;
+};
+var de_SendMessageCommand = async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const data = await parseJsonBody(output.body, context);
+  let contents = {};
+  contents = _json(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+};
+var de_SendMessageBatchCommand = async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const data = await parseJsonBody(output.body, context);
+  let contents = {};
+  contents = _json(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+};
+var de_CommandError = async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseJsonErrorBody(output.body, context)
+  };
+  populateBodyWithQueryCompatibility(parsedOutput, output.headers);
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidAddress":
+    case "com.amazonaws.sqs#InvalidAddress":
+      throw await de_InvalidAddressRes(parsedOutput);
+    case "InvalidSecurity":
+    case "com.amazonaws.sqs#InvalidSecurity":
+      throw await de_InvalidSecurityRes(parsedOutput);
+    case "OverLimit":
+    case "com.amazonaws.sqs#OverLimit":
+      throw await de_OverLimitRes(parsedOutput);
+    case "QueueDoesNotExist":
+    case "com.amazonaws.sqs#QueueDoesNotExist":
+      throw await de_QueueDoesNotExistRes(parsedOutput);
+    case "RequestThrottled":
+    case "com.amazonaws.sqs#RequestThrottled":
+      throw await de_RequestThrottledRes(parsedOutput);
+    case "UnsupportedOperation":
+    case "com.amazonaws.sqs#UnsupportedOperation":
+      throw await de_UnsupportedOperationRes(parsedOutput);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.sqs#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput);
+    case "MessageNotInflight":
+    case "com.amazonaws.sqs#MessageNotInflight":
+      throw await de_MessageNotInflightRes(parsedOutput);
+    case "ReceiptHandleIsInvalid":
+    case "com.amazonaws.sqs#ReceiptHandleIsInvalid":
+      throw await de_ReceiptHandleIsInvalidRes(parsedOutput);
+    case "BatchEntryIdsNotDistinct":
+    case "com.amazonaws.sqs#BatchEntryIdsNotDistinct":
+      throw await de_BatchEntryIdsNotDistinctRes(parsedOutput);
+    case "EmptyBatchRequest":
+    case "com.amazonaws.sqs#EmptyBatchRequest":
+      throw await de_EmptyBatchRequestRes(parsedOutput);
+    case "InvalidBatchEntryId":
+    case "com.amazonaws.sqs#InvalidBatchEntryId":
+      throw await de_InvalidBatchEntryIdRes(parsedOutput);
+    case "TooManyEntriesInBatchRequest":
+    case "com.amazonaws.sqs#TooManyEntriesInBatchRequest":
+      throw await de_TooManyEntriesInBatchRequestRes(parsedOutput);
+    case "InvalidAttributeName":
+    case "com.amazonaws.sqs#InvalidAttributeName":
+      throw await de_InvalidAttributeNameRes(parsedOutput);
+    case "InvalidAttributeValue":
+    case "com.amazonaws.sqs#InvalidAttributeValue":
+      throw await de_InvalidAttributeValueRes(parsedOutput);
+    case "QueueDeletedRecently":
+    case "com.amazonaws.sqs#QueueDeletedRecently":
+      throw await de_QueueDeletedRecentlyRes(parsedOutput);
+    case "QueueNameExists":
+    case "com.amazonaws.sqs#QueueNameExists":
+      throw await de_QueueNameExistsRes(parsedOutput);
+    case "InvalidIdFormat":
+    case "com.amazonaws.sqs#InvalidIdFormat":
+      throw await de_InvalidIdFormatRes(parsedOutput);
+    case "PurgeQueueInProgress":
+    case "com.amazonaws.sqs#PurgeQueueInProgress":
+      throw await de_PurgeQueueInProgressRes(parsedOutput);
+    case "KmsAccessDenied":
+    case "com.amazonaws.sqs#KmsAccessDenied":
+      throw await de_KmsAccessDeniedRes(parsedOutput);
+    case "KmsDisabled":
+    case "com.amazonaws.sqs#KmsDisabled":
+      throw await de_KmsDisabledRes(parsedOutput);
+    case "KmsInvalidKeyUsage":
+    case "com.amazonaws.sqs#KmsInvalidKeyUsage":
+      throw await de_KmsInvalidKeyUsageRes(parsedOutput);
+    case "KmsInvalidState":
+    case "com.amazonaws.sqs#KmsInvalidState":
+      throw await de_KmsInvalidStateRes(parsedOutput);
+    case "KmsNotFound":
+    case "com.amazonaws.sqs#KmsNotFound":
+      throw await de_KmsNotFoundRes(parsedOutput);
+    case "KmsOptInRequired":
+    case "com.amazonaws.sqs#KmsOptInRequired":
+      throw await de_KmsOptInRequiredRes(parsedOutput);
+    case "KmsThrottled":
+    case "com.amazonaws.sqs#KmsThrottled":
+      throw await de_KmsThrottledRes(parsedOutput);
+    case "InvalidMessageContents":
+    case "com.amazonaws.sqs#InvalidMessageContents":
+      throw await de_InvalidMessageContentsRes(parsedOutput);
+    case "BatchRequestTooLong":
+    case "com.amazonaws.sqs#BatchRequestTooLong":
+      throw await de_BatchRequestTooLongRes(parsedOutput);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+};
+var de_BatchEntryIdsNotDistinctRes = async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new BatchEntryIdsNotDistinct({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+};
+var de_BatchRequestTooLongRes = async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new BatchRequestTooLong({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+};
+var de_EmptyBatchRequestRes = async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new EmptyBatchRequest({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+};
+var de_InvalidAddressRes = async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new InvalidAddress({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+};
+var de_InvalidAttributeNameRes = async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new InvalidAttributeName({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+};
+var de_InvalidAttributeValueRes = async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new InvalidAttributeValue({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+};
+var de_InvalidBatchEntryIdRes = async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new InvalidBatchEntryId({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+};
+var de_InvalidIdFormatRes = async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new InvalidIdFormat({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+};
+var de_InvalidMessageContentsRes = async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new InvalidMessageContents({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+};
+var de_InvalidSecurityRes = async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new InvalidSecurity({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+};
+var de_KmsAccessDeniedRes = async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new KmsAccessDenied({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+};
+var de_KmsDisabledRes = async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new KmsDisabled({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+};
+var de_KmsInvalidKeyUsageRes = async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new KmsInvalidKeyUsage({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+};
+var de_KmsInvalidStateRes = async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new KmsInvalidState({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+};
+var de_KmsNotFoundRes = async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new KmsNotFound({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+};
+var de_KmsOptInRequiredRes = async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new KmsOptInRequired({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+};
+var de_KmsThrottledRes = async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new KmsThrottled({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+};
+var de_MessageNotInflightRes = async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new MessageNotInflight({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+};
+var de_OverLimitRes = async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new OverLimit({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+};
+var de_PurgeQueueInProgressRes = async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new PurgeQueueInProgress({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+};
+var de_QueueDeletedRecentlyRes = async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new QueueDeletedRecently({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+};
+var de_QueueDoesNotExistRes = async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new QueueDoesNotExist({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+};
+var de_QueueNameExistsRes = async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new QueueNameExists({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+};
+var de_ReceiptHandleIsInvalidRes = async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new ReceiptHandleIsInvalid({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+};
+var de_RequestThrottledRes = async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new RequestThrottled({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+};
+var de_ResourceNotFoundExceptionRes = async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new ResourceNotFoundException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+};
+var de_TooManyEntriesInBatchRequestRes = async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new TooManyEntriesInBatchRequest({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+};
+var de_UnsupportedOperationRes = async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new UnsupportedOperation({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+};
+var se_BinaryList = (input, context) => {
+  return input.filter((e3) => e3 != null).map((entry) => {
+    return context.base64Encoder(entry);
+  });
+};
+var se_ChangeMessageVisibilityRequest = (input, context) => {
+  return take(input, {
+    QueueUrl: _toStr,
+    ReceiptHandle: _toStr,
+    VisibilityTimeout: _toNum
+  });
+};
+var se_MessageAttributeValue = (input, context) => {
+  return take(input, {
+    BinaryListValues: (_) => se_BinaryList(_, context),
+    BinaryValue: context.base64Encoder,
+    DataType: _toStr,
+    StringListValues: (_) => se_StringList(_),
+    StringValue: _toStr
+  });
+};
+var se_MessageBodyAttributeMap = (input, context) => {
+  return Object.entries(input).reduce((acc, [key, value]) => {
+    if (value === null) {
+      return acc;
+    }
+    acc[key] = se_MessageAttributeValue(value, context);
+    return acc;
+  }, {});
+};
+var se_MessageBodySystemAttributeMap = (input, context) => {
+  return Object.entries(input).reduce((acc, [key, value]) => {
+    if (value === null) {
+      return acc;
+    }
+    acc[key] = se_MessageSystemAttributeValue(value, context);
+    return acc;
+  }, {});
+};
+var se_MessageSystemAttributeValue = (input, context) => {
+  return take(input, {
+    BinaryListValues: (_) => se_BinaryList(_, context),
+    BinaryValue: context.base64Encoder,
+    DataType: _toStr,
+    StringListValues: (_) => se_StringList(_),
+    StringValue: _toStr
+  });
+};
+var se_SendMessageBatchRequest = (input, context) => {
+  return take(input, {
+    Entries: (_) => se_SendMessageBatchRequestEntryList(_, context),
+    QueueUrl: _toStr
+  });
+};
+var se_SendMessageBatchRequestEntry = (input, context) => {
+  return take(input, {
+    DelaySeconds: _toNum,
+    Id: _toStr,
+    MessageAttributes: (_) => se_MessageBodyAttributeMap(_, context),
+    MessageBody: _toStr,
+    MessageDeduplicationId: _toStr,
+    MessageGroupId: _toStr,
+    MessageSystemAttributes: (_) => se_MessageBodySystemAttributeMap(_, context)
+  });
+};
+var se_SendMessageBatchRequestEntryList = (input, context) => {
+  return input.filter((e3) => e3 != null).map((entry) => {
+    return se_SendMessageBatchRequestEntry(entry, context);
+  });
+};
+var se_SendMessageRequest = (input, context) => {
+  return take(input, {
+    DelaySeconds: _toNum,
+    MessageAttributes: (_) => se_MessageBodyAttributeMap(_, context),
+    MessageBody: _toStr,
+    MessageDeduplicationId: _toStr,
+    MessageGroupId: _toStr,
+    MessageSystemAttributes: (_) => se_MessageBodySystemAttributeMap(_, context),
+    QueueUrl: _toStr
+  });
+};
+var se_StringList = (input, context) => {
+  return input.filter((e3) => e3 != null).map((entry) => {
+    return _toStr(entry);
+  });
+};
+var deserializeMetadata = (output) => ({
+  httpStatusCode: output.statusCode,
+  requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
+  extendedRequestId: output.headers["x-amz-id-2"],
+  cfId: output.headers["x-amz-cf-id"]
+});
+var throwDefaultError = withBaseException(SQSServiceException);
+var buildHttpRpcRequest = async (context, headers, path, resolvedHostname, body) => {
+  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+  const contents = {
+    protocol,
+    hostname,
+    port,
+    method: "POST",
+    path: basePath.endsWith("/") ? basePath.slice(0, -1) + path : basePath + path,
+    headers
+  };
+  if (body !== void 0) {
+    contents.body = body;
+  }
+  return new HttpRequest(contents);
+};
+function sharedHeaders(operation) {
+  return {
+    "content-type": "application/x-amz-json-1.0",
+    "x-amz-target": `AmazonSQS.${operation}`,
+    "x-amzn-query-mode": "true"
+  };
+}
+var populateBodyWithQueryCompatibility = (parsedOutput, headers) => {
+  const queryErrorHeader = headers["x-amzn-query-error"];
+  if (parsedOutput.body !== void 0 && queryErrorHeader != null) {
+    const codeAndType = queryErrorHeader.split(";");
+    parsedOutput.body.Code = codeAndType[0];
+    parsedOutput.body.Type = codeAndType[1];
+  }
+};
+
+// ../../node_modules/@aws-sdk/client-sqs/dist-es/commands/ChangeMessageVisibilityCommand.js
+var ChangeMessageVisibilityCommand = class extends Command.classBuilder().ep(commonParams).m(function(Command2, cs, config, o3) {
+  return [
+    getSerdePlugin(config, this.serialize, this.deserialize),
+    getEndpointPlugin(config, Command2.getEndpointParameterInstructions())
+  ];
+}).s("AmazonSQS", "ChangeMessageVisibility", {}).n("SQSClient", "ChangeMessageVisibilityCommand").f(void 0, void 0).ser(se_ChangeMessageVisibilityCommand).de(de_ChangeMessageVisibilityCommand).build() {
+};
+
+// ../../node_modules/@aws-sdk/client-sqs/dist-es/commands/SendMessageBatchCommand.js
+var SendMessageBatchCommand = class extends Command.classBuilder().ep(commonParams).m(function(Command2, cs, config, o3) {
+  return [
+    getSerdePlugin(config, this.serialize, this.deserialize),
+    getEndpointPlugin(config, Command2.getEndpointParameterInstructions()),
+    getSendMessageBatchPlugin(config)
+  ];
+}).s("AmazonSQS", "SendMessageBatch", {}).n("SQSClient", "SendMessageBatchCommand").f(void 0, void 0).ser(se_SendMessageBatchCommand).de(de_SendMessageBatchCommand).build() {
+};
+
+// ../../node_modules/@aws-sdk/client-sqs/dist-es/commands/SendMessageCommand.js
+var SendMessageCommand = class extends Command.classBuilder().ep(commonParams).m(function(Command2, cs, config, o3) {
+  return [
+    getSerdePlugin(config, this.serialize, this.deserialize),
+    getEndpointPlugin(config, Command2.getEndpointParameterInstructions()),
+    getSendMessagePlugin(config)
+  ];
+}).s("AmazonSQS", "SendMessage", {}).n("SQSClient", "SendMessageCommand").f(void 0, void 0).ser(se_SendMessageCommand).de(de_SendMessageCommand).build() {
+};
+
+// ../task-sqs-adapter/dist/esm/snake-case.js
+var magicSplit = /^[a-zà-öø-ÿа-я]+|[A-ZÀ-ÖØ-ßА-Я][a-zà-öø-ÿа-я]+|[a-zà-öø-ÿа-я]+|[0-9]+|[A-ZÀ-ÖØ-ßА-Я]+(?![a-zà-öø-ÿа-я])/g;
+var spaceSplit = /\S+/g;
+function getPartsAndIndexes(string, splitRegex) {
+  const result = { parts: [], prefixes: [] };
+  const matches = string.matchAll(splitRegex);
+  let lastWordEndIndex = 0;
+  for (const match of matches) {
+    if (typeof match.index !== "number")
+      continue;
+    const word = match[0];
+    result.parts.push(word);
+    const prefix = string.slice(lastWordEndIndex, match.index).trim();
+    result.prefixes.push(prefix);
+    lastWordEndIndex = match.index + word.length;
+  }
+  const tail = string.slice(lastWordEndIndex).trim();
+  if (tail) {
+    result.parts.push("");
+    result.prefixes.push(tail);
+  }
+  return result;
+}
+function splitAndPrefix(string, options) {
+  const { keepSpecialCharacters = false, keep, prefix = "" } = options || {};
+  const normalString = string.trim().normalize("NFC");
+  const hasSpaces = normalString.includes(" ");
+  const split = hasSpaces ? spaceSplit : magicSplit;
+  const partsAndIndexes = getPartsAndIndexes(normalString, split);
+  return partsAndIndexes.parts.map((_part, i3) => {
+    let foundPrefix = partsAndIndexes.prefixes[i3] || "";
+    let part = _part;
+    if (keepSpecialCharacters === false) {
+      if (keep) {
+        part = part.normalize("NFD").replace(new RegExp(`[^a-zA-Z\xD8\xDF\xF80-9${keep.join("")}]`, "g"), "");
+      }
+      if (!keep) {
+        part = part.normalize("NFD").replace(/[^a-zA-ZØßø0-9]/g, "");
+        foundPrefix = "";
+      }
+    }
+    if (keep && foundPrefix) {
+      foundPrefix = foundPrefix.replace(new RegExp(`[^${keep.join("")}]`, "g"), "");
+    }
+    if (i3 === 0) {
+      return foundPrefix + part;
+    }
+    if (!foundPrefix && !part)
+      return "";
+    if (!hasSpaces) {
+      return (foundPrefix || prefix) + part;
+    }
+    if (!foundPrefix && prefix.match(/\s/)) {
+      return " " + part;
+    }
+    return (foundPrefix || prefix) + part;
+  }).filter(Boolean);
+}
+function snakeCase(string, options) {
+  return splitAndPrefix(string, { ...options, prefix: "_" }).join("").toLowerCase();
+}
+
+// ../task-sqs-adapter/dist/esm/dispatcher.js
+var sqsClient = new SQSClient({});
+async function dispatcher(task, data, options) {
+  if (!Array.isArray(data)) {
+    validateJsonStringified(data);
+    return await sendTask(task, options, data);
+  } else {
+    data.forEach((d3) => validateJsonStringified(d3));
+    return await sendTaskBatch(task, options, data);
+  }
+}
+async function sendTask(task, options, data) {
+  const queueUrl = sqsTaskQueueURL(task.id);
+  const executionId = randomUUID();
+  await sqsClient.send(new SendMessageCommand(messageEntry(task, queueUrl, options, executionId, data)));
+  return executionId;
+}
+async function sendTaskBatch(task, options, data) {
+  const queueUrl = sqsTaskQueueURL(task.id);
+  const entries = data.map((p3) => {
+    const executionId = randomUUID();
+    return {
+      ...messageEntry(task, queueUrl, options, executionId, p3),
+      Id: executionId
+    };
+  });
+  await sqsClient.send(new SendMessageBatchCommand({
+    QueueUrl: queueUrl,
+    Entries: entries
+  }));
+  return entries.map((entry) => entry.Id);
+}
+function sqsTaskQueueURL(taskId) {
+  return process.env[`ML_TASK_${snakeCase(taskId).toUpperCase()}_SQS_QUEUE_URL`];
+}
+function messageEntry(task, queueUrl, options, executionId, data) {
+  const messageAttributes = {
+    taskId: {
+      DataType: "String",
+      StringValue: task.id
+    },
+    executionId: {
+      DataType: "String",
+      StringValue: executionId
+    },
+    attempts: {
+      DataType: "String",
+      StringValue: String(task.options?.retry?.times ?? 1)
+    }
+  };
+  return {
+    QueueUrl: queueUrl,
+    DelaySeconds: options?.delay ? options.delay / 1e3 : void 0,
+    MessageAttributes: messageAttributes,
+    MessageBody: JSON.stringify(data)
+  };
+}
+function validateJsonStringified(data, max = 256e3) {
+  const dataString = JSON.stringify(typeof data === "undefined" ? {} : data);
+  const byteLength = Buffer.byteLength(dataString, "utf8");
+  if (byteLength > max) {
+    throw new Error(`Data size exceeds the limit (${max} bytes)`);
+  }
+}
+
+// ../../node_modules/@aws-sdk/client-dynamodb/node_modules/@aws-sdk/core/dist-es/submodules/account-id-endpoint/AccountIdEndpointModeConstants.js
+var DEFAULT_ACCOUNT_ID_ENDPOINT_MODE = "preferred";
+var ACCOUNT_ID_ENDPOINT_MODE_VALUES = ["disabled", "preferred", "required"];
+function validateAccountIdEndpointMode(value) {
+  return ACCOUNT_ID_ENDPOINT_MODE_VALUES.includes(value);
+}
+
+// ../../node_modules/@aws-sdk/client-dynamodb/node_modules/@aws-sdk/core/dist-es/submodules/account-id-endpoint/AccountIdEndpointModeConfigResolver.js
+var resolveAccountIdEndpointModeConfig = (input) => {
+  const { accountIdEndpointMode } = input;
+  const accountIdEndpointModeProvider = normalizeProvider(accountIdEndpointMode ?? DEFAULT_ACCOUNT_ID_ENDPOINT_MODE);
+  return Object.assign(input, {
+    accountIdEndpointMode: async () => {
+      const accIdMode = await accountIdEndpointModeProvider();
+      if (!validateAccountIdEndpointMode(accIdMode)) {
+        throw new Error(`Invalid value for accountIdEndpointMode: ${accIdMode}. Valid values are: "required", "preferred", "disabled".`);
+      }
+      return accIdMode;
+    }
+  });
+};
+
+// ../../node_modules/@aws-sdk/client-dynamodb/node_modules/@aws-sdk/core/dist-es/submodules/account-id-endpoint/NodeAccountIdEndpointModeConfigOptions.js
+var err = "Invalid AccountIdEndpointMode value";
+var _throw = (message) => {
+  throw new Error(message);
+};
+var ENV_ACCOUNT_ID_ENDPOINT_MODE = "AWS_ACCOUNT_ID_ENDPOINT_MODE";
+var CONFIG_ACCOUNT_ID_ENDPOINT_MODE = "account_id_endpoint_mode";
+var NODE_ACCOUNT_ID_ENDPOINT_MODE_CONFIG_OPTIONS = {
+  environmentVariableSelector: (env) => {
+    const value = env[ENV_ACCOUNT_ID_ENDPOINT_MODE];
+    if (value && !validateAccountIdEndpointMode(value)) {
+      _throw(err);
+    }
+    return value;
+  },
+  configFileSelector: (profile) => {
+    const value = profile[CONFIG_ACCOUNT_ID_ENDPOINT_MODE];
+    if (value && !validateAccountIdEndpointMode(value)) {
+      _throw(err);
+    }
+    return value;
+  },
+  default: DEFAULT_ACCOUNT_ID_ENDPOINT_MODE
+};
+
+// ../../node_modules/@aws-sdk/middleware-endpoint-discovery/dist-es/configurations.js
+var ENV_ENDPOINT_DISCOVERY = ["AWS_ENABLE_ENDPOINT_DISCOVERY", "AWS_ENDPOINT_DISCOVERY_ENABLED"];
+var CONFIG_ENDPOINT_DISCOVERY = "endpoint_discovery_enabled";
+var isFalsy = (value) => ["false", "0"].indexOf(value) >= 0;
+var NODE_ENDPOINT_DISCOVERY_CONFIG_OPTIONS = {
+  environmentVariableSelector: (env) => {
+    for (let i3 = 0; i3 < ENV_ENDPOINT_DISCOVERY.length; i3++) {
+      const envKey = ENV_ENDPOINT_DISCOVERY[i3];
+      if (envKey in env) {
+        const value = env[envKey];
+        if (value === "") {
+          throw Error(`Environment variable ${envKey} can't be empty of undefined, got "${value}"`);
+        }
+        return !isFalsy(value);
+      }
+    }
+  },
+  configFileSelector: (profile) => {
+    if (CONFIG_ENDPOINT_DISCOVERY in profile) {
+      const value = profile[CONFIG_ENDPOINT_DISCOVERY];
+      if (value === void 0) {
+        throw Error(`Shared config entry ${CONFIG_ENDPOINT_DISCOVERY} can't be undefined, got "${value}"`);
+      }
+      return !isFalsy(value);
+    }
+  },
+  default: void 0
+};
+
+// ../../node_modules/@aws-sdk/endpoint-cache/dist-es/EndpointCache.js
+var import_lru_cache = __toESM(require_lru_cache());
+var EndpointCache2 = class {
+  cache;
+  constructor(capacity) {
+    this.cache = new import_lru_cache.default(capacity);
+  }
+  getEndpoint(key) {
+    const endpointsWithExpiry = this.get(key);
+    if (!endpointsWithExpiry || endpointsWithExpiry.length === 0) {
+      return void 0;
+    }
+    const endpoints = endpointsWithExpiry.map((endpoint) => endpoint.Address);
+    return endpoints[Math.floor(Math.random() * endpoints.length)];
+  }
+  get(key) {
+    if (!this.has(key)) {
+      return;
+    }
+    const value = this.cache.get(key);
+    if (!value) {
+      return;
+    }
+    const now = Date.now();
+    const endpointsWithExpiry = value.filter((endpoint) => now < endpoint.Expires);
+    if (endpointsWithExpiry.length === 0) {
+      this.delete(key);
+      return void 0;
+    }
+    return endpointsWithExpiry;
+  }
+  set(key, endpoints) {
+    const now = Date.now();
+    this.cache.set(key, endpoints.map(({ Address, CachePeriodInMinutes }) => ({
+      Address,
+      Expires: now + CachePeriodInMinutes * 60 * 1e3
+    })));
+  }
+  delete(key) {
+    this.cache.set(key, []);
+  }
+  has(key) {
+    if (!this.cache.has(key)) {
+      return false;
+    }
+    const endpoints = this.cache.peek(key);
+    if (!endpoints) {
+      return false;
+    }
+    return endpoints.length > 0;
+  }
+  clear() {
+    this.cache.clear();
+  }
+};
+
+// ../../node_modules/@aws-sdk/middleware-endpoint-discovery/dist-es/resolveEndpointDiscoveryConfig.js
+var resolveEndpointDiscoveryConfig = (input, { endpointDiscoveryCommandCtor }) => {
+  const { endpointCacheSize, endpointDiscoveryEnabled, endpointDiscoveryEnabledProvider } = input;
+  return Object.assign(input, {
+    endpointDiscoveryCommandCtor,
+    endpointCache: new EndpointCache2(endpointCacheSize ?? 1e3),
+    endpointDiscoveryEnabled: endpointDiscoveryEnabled !== void 0 ? () => Promise.resolve(endpointDiscoveryEnabled) : endpointDiscoveryEnabledProvider,
+    isClientEndpointDiscoveryEnabled: endpointDiscoveryEnabled !== void 0
+  });
+};
+
+// ../../node_modules/@aws-sdk/client-dynamodb/node_modules/@aws-sdk/core/dist-es/submodules/protocols/json/awsExpectUnion.js
+var awsExpectUnion = (value) => {
+  if (value == null) {
+    return void 0;
+  }
+  if (typeof value === "object" && "__type" in value) {
+    delete value.__type;
+  }
+  return expectUnion(value);
+};
+
+// ../../node_modules/@aws-sdk/client-dynamodb/dist-es/auth/httpAuthSchemeProvider.js
+var defaultDynamoDBHttpAuthSchemeParametersProvider = async (config, context, input) => {
+  return {
+    operation: getSmithyContext(context).operation,
+    region: await normalizeProvider(config.region)() || (() => {
+      throw new Error("expected `region` to be configured for `aws.auth#sigv4`");
+    })()
+  };
+};
+function createAwsAuthSigv4HttpAuthOption2(authParameters) {
+  return {
+    schemeId: "aws.auth#sigv4",
+    signingProperties: {
+      name: "dynamodb",
+      region: authParameters.region
+    },
+    propertiesExtractor: (config, context) => ({
+      signingProperties: {
+        config,
+        context
+      }
+    })
+  };
+}
+var defaultDynamoDBHttpAuthSchemeProvider = (authParameters) => {
+  const options = [];
+  switch (authParameters.operation) {
+    default: {
+      options.push(createAwsAuthSigv4HttpAuthOption2(authParameters));
+    }
+  }
+  return options;
+};
+var resolveHttpAuthSchemeConfig2 = (config) => {
+  const config_0 = resolveAwsSdkSigV4Config$1(config);
+  return Object.assign(config_0, {
+    authSchemePreference: normalizeProvider(config.authSchemePreference ?? [])
+  });
+};
+
+// ../../node_modules/@aws-sdk/client-dynamodb/dist-es/endpoint/EndpointParameters.js
+var resolveClientEndpointParameters2 = (options) => {
+  return Object.assign(options, {
+    useDualstackEndpoint: options.useDualstackEndpoint ?? false,
+    useFipsEndpoint: options.useFipsEndpoint ?? false,
+    defaultSigningName: "dynamodb"
+  });
+};
+var commonParams2 = {
+  UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+  AccountId: { type: "builtInParams", name: "accountId" },
+  Endpoint: { type: "builtInParams", name: "endpoint" },
+  Region: { type: "builtInParams", name: "region" },
+  UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+  AccountIdEndpointMode: { type: "builtInParams", name: "accountIdEndpointMode" }
+};
+
+// ../../node_modules/@aws-sdk/client-dynamodb/dist-es/models/DynamoDBServiceException.js
+var DynamoDBServiceException = class _DynamoDBServiceException extends ServiceException {
+  constructor(options) {
+    super(options);
+    Object.setPrototypeOf(this, _DynamoDBServiceException.prototype);
+  }
+};
+
+// ../../node_modules/@aws-sdk/client-dynamodb/dist-es/models/models_0.js
+var BackupInUseException = class _BackupInUseException extends DynamoDBServiceException {
+  name = "BackupInUseException";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "BackupInUseException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _BackupInUseException.prototype);
+  }
+};
+var BackupNotFoundException = class _BackupNotFoundException extends DynamoDBServiceException {
+  name = "BackupNotFoundException";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "BackupNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _BackupNotFoundException.prototype);
+  }
+};
+var InternalServerError = class _InternalServerError extends DynamoDBServiceException {
+  name = "InternalServerError";
+  $fault = "server";
+  constructor(opts) {
+    super({
+      name: "InternalServerError",
+      $fault: "server",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _InternalServerError.prototype);
+  }
+};
+var RequestLimitExceeded = class _RequestLimitExceeded extends DynamoDBServiceException {
+  name = "RequestLimitExceeded";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "RequestLimitExceeded",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _RequestLimitExceeded.prototype);
+  }
+};
+var InvalidEndpointException = class _InvalidEndpointException extends DynamoDBServiceException {
+  name = "InvalidEndpointException";
+  $fault = "client";
+  Message;
+  constructor(opts) {
+    super({
+      name: "InvalidEndpointException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _InvalidEndpointException.prototype);
+    this.Message = opts.Message;
+  }
+};
+var ProvisionedThroughputExceededException = class _ProvisionedThroughputExceededException extends DynamoDBServiceException {
+  name = "ProvisionedThroughputExceededException";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "ProvisionedThroughputExceededException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _ProvisionedThroughputExceededException.prototype);
+  }
+};
+var ResourceNotFoundException2 = class _ResourceNotFoundException extends DynamoDBServiceException {
+  name = "ResourceNotFoundException";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "ResourceNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _ResourceNotFoundException.prototype);
+  }
+};
+var ItemCollectionSizeLimitExceededException = class _ItemCollectionSizeLimitExceededException extends DynamoDBServiceException {
+  name = "ItemCollectionSizeLimitExceededException";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "ItemCollectionSizeLimitExceededException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _ItemCollectionSizeLimitExceededException.prototype);
+  }
+};
+var ContinuousBackupsUnavailableException = class _ContinuousBackupsUnavailableException extends DynamoDBServiceException {
+  name = "ContinuousBackupsUnavailableException";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "ContinuousBackupsUnavailableException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _ContinuousBackupsUnavailableException.prototype);
+  }
+};
+var LimitExceededException = class _LimitExceededException extends DynamoDBServiceException {
+  name = "LimitExceededException";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "LimitExceededException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _LimitExceededException.prototype);
+  }
+};
+var TableInUseException = class _TableInUseException extends DynamoDBServiceException {
+  name = "TableInUseException";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "TableInUseException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _TableInUseException.prototype);
+  }
+};
+var TableNotFoundException = class _TableNotFoundException extends DynamoDBServiceException {
+  name = "TableNotFoundException";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "TableNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _TableNotFoundException.prototype);
+  }
+};
+var GlobalTableAlreadyExistsException = class _GlobalTableAlreadyExistsException extends DynamoDBServiceException {
+  name = "GlobalTableAlreadyExistsException";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "GlobalTableAlreadyExistsException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _GlobalTableAlreadyExistsException.prototype);
+  }
+};
+var ResourceInUseException = class _ResourceInUseException extends DynamoDBServiceException {
+  name = "ResourceInUseException";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "ResourceInUseException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _ResourceInUseException.prototype);
+  }
+};
+var ReplicatedWriteConflictException = class _ReplicatedWriteConflictException extends DynamoDBServiceException {
+  name = "ReplicatedWriteConflictException";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "ReplicatedWriteConflictException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _ReplicatedWriteConflictException.prototype);
+  }
+};
+var TransactionConflictException = class _TransactionConflictException extends DynamoDBServiceException {
+  name = "TransactionConflictException";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "TransactionConflictException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _TransactionConflictException.prototype);
+  }
+};
+var PolicyNotFoundException = class _PolicyNotFoundException extends DynamoDBServiceException {
+  name = "PolicyNotFoundException";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "PolicyNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _PolicyNotFoundException.prototype);
+  }
+};
+var ExportNotFoundException = class _ExportNotFoundException extends DynamoDBServiceException {
+  name = "ExportNotFoundException";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "ExportNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _ExportNotFoundException.prototype);
+  }
+};
+var GlobalTableNotFoundException = class _GlobalTableNotFoundException extends DynamoDBServiceException {
+  name = "GlobalTableNotFoundException";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "GlobalTableNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _GlobalTableNotFoundException.prototype);
+  }
+};
+var ImportNotFoundException = class _ImportNotFoundException extends DynamoDBServiceException {
+  name = "ImportNotFoundException";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "ImportNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _ImportNotFoundException.prototype);
+  }
+};
+var DuplicateItemException = class _DuplicateItemException extends DynamoDBServiceException {
+  name = "DuplicateItemException";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "DuplicateItemException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _DuplicateItemException.prototype);
+  }
+};
+var IdempotentParameterMismatchException = class _IdempotentParameterMismatchException extends DynamoDBServiceException {
+  name = "IdempotentParameterMismatchException";
+  $fault = "client";
+  Message;
+  constructor(opts) {
+    super({
+      name: "IdempotentParameterMismatchException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _IdempotentParameterMismatchException.prototype);
+    this.Message = opts.Message;
+  }
+};
+var TransactionInProgressException = class _TransactionInProgressException extends DynamoDBServiceException {
+  name = "TransactionInProgressException";
+  $fault = "client";
+  Message;
+  constructor(opts) {
+    super({
+      name: "TransactionInProgressException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _TransactionInProgressException.prototype);
+    this.Message = opts.Message;
+  }
+};
+var ExportConflictException = class _ExportConflictException extends DynamoDBServiceException {
+  name = "ExportConflictException";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "ExportConflictException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _ExportConflictException.prototype);
+  }
+};
+var InvalidExportTimeException = class _InvalidExportTimeException extends DynamoDBServiceException {
+  name = "InvalidExportTimeException";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "InvalidExportTimeException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _InvalidExportTimeException.prototype);
+  }
+};
+var PointInTimeRecoveryUnavailableException = class _PointInTimeRecoveryUnavailableException extends DynamoDBServiceException {
+  name = "PointInTimeRecoveryUnavailableException";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "PointInTimeRecoveryUnavailableException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _PointInTimeRecoveryUnavailableException.prototype);
+  }
+};
+var ImportConflictException = class _ImportConflictException extends DynamoDBServiceException {
+  name = "ImportConflictException";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "ImportConflictException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _ImportConflictException.prototype);
+  }
+};
+var TableAlreadyExistsException = class _TableAlreadyExistsException extends DynamoDBServiceException {
+  name = "TableAlreadyExistsException";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "TableAlreadyExistsException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _TableAlreadyExistsException.prototype);
+  }
+};
+var InvalidRestoreTimeException = class _InvalidRestoreTimeException extends DynamoDBServiceException {
+  name = "InvalidRestoreTimeException";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "InvalidRestoreTimeException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _InvalidRestoreTimeException.prototype);
+  }
+};
+var ReplicaAlreadyExistsException = class _ReplicaAlreadyExistsException extends DynamoDBServiceException {
+  name = "ReplicaAlreadyExistsException";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "ReplicaAlreadyExistsException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _ReplicaAlreadyExistsException.prototype);
+  }
+};
+var ReplicaNotFoundException = class _ReplicaNotFoundException extends DynamoDBServiceException {
+  name = "ReplicaNotFoundException";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "ReplicaNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _ReplicaNotFoundException.prototype);
+  }
+};
+var IndexNotFoundException = class _IndexNotFoundException extends DynamoDBServiceException {
+  name = "IndexNotFoundException";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "IndexNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _IndexNotFoundException.prototype);
+  }
+};
+var AttributeValue;
+(function(AttributeValue2) {
+  AttributeValue2.visit = (value, visitor) => {
+    if (value.S !== void 0)
+      return visitor.S(value.S);
+    if (value.N !== void 0)
+      return visitor.N(value.N);
+    if (value.B !== void 0)
+      return visitor.B(value.B);
+    if (value.SS !== void 0)
+      return visitor.SS(value.SS);
+    if (value.NS !== void 0)
+      return visitor.NS(value.NS);
+    if (value.BS !== void 0)
+      return visitor.BS(value.BS);
+    if (value.M !== void 0)
+      return visitor.M(value.M);
+    if (value.L !== void 0)
+      return visitor.L(value.L);
+    if (value.NULL !== void 0)
+      return visitor.NULL(value.NULL);
+    if (value.BOOL !== void 0)
+      return visitor.BOOL(value.BOOL);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  };
+})(AttributeValue || (AttributeValue = {}));
+var ConditionalCheckFailedException = class _ConditionalCheckFailedException extends DynamoDBServiceException {
+  name = "ConditionalCheckFailedException";
+  $fault = "client";
+  Item;
+  constructor(opts) {
+    super({
+      name: "ConditionalCheckFailedException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _ConditionalCheckFailedException.prototype);
+    this.Item = opts.Item;
+  }
+};
+var TransactionCanceledException = class _TransactionCanceledException extends DynamoDBServiceException {
+  name = "TransactionCanceledException";
+  $fault = "client";
+  Message;
+  CancellationReasons;
+  constructor(opts) {
+    super({
+      name: "TransactionCanceledException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _TransactionCanceledException.prototype);
+    this.Message = opts.Message;
+    this.CancellationReasons = opts.CancellationReasons;
+  }
+};
+
+// ../../node_modules/@aws-sdk/client-dynamodb/dist-es/protocols/Aws_json1_0.js
+var se_BatchWriteItemCommand = async (input, context) => {
+  const headers = sharedHeaders2("BatchWriteItem");
+  let body;
+  body = JSON.stringify(se_BatchWriteItemInput(input, context));
+  return buildHttpRpcRequest2(context, headers, "/", void 0, body);
+};
+var se_DescribeEndpointsCommand = async (input, context) => {
+  const headers = sharedHeaders2("DescribeEndpoints");
+  let body;
+  body = JSON.stringify(_json(input));
+  return buildHttpRpcRequest2(context, headers, "/", void 0, body);
+};
+var se_PutItemCommand = async (input, context) => {
+  const headers = sharedHeaders2("PutItem");
+  let body;
+  body = JSON.stringify(se_PutItemInput(input, context));
+  return buildHttpRpcRequest2(context, headers, "/", void 0, body);
+};
+var se_QueryCommand = async (input, context) => {
+  const headers = sharedHeaders2("Query");
+  let body;
+  body = JSON.stringify(se_QueryInput(input, context));
+  return buildHttpRpcRequest2(context, headers, "/", void 0, body);
+};
+var se_ScanCommand = async (input, context) => {
+  const headers = sharedHeaders2("Scan");
+  let body;
+  body = JSON.stringify(se_ScanInput(input, context));
+  return buildHttpRpcRequest2(context, headers, "/", void 0, body);
+};
+var se_UpdateItemCommand = async (input, context) => {
+  const headers = sharedHeaders2("UpdateItem");
+  let body;
+  body = JSON.stringify(se_UpdateItemInput(input, context));
+  return buildHttpRpcRequest2(context, headers, "/", void 0, body);
+};
+var de_BatchWriteItemCommand = async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError2(output, context);
+  }
+  const data = await parseJsonBody$1(output.body, context);
+  let contents = {};
+  contents = de_BatchWriteItemOutput(data, context);
+  const response = {
+    $metadata: deserializeMetadata2(output),
+    ...contents
+  };
+  return response;
+};
+var de_DescribeEndpointsCommand = async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError2(output, context);
+  }
+  const data = await parseJsonBody$1(output.body, context);
+  let contents = {};
+  contents = _json(data);
+  const response = {
+    $metadata: deserializeMetadata2(output),
+    ...contents
+  };
+  return response;
+};
+var de_PutItemCommand = async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError2(output, context);
+  }
+  const data = await parseJsonBody$1(output.body, context);
+  let contents = {};
+  contents = de_PutItemOutput(data, context);
+  const response = {
+    $metadata: deserializeMetadata2(output),
+    ...contents
+  };
+  return response;
+};
+var de_QueryCommand = async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError2(output, context);
+  }
+  const data = await parseJsonBody$1(output.body, context);
+  let contents = {};
+  contents = de_QueryOutput(data, context);
+  const response = {
+    $metadata: deserializeMetadata2(output),
+    ...contents
+  };
+  return response;
+};
+var de_ScanCommand = async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError2(output, context);
+  }
+  const data = await parseJsonBody$1(output.body, context);
+  let contents = {};
+  contents = de_ScanOutput(data, context);
+  const response = {
+    $metadata: deserializeMetadata2(output),
+    ...contents
+  };
+  return response;
+};
+var de_UpdateItemCommand = async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError2(output, context);
+  }
+  const data = await parseJsonBody$1(output.body, context);
+  let contents = {};
+  contents = de_UpdateItemOutput(data, context);
+  const response = {
+    $metadata: deserializeMetadata2(output),
+    ...contents
+  };
+  return response;
+};
+var de_CommandError2 = async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseJsonErrorBody$1(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode$1(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServerError":
+    case "com.amazonaws.dynamodb#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput);
+    case "RequestLimitExceeded":
+    case "com.amazonaws.dynamodb#RequestLimitExceeded":
+      throw await de_RequestLimitExceededRes(parsedOutput);
+    case "InvalidEndpointException":
+    case "com.amazonaws.dynamodb#InvalidEndpointException":
+      throw await de_InvalidEndpointExceptionRes(parsedOutput);
+    case "ProvisionedThroughputExceededException":
+    case "com.amazonaws.dynamodb#ProvisionedThroughputExceededException":
+      throw await de_ProvisionedThroughputExceededExceptionRes(parsedOutput);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.dynamodb#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes2(parsedOutput);
+    case "ItemCollectionSizeLimitExceededException":
+    case "com.amazonaws.dynamodb#ItemCollectionSizeLimitExceededException":
+      throw await de_ItemCollectionSizeLimitExceededExceptionRes(parsedOutput);
+    case "BackupInUseException":
+    case "com.amazonaws.dynamodb#BackupInUseException":
+      throw await de_BackupInUseExceptionRes(parsedOutput);
+    case "ContinuousBackupsUnavailableException":
+    case "com.amazonaws.dynamodb#ContinuousBackupsUnavailableException":
+      throw await de_ContinuousBackupsUnavailableExceptionRes(parsedOutput);
+    case "LimitExceededException":
+    case "com.amazonaws.dynamodb#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput);
+    case "TableInUseException":
+    case "com.amazonaws.dynamodb#TableInUseException":
+      throw await de_TableInUseExceptionRes(parsedOutput);
+    case "TableNotFoundException":
+    case "com.amazonaws.dynamodb#TableNotFoundException":
+      throw await de_TableNotFoundExceptionRes(parsedOutput);
+    case "GlobalTableAlreadyExistsException":
+    case "com.amazonaws.dynamodb#GlobalTableAlreadyExistsException":
+      throw await de_GlobalTableAlreadyExistsExceptionRes(parsedOutput);
+    case "ResourceInUseException":
+    case "com.amazonaws.dynamodb#ResourceInUseException":
+      throw await de_ResourceInUseExceptionRes(parsedOutput);
+    case "BackupNotFoundException":
+    case "com.amazonaws.dynamodb#BackupNotFoundException":
+      throw await de_BackupNotFoundExceptionRes(parsedOutput);
+    case "ConditionalCheckFailedException":
+    case "com.amazonaws.dynamodb#ConditionalCheckFailedException":
+      throw await de_ConditionalCheckFailedExceptionRes(parsedOutput, context);
+    case "ReplicatedWriteConflictException":
+    case "com.amazonaws.dynamodb#ReplicatedWriteConflictException":
+      throw await de_ReplicatedWriteConflictExceptionRes(parsedOutput);
+    case "TransactionConflictException":
+    case "com.amazonaws.dynamodb#TransactionConflictException":
+      throw await de_TransactionConflictExceptionRes(parsedOutput);
+    case "PolicyNotFoundException":
+    case "com.amazonaws.dynamodb#PolicyNotFoundException":
+      throw await de_PolicyNotFoundExceptionRes(parsedOutput);
+    case "ExportNotFoundException":
+    case "com.amazonaws.dynamodb#ExportNotFoundException":
+      throw await de_ExportNotFoundExceptionRes(parsedOutput);
+    case "GlobalTableNotFoundException":
+    case "com.amazonaws.dynamodb#GlobalTableNotFoundException":
+      throw await de_GlobalTableNotFoundExceptionRes(parsedOutput);
+    case "ImportNotFoundException":
+    case "com.amazonaws.dynamodb#ImportNotFoundException":
+      throw await de_ImportNotFoundExceptionRes(parsedOutput);
+    case "DuplicateItemException":
+    case "com.amazonaws.dynamodb#DuplicateItemException":
+      throw await de_DuplicateItemExceptionRes(parsedOutput);
+    case "IdempotentParameterMismatchException":
+    case "com.amazonaws.dynamodb#IdempotentParameterMismatchException":
+      throw await de_IdempotentParameterMismatchExceptionRes(parsedOutput);
+    case "TransactionCanceledException":
+    case "com.amazonaws.dynamodb#TransactionCanceledException":
+      throw await de_TransactionCanceledExceptionRes(parsedOutput, context);
+    case "TransactionInProgressException":
+    case "com.amazonaws.dynamodb#TransactionInProgressException":
+      throw await de_TransactionInProgressExceptionRes(parsedOutput);
+    case "ExportConflictException":
+    case "com.amazonaws.dynamodb#ExportConflictException":
+      throw await de_ExportConflictExceptionRes(parsedOutput);
+    case "InvalidExportTimeException":
+    case "com.amazonaws.dynamodb#InvalidExportTimeException":
+      throw await de_InvalidExportTimeExceptionRes(parsedOutput);
+    case "PointInTimeRecoveryUnavailableException":
+    case "com.amazonaws.dynamodb#PointInTimeRecoveryUnavailableException":
+      throw await de_PointInTimeRecoveryUnavailableExceptionRes(parsedOutput);
+    case "ImportConflictException":
+    case "com.amazonaws.dynamodb#ImportConflictException":
+      throw await de_ImportConflictExceptionRes(parsedOutput);
+    case "TableAlreadyExistsException":
+    case "com.amazonaws.dynamodb#TableAlreadyExistsException":
+      throw await de_TableAlreadyExistsExceptionRes(parsedOutput);
+    case "InvalidRestoreTimeException":
+    case "com.amazonaws.dynamodb#InvalidRestoreTimeException":
+      throw await de_InvalidRestoreTimeExceptionRes(parsedOutput);
+    case "ReplicaAlreadyExistsException":
+    case "com.amazonaws.dynamodb#ReplicaAlreadyExistsException":
+      throw await de_ReplicaAlreadyExistsExceptionRes(parsedOutput);
+    case "ReplicaNotFoundException":
+    case "com.amazonaws.dynamodb#ReplicaNotFoundException":
+      throw await de_ReplicaNotFoundExceptionRes(parsedOutput);
+    case "IndexNotFoundException":
+    case "com.amazonaws.dynamodb#IndexNotFoundException":
+      throw await de_IndexNotFoundExceptionRes(parsedOutput);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError2({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+};
+var de_BackupInUseExceptionRes = async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new BackupInUseException({
+    $metadata: deserializeMetadata2(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+};
+var de_BackupNotFoundExceptionRes = async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new BackupNotFoundException({
+    $metadata: deserializeMetadata2(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+};
+var de_ConditionalCheckFailedExceptionRes = async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = de_ConditionalCheckFailedException(body, context);
+  const exception = new ConditionalCheckFailedException({
+    $metadata: deserializeMetadata2(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+};
+var de_ContinuousBackupsUnavailableExceptionRes = async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new ContinuousBackupsUnavailableException({
+    $metadata: deserializeMetadata2(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+};
+var de_DuplicateItemExceptionRes = async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new DuplicateItemException({
+    $metadata: deserializeMetadata2(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+};
+var de_ExportConflictExceptionRes = async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new ExportConflictException({
+    $metadata: deserializeMetadata2(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+};
+var de_ExportNotFoundExceptionRes = async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new ExportNotFoundException({
+    $metadata: deserializeMetadata2(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+};
+var de_GlobalTableAlreadyExistsExceptionRes = async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new GlobalTableAlreadyExistsException({
+    $metadata: deserializeMetadata2(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+};
+var de_GlobalTableNotFoundExceptionRes = async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new GlobalTableNotFoundException({
+    $metadata: deserializeMetadata2(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+};
+var de_IdempotentParameterMismatchExceptionRes = async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new IdempotentParameterMismatchException({
+    $metadata: deserializeMetadata2(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+};
+var de_ImportConflictExceptionRes = async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new ImportConflictException({
+    $metadata: deserializeMetadata2(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+};
+var de_ImportNotFoundExceptionRes = async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new ImportNotFoundException({
+    $metadata: deserializeMetadata2(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+};
+var de_IndexNotFoundExceptionRes = async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new IndexNotFoundException({
+    $metadata: deserializeMetadata2(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+};
+var de_InternalServerErrorRes = async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new InternalServerError({
+    $metadata: deserializeMetadata2(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+};
+var de_InvalidEndpointExceptionRes = async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new InvalidEndpointException({
+    $metadata: deserializeMetadata2(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+};
+var de_InvalidExportTimeExceptionRes = async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new InvalidExportTimeException({
+    $metadata: deserializeMetadata2(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+};
+var de_InvalidRestoreTimeExceptionRes = async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new InvalidRestoreTimeException({
+    $metadata: deserializeMetadata2(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+};
+var de_ItemCollectionSizeLimitExceededExceptionRes = async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new ItemCollectionSizeLimitExceededException({
+    $metadata: deserializeMetadata2(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+};
+var de_LimitExceededExceptionRes = async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new LimitExceededException({
+    $metadata: deserializeMetadata2(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+};
+var de_PointInTimeRecoveryUnavailableExceptionRes = async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new PointInTimeRecoveryUnavailableException({
+    $metadata: deserializeMetadata2(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+};
+var de_PolicyNotFoundExceptionRes = async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new PolicyNotFoundException({
+    $metadata: deserializeMetadata2(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+};
+var de_ProvisionedThroughputExceededExceptionRes = async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new ProvisionedThroughputExceededException({
+    $metadata: deserializeMetadata2(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+};
+var de_ReplicaAlreadyExistsExceptionRes = async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new ReplicaAlreadyExistsException({
+    $metadata: deserializeMetadata2(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+};
+var de_ReplicaNotFoundExceptionRes = async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new ReplicaNotFoundException({
+    $metadata: deserializeMetadata2(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+};
+var de_ReplicatedWriteConflictExceptionRes = async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new ReplicatedWriteConflictException({
+    $metadata: deserializeMetadata2(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+};
+var de_RequestLimitExceededRes = async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new RequestLimitExceeded({
+    $metadata: deserializeMetadata2(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+};
+var de_ResourceInUseExceptionRes = async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new ResourceInUseException({
+    $metadata: deserializeMetadata2(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+};
+var de_ResourceNotFoundExceptionRes2 = async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new ResourceNotFoundException2({
+    $metadata: deserializeMetadata2(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+};
+var de_TableAlreadyExistsExceptionRes = async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new TableAlreadyExistsException({
+    $metadata: deserializeMetadata2(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+};
+var de_TableInUseExceptionRes = async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new TableInUseException({
+    $metadata: deserializeMetadata2(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+};
+var de_TableNotFoundExceptionRes = async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new TableNotFoundException({
+    $metadata: deserializeMetadata2(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+};
+var de_TransactionCanceledExceptionRes = async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = de_TransactionCanceledException(body, context);
+  const exception = new TransactionCanceledException({
+    $metadata: deserializeMetadata2(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+};
+var de_TransactionConflictExceptionRes = async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new TransactionConflictException({
+    $metadata: deserializeMetadata2(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+};
+var de_TransactionInProgressExceptionRes = async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new TransactionInProgressException({
+    $metadata: deserializeMetadata2(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+};
+var se_AttributeUpdates = (input, context) => {
+  return Object.entries(input).reduce((acc, [key, value]) => {
+    if (value === null) {
+      return acc;
+    }
+    acc[key] = se_AttributeValueUpdate(value, context);
+    return acc;
+  }, {});
+};
+var se_AttributeValue = (input, context) => {
+  return AttributeValue.visit(input, {
+    B: (value) => ({ B: context.base64Encoder(value) }),
+    BOOL: (value) => ({ BOOL: value }),
+    BS: (value) => ({ BS: se_BinarySetAttributeValue(value, context) }),
+    L: (value) => ({ L: se_ListAttributeValue(value, context) }),
+    M: (value) => ({ M: se_MapAttributeValue(value, context) }),
+    N: (value) => ({ N: value }),
+    NS: (value) => ({ NS: _json(value) }),
+    NULL: (value) => ({ NULL: value }),
+    S: (value) => ({ S: value }),
+    SS: (value) => ({ SS: _json(value) }),
+    _: (name, value) => ({ [name]: value })
+  });
+};
+var se_AttributeValueList = (input, context) => {
+  return input.filter((e3) => e3 != null).map((entry) => {
+    return se_AttributeValue(entry, context);
+  });
+};
+var se_AttributeValueUpdate = (input, context) => {
+  return take(input, {
+    Action: [],
+    Value: (_) => se_AttributeValue(_, context)
+  });
+};
+var se_BatchWriteItemInput = (input, context) => {
+  return take(input, {
+    RequestItems: (_) => se_BatchWriteItemRequestMap(_, context),
+    ReturnConsumedCapacity: [],
+    ReturnItemCollectionMetrics: []
+  });
+};
+var se_BatchWriteItemRequestMap = (input, context) => {
+  return Object.entries(input).reduce((acc, [key, value]) => {
+    if (value === null) {
+      return acc;
+    }
+    acc[key] = se_WriteRequests(value, context);
+    return acc;
+  }, {});
+};
+var se_BinarySetAttributeValue = (input, context) => {
+  return input.filter((e3) => e3 != null).map((entry) => {
+    return context.base64Encoder(entry);
+  });
+};
+var se_Condition = (input, context) => {
+  return take(input, {
+    AttributeValueList: (_) => se_AttributeValueList(_, context),
+    ComparisonOperator: []
+  });
+};
+var se_DeleteRequest = (input, context) => {
+  return take(input, {
+    Key: (_) => se_Key(_, context)
+  });
+};
+var se_ExpectedAttributeMap = (input, context) => {
+  return Object.entries(input).reduce((acc, [key, value]) => {
+    if (value === null) {
+      return acc;
+    }
+    acc[key] = se_ExpectedAttributeValue(value, context);
+    return acc;
+  }, {});
+};
+var se_ExpectedAttributeValue = (input, context) => {
+  return take(input, {
+    AttributeValueList: (_) => se_AttributeValueList(_, context),
+    ComparisonOperator: [],
+    Exists: [],
+    Value: (_) => se_AttributeValue(_, context)
+  });
+};
+var se_ExpressionAttributeValueMap = (input, context) => {
+  return Object.entries(input).reduce((acc, [key, value]) => {
+    if (value === null) {
+      return acc;
+    }
+    acc[key] = se_AttributeValue(value, context);
+    return acc;
+  }, {});
+};
+var se_FilterConditionMap = (input, context) => {
+  return Object.entries(input).reduce((acc, [key, value]) => {
+    if (value === null) {
+      return acc;
+    }
+    acc[key] = se_Condition(value, context);
+    return acc;
+  }, {});
+};
+var se_Key = (input, context) => {
+  return Object.entries(input).reduce((acc, [key, value]) => {
+    if (value === null) {
+      return acc;
+    }
+    acc[key] = se_AttributeValue(value, context);
+    return acc;
+  }, {});
+};
+var se_KeyConditions = (input, context) => {
+  return Object.entries(input).reduce((acc, [key, value]) => {
+    if (value === null) {
+      return acc;
+    }
+    acc[key] = se_Condition(value, context);
+    return acc;
+  }, {});
+};
+var se_ListAttributeValue = (input, context) => {
+  return input.filter((e3) => e3 != null).map((entry) => {
+    return se_AttributeValue(entry, context);
+  });
+};
+var se_MapAttributeValue = (input, context) => {
+  return Object.entries(input).reduce((acc, [key, value]) => {
+    if (value === null) {
+      return acc;
+    }
+    acc[key] = se_AttributeValue(value, context);
+    return acc;
+  }, {});
+};
+var se_PutItemInput = (input, context) => {
+  return take(input, {
+    ConditionExpression: [],
+    ConditionalOperator: [],
+    Expected: (_) => se_ExpectedAttributeMap(_, context),
+    ExpressionAttributeNames: _json,
+    ExpressionAttributeValues: (_) => se_ExpressionAttributeValueMap(_, context),
+    Item: (_) => se_PutItemInputAttributeMap(_, context),
+    ReturnConsumedCapacity: [],
+    ReturnItemCollectionMetrics: [],
+    ReturnValues: [],
+    ReturnValuesOnConditionCheckFailure: [],
+    TableName: []
+  });
+};
+var se_PutItemInputAttributeMap = (input, context) => {
+  return Object.entries(input).reduce((acc, [key, value]) => {
+    if (value === null) {
+      return acc;
+    }
+    acc[key] = se_AttributeValue(value, context);
+    return acc;
+  }, {});
+};
+var se_PutRequest = (input, context) => {
+  return take(input, {
+    Item: (_) => se_PutItemInputAttributeMap(_, context)
+  });
+};
+var se_QueryInput = (input, context) => {
+  return take(input, {
+    AttributesToGet: _json,
+    ConditionalOperator: [],
+    ConsistentRead: [],
+    ExclusiveStartKey: (_) => se_Key(_, context),
+    ExpressionAttributeNames: _json,
+    ExpressionAttributeValues: (_) => se_ExpressionAttributeValueMap(_, context),
+    FilterExpression: [],
+    IndexName: [],
+    KeyConditionExpression: [],
+    KeyConditions: (_) => se_KeyConditions(_, context),
+    Limit: [],
+    ProjectionExpression: [],
+    QueryFilter: (_) => se_FilterConditionMap(_, context),
+    ReturnConsumedCapacity: [],
+    ScanIndexForward: [],
+    Select: [],
+    TableName: []
+  });
+};
+var se_ScanInput = (input, context) => {
+  return take(input, {
+    AttributesToGet: _json,
+    ConditionalOperator: [],
+    ConsistentRead: [],
+    ExclusiveStartKey: (_) => se_Key(_, context),
+    ExpressionAttributeNames: _json,
+    ExpressionAttributeValues: (_) => se_ExpressionAttributeValueMap(_, context),
+    FilterExpression: [],
+    IndexName: [],
+    Limit: [],
+    ProjectionExpression: [],
+    ReturnConsumedCapacity: [],
+    ScanFilter: (_) => se_FilterConditionMap(_, context),
+    Segment: [],
+    Select: [],
+    TableName: [],
+    TotalSegments: []
+  });
+};
+var se_UpdateItemInput = (input, context) => {
+  return take(input, {
+    AttributeUpdates: (_) => se_AttributeUpdates(_, context),
+    ConditionExpression: [],
+    ConditionalOperator: [],
+    Expected: (_) => se_ExpectedAttributeMap(_, context),
+    ExpressionAttributeNames: _json,
+    ExpressionAttributeValues: (_) => se_ExpressionAttributeValueMap(_, context),
+    Key: (_) => se_Key(_, context),
+    ReturnConsumedCapacity: [],
+    ReturnItemCollectionMetrics: [],
+    ReturnValues: [],
+    ReturnValuesOnConditionCheckFailure: [],
+    TableName: [],
+    UpdateExpression: []
+  });
+};
+var se_WriteRequest = (input, context) => {
+  return take(input, {
+    DeleteRequest: (_) => se_DeleteRequest(_, context),
+    PutRequest: (_) => se_PutRequest(_, context)
+  });
+};
+var se_WriteRequests = (input, context) => {
+  return input.filter((e3) => e3 != null).map((entry) => {
+    return se_WriteRequest(entry, context);
+  });
+};
+var de_AttributeMap = (output, context) => {
+  return Object.entries(output).reduce((acc, [key, value]) => {
+    if (value === null) {
+      return acc;
+    }
+    acc[key] = de_AttributeValue(awsExpectUnion(value), context);
+    return acc;
+  }, {});
+};
+var de_AttributeValue = (output, context) => {
+  if (output.B != null) {
+    return {
+      B: context.base64Decoder(output.B)
+    };
+  }
+  if (expectBoolean(output.BOOL) !== void 0) {
+    return { BOOL: expectBoolean(output.BOOL) };
+  }
+  if (output.BS != null) {
+    return {
+      BS: de_BinarySetAttributeValue(output.BS, context)
+    };
+  }
+  if (output.L != null) {
+    return {
+      L: de_ListAttributeValue(output.L, context)
+    };
+  }
+  if (output.M != null) {
+    return {
+      M: de_MapAttributeValue(output.M, context)
+    };
+  }
+  if (expectString(output.N) !== void 0) {
+    return { N: expectString(output.N) };
+  }
+  if (output.NS != null) {
+    return {
+      NS: _json(output.NS)
+    };
+  }
+  if (expectBoolean(output.NULL) !== void 0) {
+    return { NULL: expectBoolean(output.NULL) };
+  }
+  if (expectString(output.S) !== void 0) {
+    return { S: expectString(output.S) };
+  }
+  if (output.SS != null) {
+    return {
+      SS: _json(output.SS)
+    };
+  }
+  return { $unknown: Object.entries(output)[0] };
+};
+var de_BatchWriteItemOutput = (output, context) => {
+  return take(output, {
+    ConsumedCapacity: (_) => de_ConsumedCapacityMultiple(_),
+    ItemCollectionMetrics: (_) => de_ItemCollectionMetricsPerTable(_, context),
+    UnprocessedItems: (_) => de_BatchWriteItemRequestMap(_, context)
+  });
+};
+var de_BatchWriteItemRequestMap = (output, context) => {
+  return Object.entries(output).reduce((acc, [key, value]) => {
+    if (value === null) {
+      return acc;
+    }
+    acc[key] = de_WriteRequests(value, context);
+    return acc;
+  }, {});
+};
+var de_BinarySetAttributeValue = (output, context) => {
+  const retVal = (output || []).filter((e3) => e3 != null).map((entry) => {
+    return context.base64Decoder(entry);
+  });
+  return retVal;
+};
+var de_CancellationReason = (output, context) => {
+  return take(output, {
+    Code: expectString,
+    Item: (_) => de_AttributeMap(_, context),
+    Message: expectString
+  });
+};
+var de_CancellationReasonList = (output, context) => {
+  const retVal = (output || []).filter((e3) => e3 != null).map((entry) => {
+    return de_CancellationReason(entry, context);
+  });
+  return retVal;
+};
+var de_Capacity = (output, context) => {
+  return take(output, {
+    CapacityUnits: limitedParseDouble,
+    ReadCapacityUnits: limitedParseDouble,
+    WriteCapacityUnits: limitedParseDouble
+  });
+};
+var de_ConditionalCheckFailedException = (output, context) => {
+  return take(output, {
+    Item: (_) => de_AttributeMap(_, context),
+    message: expectString
+  });
+};
+var de_ConsumedCapacity = (output, context) => {
+  return take(output, {
+    CapacityUnits: limitedParseDouble,
+    GlobalSecondaryIndexes: (_) => de_SecondaryIndexesCapacityMap(_),
+    LocalSecondaryIndexes: (_) => de_SecondaryIndexesCapacityMap(_),
+    ReadCapacityUnits: limitedParseDouble,
+    Table: (_) => de_Capacity(_),
+    TableName: expectString,
+    WriteCapacityUnits: limitedParseDouble
+  });
+};
+var de_ConsumedCapacityMultiple = (output, context) => {
+  const retVal = (output || []).filter((e3) => e3 != null).map((entry) => {
+    return de_ConsumedCapacity(entry);
+  });
+  return retVal;
+};
+var de_DeleteRequest = (output, context) => {
+  return take(output, {
+    Key: (_) => de_Key(_, context)
+  });
+};
+var de_ItemCollectionKeyAttributeMap = (output, context) => {
+  return Object.entries(output).reduce((acc, [key, value]) => {
+    if (value === null) {
+      return acc;
+    }
+    acc[key] = de_AttributeValue(awsExpectUnion(value), context);
+    return acc;
+  }, {});
+};
+var de_ItemCollectionMetrics = (output, context) => {
+  return take(output, {
+    ItemCollectionKey: (_) => de_ItemCollectionKeyAttributeMap(_, context),
+    SizeEstimateRangeGB: (_) => de_ItemCollectionSizeEstimateRange(_)
+  });
+};
+var de_ItemCollectionMetricsMultiple = (output, context) => {
+  const retVal = (output || []).filter((e3) => e3 != null).map((entry) => {
+    return de_ItemCollectionMetrics(entry, context);
+  });
+  return retVal;
+};
+var de_ItemCollectionMetricsPerTable = (output, context) => {
+  return Object.entries(output).reduce((acc, [key, value]) => {
+    if (value === null) {
+      return acc;
+    }
+    acc[key] = de_ItemCollectionMetricsMultiple(value, context);
+    return acc;
+  }, {});
+};
+var de_ItemCollectionSizeEstimateRange = (output, context) => {
+  const retVal = (output || []).filter((e3) => e3 != null).map((entry) => {
+    return limitedParseDouble(entry);
+  });
+  return retVal;
+};
+var de_ItemList = (output, context) => {
+  const retVal = (output || []).filter((e3) => e3 != null).map((entry) => {
+    return de_AttributeMap(entry, context);
+  });
+  return retVal;
+};
+var de_Key = (output, context) => {
+  return Object.entries(output).reduce((acc, [key, value]) => {
+    if (value === null) {
+      return acc;
+    }
+    acc[key] = de_AttributeValue(awsExpectUnion(value), context);
+    return acc;
+  }, {});
+};
+var de_ListAttributeValue = (output, context) => {
+  const retVal = (output || []).filter((e3) => e3 != null).map((entry) => {
+    return de_AttributeValue(awsExpectUnion(entry), context);
+  });
+  return retVal;
+};
+var de_MapAttributeValue = (output, context) => {
+  return Object.entries(output).reduce((acc, [key, value]) => {
+    if (value === null) {
+      return acc;
+    }
+    acc[key] = de_AttributeValue(awsExpectUnion(value), context);
+    return acc;
+  }, {});
+};
+var de_PutItemInputAttributeMap = (output, context) => {
+  return Object.entries(output).reduce((acc, [key, value]) => {
+    if (value === null) {
+      return acc;
+    }
+    acc[key] = de_AttributeValue(awsExpectUnion(value), context);
+    return acc;
+  }, {});
+};
+var de_PutItemOutput = (output, context) => {
+  return take(output, {
+    Attributes: (_) => de_AttributeMap(_, context),
+    ConsumedCapacity: (_) => de_ConsumedCapacity(_),
+    ItemCollectionMetrics: (_) => de_ItemCollectionMetrics(_, context)
+  });
+};
+var de_PutRequest = (output, context) => {
+  return take(output, {
+    Item: (_) => de_PutItemInputAttributeMap(_, context)
+  });
+};
+var de_QueryOutput = (output, context) => {
+  return take(output, {
+    ConsumedCapacity: (_) => de_ConsumedCapacity(_),
+    Count: expectInt32,
+    Items: (_) => de_ItemList(_, context),
+    LastEvaluatedKey: (_) => de_Key(_, context),
+    ScannedCount: expectInt32
+  });
+};
+var de_ScanOutput = (output, context) => {
+  return take(output, {
+    ConsumedCapacity: (_) => de_ConsumedCapacity(_),
+    Count: expectInt32,
+    Items: (_) => de_ItemList(_, context),
+    LastEvaluatedKey: (_) => de_Key(_, context),
+    ScannedCount: expectInt32
+  });
+};
+var de_SecondaryIndexesCapacityMap = (output, context) => {
+  return Object.entries(output).reduce((acc, [key, value]) => {
+    if (value === null) {
+      return acc;
+    }
+    acc[key] = de_Capacity(value);
+    return acc;
+  }, {});
+};
+var de_TransactionCanceledException = (output, context) => {
+  return take(output, {
+    CancellationReasons: (_) => de_CancellationReasonList(_, context),
+    Message: expectString
+  });
+};
+var de_UpdateItemOutput = (output, context) => {
+  return take(output, {
+    Attributes: (_) => de_AttributeMap(_, context),
+    ConsumedCapacity: (_) => de_ConsumedCapacity(_),
+    ItemCollectionMetrics: (_) => de_ItemCollectionMetrics(_, context)
+  });
+};
+var de_WriteRequest = (output, context) => {
+  return take(output, {
+    DeleteRequest: (_) => de_DeleteRequest(_, context),
+    PutRequest: (_) => de_PutRequest(_, context)
+  });
+};
+var de_WriteRequests = (output, context) => {
+  const retVal = (output || []).filter((e3) => e3 != null).map((entry) => {
+    return de_WriteRequest(entry, context);
+  });
+  return retVal;
+};
+var deserializeMetadata2 = (output) => ({
+  httpStatusCode: output.statusCode,
+  requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
+  extendedRequestId: output.headers["x-amz-id-2"],
+  cfId: output.headers["x-amz-cf-id"]
+});
+var throwDefaultError2 = withBaseException(DynamoDBServiceException);
+var buildHttpRpcRequest2 = async (context, headers, path, resolvedHostname, body) => {
+  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+  const contents = {
+    protocol,
+    hostname,
+    port,
+    method: "POST",
+    path: basePath.endsWith("/") ? basePath.slice(0, -1) + path : basePath + path,
+    headers
+  };
+  if (body !== void 0) {
+    contents.body = body;
+  }
+  return new HttpRequest(contents);
+};
+function sharedHeaders2(operation) {
+  return {
+    "content-type": "application/x-amz-json-1.0",
+    "x-amz-target": `DynamoDB_20120810.${operation}`
+  };
+}
+
+// ../../node_modules/@aws-sdk/client-dynamodb/dist-es/commands/DescribeEndpointsCommand.js
+var DescribeEndpointsCommand = class extends Command.classBuilder().ep(commonParams2).m(function(Command2, cs, config, o3) {
+  return [
+    getSerdePlugin(config, this.serialize, this.deserialize),
+    getEndpointPlugin(config, Command2.getEndpointParameterInstructions())
+  ];
+}).s("DynamoDB_20120810", "DescribeEndpoints", {}).n("DynamoDBClient", "DescribeEndpointsCommand").f(void 0, void 0).ser(se_DescribeEndpointsCommand).de(de_DescribeEndpointsCommand).build() {
+};
+
+// ../../node_modules/@aws-sdk/client-dynamodb/package.json
+var package_default2 = {
+  version: "3.828.0"};
+
+// ../../node_modules/@aws-sdk/client-dynamodb/node_modules/@aws-sdk/credential-provider-node/dist-es/remoteProvider.js
+var ENV_IMDS_DISABLED2 = "AWS_EC2_METADATA_DISABLED";
+var remoteProvider2 = async (init) => {
+  const { ENV_CMDS_FULL_URI, ENV_CMDS_RELATIVE_URI, fromContainerMetadata, fromInstanceMetadata } = await import('./dist-es-4ULGGWP4.js');
+  if (process.env[ENV_CMDS_RELATIVE_URI] || process.env[ENV_CMDS_FULL_URI]) {
+    init.logger?.debug("@aws-sdk/credential-provider-node - remoteProvider::fromHttp/fromContainerMetadata");
+    const { fromHttp } = await import('./dist-es-A2JHLMIV.js');
+    return chain(fromHttp(init), fromContainerMetadata(init));
+  }
+  if (process.env[ENV_IMDS_DISABLED2] && process.env[ENV_IMDS_DISABLED2] !== "false") {
+    return async () => {
+      throw new CredentialsProviderError("EC2 Instance Metadata Service access disabled", { logger: init.logger });
+    };
+  }
+  init.logger?.debug("@aws-sdk/credential-provider-node - remoteProvider::fromInstanceMetadata");
+  return fromInstanceMetadata(init);
+};
+
+// ../../node_modules/@aws-sdk/client-dynamodb/node_modules/@aws-sdk/credential-provider-node/dist-es/defaultProvider.js
+var multipleCredentialSourceWarningEmitted2 = false;
+var defaultProvider2 = (init = {}) => memoize(chain(async () => {
+  const profile = init.profile ?? process.env[ENV_PROFILE];
+  if (profile) {
+    const envStaticCredentialsAreSet = process.env[ENV_KEY$1] && process.env[ENV_SECRET$1];
+    if (envStaticCredentialsAreSet) {
+      if (!multipleCredentialSourceWarningEmitted2) {
+        const warnFn = init.logger?.warn && init.logger?.constructor?.name !== "NoOpLogger" ? init.logger.warn : console.warn;
+        warnFn(`@aws-sdk/credential-provider-node - defaultProvider::fromEnv WARNING:
+    Multiple credential sources detected: 
+    Both AWS_PROFILE and the pair AWS_ACCESS_KEY_ID/AWS_SECRET_ACCESS_KEY static credentials are set.
+    This SDK will proceed with the AWS_PROFILE value.
+    
+    However, a future version may change this behavior to prefer the ENV static credentials.
+    Please ensure that your environment only sets either the AWS_PROFILE or the
+    AWS_ACCESS_KEY_ID/AWS_SECRET_ACCESS_KEY pair.
+`);
+        multipleCredentialSourceWarningEmitted2 = true;
+      }
+    }
+    throw new CredentialsProviderError("AWS_PROFILE is set, skipping fromEnv provider.", {
+      logger: init.logger,
+      tryNextLink: true
+    });
+  }
+  init.logger?.debug("@aws-sdk/credential-provider-node - defaultProvider::fromEnv");
+  return fromEnv$1(init)();
+}, async () => {
+  init.logger?.debug("@aws-sdk/credential-provider-node - defaultProvider::fromSSO");
+  const { ssoStartUrl, ssoAccountId, ssoRegion, ssoRoleName, ssoSession } = init;
+  if (!ssoStartUrl && !ssoAccountId && !ssoRegion && !ssoRoleName && !ssoSession) {
+    throw new CredentialsProviderError("Skipping SSO provider in default chain (inputs do not include SSO fields).", { logger: init.logger });
+  }
+  const { fromSSO } = await import('./dist-es-AWY666YH.js');
+  return fromSSO(init)();
+}, async () => {
+  init.logger?.debug("@aws-sdk/credential-provider-node - defaultProvider::fromIni");
+  const { fromIni } = await import('./dist-es-KUMQWKJB.js');
+  return fromIni(init)();
+}, async () => {
+  init.logger?.debug("@aws-sdk/credential-provider-node - defaultProvider::fromProcess");
+  const { fromProcess } = await import('./dist-es-YGJKPYIO.js');
+  return fromProcess(init)();
+}, async () => {
+  init.logger?.debug("@aws-sdk/credential-provider-node - defaultProvider::fromTokenFile");
+  const { fromTokenFile } = await import('./dist-es-YYROUSP5.js');
+  return fromTokenFile(init)();
+}, async () => {
+  init.logger?.debug("@aws-sdk/credential-provider-node - defaultProvider::remoteProvider");
+  return (await remoteProvider2(init))();
+}, async () => {
+  throw new CredentialsProviderError("Could not load credentials from any providers", {
+    tryNextLink: false,
+    logger: init.logger
+  });
+}), credentialsTreatedAsExpired2, credentialsWillNeedRefresh2);
+var credentialsWillNeedRefresh2 = (credentials) => credentials?.expiration !== void 0;
+var credentialsTreatedAsExpired2 = (credentials) => credentials?.expiration !== void 0 && credentials.expiration.getTime() - Date.now() < 3e5;
+
+// ../../node_modules/@aws-sdk/client-dynamodb/dist-es/endpoint/ruleset.js
+var S = "required";
+var T = "type";
+var U = "fn";
+var V = "argv";
+var W = "ref";
+var X = "properties";
+var Y = "headers";
+var a2 = false;
+var b2 = "isSet";
+var c2 = "error";
+var d2 = "endpoint";
+var e2 = "tree";
+var f2 = "PartitionResult";
+var g2 = "stringEquals";
+var h2 = "dynamodb";
+var i2 = "getAttr";
+var j2 = "aws.parseArn";
+var k2 = "ParsedArn";
+var l2 = "isValidHostLabel";
+var m2 = "FirstArn";
+var n2 = { [S]: false, [T]: "String" };
+var o2 = { [S]: true, "default": false, [T]: "Boolean" };
+var p2 = { [U]: "booleanEquals", [V]: [{ [W]: "UseFIPS" }, true] };
+var q2 = { [U]: "booleanEquals", [V]: [{ [W]: "UseDualStack" }, true] };
+var r2 = {};
+var s2 = { [W]: "Region" };
+var t2 = { [U]: "booleanEquals", [V]: [{ [U]: i2, [V]: [{ [W]: f2 }, "supportsFIPS"] }, true] };
+var u2 = { [U]: "booleanEquals", [V]: [{ [U]: i2, [V]: [{ [W]: f2 }, "supportsDualStack"] }, true] };
+var v2 = { "conditions": [{ [U]: b2, [V]: [{ [W]: "AccountIdEndpointMode" }] }, { [U]: g2, [V]: [{ [W]: "AccountIdEndpointMode" }, "required"] }], "rules": [{ [c2]: "Invalid Configuration: AccountIdEndpointMode is required and FIPS is enabled, but FIPS account endpoints are not supported", [T]: c2 }], [T]: e2 };
+var w2 = { [U]: b2, [V]: [{ [W]: "AccountIdEndpointMode" }] };
+var x2 = { [c2]: "Invalid Configuration: AccountIdEndpointMode is required and FIPS is enabled, but FIPS account endpoints are not supported", [T]: c2 };
+var y = { [U]: i2, [V]: [{ [W]: f2 }, "name"] };
+var z = { [d2]: { "url": "https://dynamodb.{Region}.{PartitionResult#dnsSuffix}", [X]: {}, [Y]: {} }, [T]: d2 };
+var A = { [U]: "not", [V]: [p2] };
+var B = { [c2]: "Invalid Configuration: AccountIdEndpointMode is required and DualStack is enabled, but DualStack account endpoints are not supported", [T]: c2 };
+var C = { [U]: "not", [V]: [{ [U]: g2, [V]: [{ [W]: "AccountIdEndpointMode" }, "disabled"] }] };
+var D = { [U]: g2, [V]: [y, "aws"] };
+var E = { [U]: "not", [V]: [q2] };
+var F = { [U]: g2, [V]: [{ [U]: i2, [V]: [{ [W]: k2 }, "service"] }, h2] };
+var G = { [U]: l2, [V]: [{ [U]: i2, [V]: [{ [W]: k2 }, "region"] }, false] };
+var H = { [U]: g2, [V]: [{ [U]: i2, [V]: [{ [W]: k2 }, "region"] }, "{Region}"] };
+var I = { [U]: l2, [V]: [{ [U]: i2, [V]: [{ [W]: k2 }, "accountId"] }, false] };
+var J = { "url": "https://{ParsedArn#accountId}.ddb.{Region}.{PartitionResult#dnsSuffix}", [X]: {}, [Y]: {} };
+var K = { [W]: "ResourceArnList" };
+var L = { [W]: "AccountId" };
+var M = [p2];
+var N = [q2];
+var O = [s2];
+var P = [w2, { [U]: g2, [V]: [{ [W]: "AccountIdEndpointMode" }, "required"] }];
+var Q = [A];
+var R = [{ [W]: "ResourceArn" }];
+var _data2 = { version: "1.0", parameters: { Region: n2, UseDualStack: o2, UseFIPS: o2, Endpoint: n2, AccountId: n2, AccountIdEndpointMode: n2, ResourceArn: n2, ResourceArnList: { [S]: a2, [T]: "stringArray" } }, rules: [{ conditions: [{ [U]: b2, [V]: [{ [W]: "Endpoint" }] }], rules: [{ conditions: M, error: "Invalid Configuration: FIPS and custom endpoint are not supported", [T]: c2 }, { conditions: N, error: "Invalid Configuration: Dualstack and custom endpoint are not supported", [T]: c2 }, { endpoint: { url: "{Endpoint}", [X]: r2, [Y]: r2 }, [T]: d2 }], [T]: e2 }, { conditions: [{ [U]: b2, [V]: O }], rules: [{ conditions: [{ [U]: "aws.partition", [V]: O, assign: f2 }], rules: [{ conditions: [{ [U]: g2, [V]: [s2, "local"] }], rules: [{ conditions: M, error: "Invalid Configuration: FIPS and local endpoint are not supported", [T]: c2 }, { conditions: N, error: "Invalid Configuration: Dualstack and local endpoint are not supported", [T]: c2 }, { endpoint: { url: "http://localhost:8000", [X]: { authSchemes: [{ signingRegion: "us-east-1", name: "sigv4", signingName: h2 }] }, [Y]: r2 }, [T]: d2 }], [T]: e2 }, { conditions: [p2, q2], rules: [{ conditions: [t2, u2], rules: [v2, { endpoint: { url: "https://dynamodb-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", [X]: r2, [Y]: r2 }, [T]: d2 }], [T]: e2 }, { error: "FIPS and DualStack are enabled, but this partition does not support one or both", [T]: c2 }], [T]: e2 }, { conditions: M, rules: [{ conditions: [t2], rules: [{ conditions: [{ [U]: g2, [V]: [y, "aws-us-gov"] }], rules: [v2, z], [T]: e2 }, v2, { endpoint: { url: "https://dynamodb-fips.{Region}.{PartitionResult#dnsSuffix}", [X]: r2, [Y]: r2 }, [T]: d2 }], [T]: e2 }, { error: "FIPS is enabled but this partition does not support FIPS", [T]: c2 }], [T]: e2 }, { conditions: N, rules: [{ conditions: [u2], rules: [{ conditions: P, rules: [{ conditions: Q, rules: [B], [T]: e2 }, x2], [T]: e2 }, { endpoint: { url: "https://dynamodb.{Region}.{PartitionResult#dualStackDnsSuffix}", [X]: r2, [Y]: r2 }, [T]: d2 }], [T]: e2 }, { error: "DualStack is enabled but this partition does not support DualStack", [T]: c2 }], [T]: e2 }, { conditions: [w2, C, D, A, E, { [U]: b2, [V]: R }, { [U]: j2, [V]: R, assign: k2 }, F, G, H, I], endpoint: J, [T]: d2 }, { conditions: [w2, C, D, A, E, { [U]: b2, [V]: [K] }, { [U]: i2, [V]: [K, "[0]"], assign: m2 }, { [U]: j2, [V]: [{ [W]: m2 }], assign: k2 }, F, G, H, I], endpoint: J, [T]: d2 }, { conditions: [w2, C, D, A, E, { [U]: b2, [V]: [L] }], rules: [{ conditions: [{ [U]: l2, [V]: [L, a2] }], rules: [{ endpoint: { url: "https://{AccountId}.ddb.{Region}.{PartitionResult#dnsSuffix}", [X]: r2, [Y]: r2 }, [T]: d2 }], [T]: e2 }, { error: "Credentials-sourced account ID parameter is invalid", [T]: c2 }], [T]: e2 }, { conditions: P, rules: [{ conditions: Q, rules: [{ conditions: [E], rules: [{ conditions: [D], rules: [{ error: "AccountIdEndpointMode is required but no AccountID was provided or able to be loaded", [T]: c2 }], [T]: e2 }, { error: "Invalid Configuration: AccountIdEndpointMode is required but account endpoints are not supported in this partition", [T]: c2 }], [T]: e2 }, B], [T]: e2 }, x2], [T]: e2 }, z], [T]: e2 }], [T]: e2 }, { error: "Invalid Configuration: Missing Region", [T]: c2 }] };
+var ruleSet2 = _data2;
+
+// ../../node_modules/@aws-sdk/client-dynamodb/dist-es/endpoint/endpointResolver.js
+var cache2 = new EndpointCache({
+  size: 50,
+  params: [
+    "AccountId",
+    "AccountIdEndpointMode",
+    "Endpoint",
+    "Region",
+    "ResourceArn",
+    "ResourceArnList",
+    "UseDualStack",
+    "UseFIPS"
+  ]
+});
+var defaultEndpointResolver2 = (endpointParams, context = {}) => {
+  return cache2.get(endpointParams, () => resolveEndpoint(ruleSet2, {
+    endpointParams,
+    logger: context.logger
+  }));
+};
+customEndpointFunctions.aws = awsEndpointFunctions$1;
+
+// ../../node_modules/@aws-sdk/client-dynamodb/dist-es/runtimeConfig.shared.js
+var getRuntimeConfig3 = (config) => {
+  return {
+    apiVersion: "2012-08-10",
+    base64Decoder: config?.base64Decoder ?? fromBase64,
+    base64Encoder: config?.base64Encoder ?? toBase64,
+    disableHostPrefix: config?.disableHostPrefix ?? false,
+    endpointProvider: config?.endpointProvider ?? defaultEndpointResolver2,
+    extensions: config?.extensions ?? [],
+    httpAuthSchemeProvider: config?.httpAuthSchemeProvider ?? defaultDynamoDBHttpAuthSchemeProvider,
+    httpAuthSchemes: config?.httpAuthSchemes ?? [
+      {
+        schemeId: "aws.auth#sigv4",
+        identityProvider: (ipc) => ipc.getIdentityProvider("aws.auth#sigv4"),
+        signer: new AwsSdkSigV4Signer$1()
+      }
+    ],
+    logger: config?.logger ?? new NoOpLogger(),
+    serviceId: config?.serviceId ?? "DynamoDB",
+    urlParser: config?.urlParser ?? parseUrl,
+    utf8Decoder: config?.utf8Decoder ?? fromUtf8,
+    utf8Encoder: config?.utf8Encoder ?? toUtf8
+  };
+};
+
+// ../../node_modules/@aws-sdk/client-dynamodb/dist-es/runtimeConfig.js
+var getRuntimeConfig4 = (config) => {
+  emitWarningIfUnsupportedVersion(process.version);
+  const defaultsMode = resolveDefaultsModeConfig(config);
+  const defaultConfigProvider = () => defaultsMode().then(loadConfigsForDefaultMode);
+  const clientSharedValues = getRuntimeConfig3(config);
+  emitWarningIfUnsupportedVersion$2(process.version);
+  const loaderConfig = {
+    profile: config?.profile,
+    logger: clientSharedValues.logger
+  };
+  return {
+    ...clientSharedValues,
+    ...config,
+    runtime: "node",
+    defaultsMode,
+    accountIdEndpointMode: config?.accountIdEndpointMode ?? loadConfig(NODE_ACCOUNT_ID_ENDPOINT_MODE_CONFIG_OPTIONS, loaderConfig),
+    authSchemePreference: config?.authSchemePreference ?? loadConfig(NODE_AUTH_SCHEME_PREFERENCE_OPTIONS, loaderConfig),
+    bodyLengthChecker: config?.bodyLengthChecker ?? calculateBodyLength,
+    credentialDefaultProvider: config?.credentialDefaultProvider ?? defaultProvider2,
+    defaultUserAgentProvider: config?.defaultUserAgentProvider ?? createDefaultUserAgentProvider$1({ serviceId: clientSharedValues.serviceId, clientVersion: package_default2.version }),
+    endpointDiscoveryEnabledProvider: config?.endpointDiscoveryEnabledProvider ?? loadConfig(NODE_ENDPOINT_DISCOVERY_CONFIG_OPTIONS, loaderConfig),
+    maxAttempts: config?.maxAttempts ?? loadConfig(NODE_MAX_ATTEMPT_CONFIG_OPTIONS, config),
+    region: config?.region ?? loadConfig(NODE_REGION_CONFIG_OPTIONS, { ...NODE_REGION_CONFIG_FILE_OPTIONS, ...loaderConfig }),
+    requestHandler: NodeHttpHandler.create(config?.requestHandler ?? defaultConfigProvider),
+    retryMode: config?.retryMode ?? loadConfig({
+      ...NODE_RETRY_MODE_CONFIG_OPTIONS,
+      default: async () => (await defaultConfigProvider()).retryMode || DEFAULT_RETRY_MODE
+    }, config),
+    sha256: config?.sha256 ?? Hash.bind(null, "sha256"),
+    streamCollector: config?.streamCollector ?? streamCollector,
+    useDualstackEndpoint: config?.useDualstackEndpoint ?? loadConfig(NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS, loaderConfig),
+    useFipsEndpoint: config?.useFipsEndpoint ?? loadConfig(NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS, loaderConfig),
+    userAgentAppId: config?.userAgentAppId ?? loadConfig(NODE_APP_ID_CONFIG_OPTIONS$1, loaderConfig)
+  };
+};
+
+// ../../node_modules/@aws-sdk/client-dynamodb/dist-es/auth/httpAuthExtensionConfiguration.js
+var getHttpAuthExtensionConfiguration2 = (runtimeConfig) => {
+  const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
+  let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
+  let _credentials = runtimeConfig.credentials;
+  return {
+    setHttpAuthScheme(httpAuthScheme) {
+      const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
+      if (index === -1) {
+        _httpAuthSchemes.push(httpAuthScheme);
+      } else {
+        _httpAuthSchemes.splice(index, 1, httpAuthScheme);
+      }
+    },
+    httpAuthSchemes() {
+      return _httpAuthSchemes;
+    },
+    setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
+      _httpAuthSchemeProvider = httpAuthSchemeProvider;
+    },
+    httpAuthSchemeProvider() {
+      return _httpAuthSchemeProvider;
+    },
+    setCredentials(credentials) {
+      _credentials = credentials;
+    },
+    credentials() {
+      return _credentials;
+    }
+  };
+};
+var resolveHttpAuthRuntimeConfig2 = (config) => {
+  return {
+    httpAuthSchemes: config.httpAuthSchemes(),
+    httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
+    credentials: config.credentials()
+  };
+};
+
+// ../../node_modules/@aws-sdk/client-dynamodb/dist-es/runtimeExtensions.js
+var resolveRuntimeExtensions2 = (runtimeConfig, extensions) => {
+  const extensionConfiguration = Object.assign(getAwsRegionExtensionConfiguration$1(runtimeConfig), getDefaultExtensionConfiguration(runtimeConfig), getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration2(runtimeConfig));
+  extensions.forEach((extension) => extension.configure(extensionConfiguration));
+  return Object.assign(runtimeConfig, resolveAwsRegionExtensionConfiguration$1(extensionConfiguration), resolveDefaultRuntimeConfig(extensionConfiguration), resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig2(extensionConfiguration));
+};
+
+// ../../node_modules/@aws-sdk/client-dynamodb/dist-es/DynamoDBClient.js
+var DynamoDBClient = class extends Client {
+  config;
+  constructor(...[configuration]) {
+    const _config_0 = getRuntimeConfig4(configuration || {});
+    super(_config_0);
+    this.initConfig = _config_0;
+    const _config_1 = resolveClientEndpointParameters2(_config_0);
+    const _config_2 = resolveAccountIdEndpointModeConfig(_config_1);
+    const _config_3 = resolveUserAgentConfig$1(_config_2);
+    const _config_4 = resolveRetryConfig(_config_3);
+    const _config_5 = resolveRegionConfig(_config_4);
+    const _config_6 = resolveHostHeaderConfig$1(_config_5);
+    const _config_7 = resolveEndpointConfig(_config_6);
+    const _config_8 = resolveHttpAuthSchemeConfig2(_config_7);
+    const _config_9 = resolveEndpointDiscoveryConfig(_config_8, {
+      endpointDiscoveryCommandCtor: DescribeEndpointsCommand
+    });
+    const _config_10 = resolveRuntimeExtensions2(_config_9, configuration?.extensions || []);
+    this.config = _config_10;
+    this.middlewareStack.use(getUserAgentPlugin$1(this.config));
+    this.middlewareStack.use(getRetryPlugin(this.config));
+    this.middlewareStack.use(getContentLengthPlugin(this.config));
+    this.middlewareStack.use(getHostHeaderPlugin$1(this.config));
+    this.middlewareStack.use(getLoggerPlugin$1(this.config));
+    this.middlewareStack.use(getRecursionDetectionPlugin$1(this.config));
+    this.middlewareStack.use(getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
+      httpAuthSchemeParametersProvider: defaultDynamoDBHttpAuthSchemeParametersProvider,
+      identityProviderConfigProvider: async (config) => new DefaultIdentityProviderConfig({
+        "aws.auth#sigv4": config.credentials
+      })
+    }));
+    this.middlewareStack.use(getHttpSigningPlugin(this.config));
+  }
+  destroy() {
+    super.destroy();
+  }
+};
+
+// ../../node_modules/@aws-sdk/client-dynamodb/dist-es/commands/BatchWriteItemCommand.js
+var BatchWriteItemCommand = class extends Command.classBuilder().ep({
+  ...commonParams2,
+  ResourceArnList: { type: "operationContextParams", get: (input) => Object.keys(input?.RequestItems ?? {}) }
+}).m(function(Command2, cs, config, o3) {
+  return [
+    getSerdePlugin(config, this.serialize, this.deserialize),
+    getEndpointPlugin(config, Command2.getEndpointParameterInstructions())
+  ];
+}).s("DynamoDB_20120810", "BatchWriteItem", {}).n("DynamoDBClient", "BatchWriteItemCommand").f(void 0, void 0).ser(se_BatchWriteItemCommand).de(de_BatchWriteItemCommand).build() {
+};
+
+// ../../node_modules/@aws-sdk/client-dynamodb/dist-es/commands/PutItemCommand.js
+var PutItemCommand = class extends Command.classBuilder().ep({
+  ...commonParams2,
+  ResourceArn: { type: "contextParams", name: "TableName" }
+}).m(function(Command2, cs, config, o3) {
+  return [
+    getSerdePlugin(config, this.serialize, this.deserialize),
+    getEndpointPlugin(config, Command2.getEndpointParameterInstructions())
+  ];
+}).s("DynamoDB_20120810", "PutItem", {}).n("DynamoDBClient", "PutItemCommand").f(void 0, void 0).ser(se_PutItemCommand).de(de_PutItemCommand).build() {
+};
+
+// ../../node_modules/@aws-sdk/client-dynamodb/dist-es/commands/QueryCommand.js
+var QueryCommand = class extends Command.classBuilder().ep({
+  ...commonParams2,
+  ResourceArn: { type: "contextParams", name: "TableName" }
+}).m(function(Command2, cs, config, o3) {
+  return [
+    getSerdePlugin(config, this.serialize, this.deserialize),
+    getEndpointPlugin(config, Command2.getEndpointParameterInstructions())
+  ];
+}).s("DynamoDB_20120810", "Query", {}).n("DynamoDBClient", "QueryCommand").f(void 0, void 0).ser(se_QueryCommand).de(de_QueryCommand).build() {
+};
+
+// ../../node_modules/@aws-sdk/client-dynamodb/dist-es/commands/ScanCommand.js
+var ScanCommand = class extends Command.classBuilder().ep({
+  ...commonParams2,
+  ResourceArn: { type: "contextParams", name: "TableName" }
+}).m(function(Command2, cs, config, o3) {
+  return [
+    getSerdePlugin(config, this.serialize, this.deserialize),
+    getEndpointPlugin(config, Command2.getEndpointParameterInstructions())
+  ];
+}).s("DynamoDB_20120810", "Scan", {}).n("DynamoDBClient", "ScanCommand").f(void 0, void 0).ser(se_ScanCommand).de(de_ScanCommand).build() {
+};
+
+// ../../node_modules/@aws-sdk/client-dynamodb/dist-es/commands/UpdateItemCommand.js
+var UpdateItemCommand = class extends Command.classBuilder().ep({
+  ...commonParams2,
+  ResourceArn: { type: "contextParams", name: "TableName" }
+}).m(function(Command2, cs, config, o3) {
+  return [
+    getSerdePlugin(config, this.serialize, this.deserialize),
+    getEndpointPlugin(config, Command2.getEndpointParameterInstructions())
+  ];
+}).s("DynamoDB_20120810", "UpdateItem", {}).n("DynamoDBClient", "UpdateItemCommand").f(void 0, void 0).ser(se_UpdateItemCommand).de(de_UpdateItemCommand).build() {
+};
+
+// ../task-sqs-adapter/dist/esm/idempotency.js
+async function insertId(id, ttlSeconds, opts) {
+  try {
+    const dynamoClient = opts?.client ?? new DynamoDBClient({});
+    const now = /* @__PURE__ */ new Date();
+    now.setSeconds(now.getSeconds() + ttlSeconds * 1e3);
+    await dynamoClient.send(new PutItemCommand({
+      TableName: process.env.DYNAMODB_TABLE_NAME,
+      Item: {
+        PK: { S: id },
+        SK: { S: id },
+        ttl: { N: Math.floor(now.getTime() / 1e3).toString() }
+      },
+      ConditionExpression: "attribute_not_exists(PK)"
+    }));
+    return true;
+  } catch (e3) {
+    if (e3 instanceof ConditionalCheckFailedException) {
+      return false;
+    } else {
+      throw e3;
+    }
+  }
+}
+
+// ../../node_modules/@aws-sdk/lib-dynamodb/node_modules/@aws-sdk/core/dist-es/submodules/client/setFeature.js
+function setFeature(context, feature, value) {
+  if (!context.__aws_sdk_context) {
+    context.__aws_sdk_context = {
+      features: {}
+    };
+  } else if (!context.__aws_sdk_context.features) {
+    context.__aws_sdk_context.features = {};
+  }
+  context.__aws_sdk_context.features[feature] = value;
+}
+
+// ../../node_modules/@aws-sdk/util-dynamodb/dist-es/NumberValue.js
+var NumberValue = class _NumberValue {
+  value;
+  constructor(value) {
+    if (typeof value === "object" && "N" in value) {
+      this.value = String(value.N);
+    } else {
+      this.value = String(value);
+    }
+    const valueOf = typeof value.valueOf() === "number" ? value.valueOf() : 0;
+    const imprecise = valueOf > Number.MAX_SAFE_INTEGER || valueOf < Number.MIN_SAFE_INTEGER || Math.abs(valueOf) === Infinity || Number.isNaN(valueOf);
+    if (imprecise) {
+      throw new Error(`NumberValue should not be initialized with an imprecise number=${valueOf}. Use a string instead.`);
+    }
+  }
+  static from(value) {
+    return new _NumberValue(value);
+  }
+  toAttributeValue() {
+    return {
+      N: this.toString()
+    };
+  }
+  toBigInt() {
+    const stringValue = this.toString();
+    return BigInt(stringValue);
+  }
+  toString() {
+    return String(this.value);
+  }
+  valueOf() {
+    return this.toString();
+  }
+};
+
+// ../../node_modules/@aws-sdk/util-dynamodb/dist-es/convertToAttr.js
+var convertToAttr = (data, options) => {
+  if (data === void 0) {
+    throw new Error(`Pass options.removeUndefinedValues=true to remove undefined values from map/array/set.`);
+  } else if (data === null && typeof data === "object") {
+    return convertToNullAttr();
+  } else if (Array.isArray(data)) {
+    return convertToListAttr(data, options);
+  } else if (data?.constructor?.name === "Set") {
+    return convertToSetAttr(data, options);
+  } else if (data?.constructor?.name === "Map") {
+    return convertToMapAttrFromIterable(data, options);
+  } else if (data?.constructor?.name === "Object" || !data.constructor && typeof data === "object") {
+    return convertToMapAttrFromEnumerableProps(data, options);
+  } else if (isBinary(data)) {
+    if (data.length === 0 && options?.convertEmptyValues) {
+      return convertToNullAttr();
+    }
+    return convertToBinaryAttr(data);
+  } else if (typeof data === "boolean" || data?.constructor?.name === "Boolean") {
+    return { BOOL: data.valueOf() };
+  } else if (typeof data === "number" || data?.constructor?.name === "Number") {
+    return convertToNumberAttr(data, options);
+  } else if (data instanceof NumberValue) {
+    return data.toAttributeValue();
+  } else if (typeof data === "bigint") {
+    return convertToBigIntAttr(data);
+  } else if (typeof data === "string" || data?.constructor?.name === "String") {
+    if (data.length === 0 && options?.convertEmptyValues) {
+      return convertToNullAttr();
+    }
+    return convertToStringAttr(data);
+  } else if (options?.convertClassInstanceToMap && typeof data === "object") {
+    return convertToMapAttrFromEnumerableProps(data, options);
+  }
+  throw new Error(`Unsupported type passed: ${data}. Pass options.convertClassInstanceToMap=true to marshall typeof object as map attribute.`);
+};
+var convertToListAttr = (data, options) => ({
+  L: data.filter((item) => typeof item !== "function" && (!options?.removeUndefinedValues || options?.removeUndefinedValues && item !== void 0)).map((item) => convertToAttr(item, options))
+});
+var convertToSetAttr = (set, options) => {
+  const setToOperate = options?.removeUndefinedValues ? new Set([...set].filter((value) => value !== void 0)) : set;
+  if (!options?.removeUndefinedValues && setToOperate.has(void 0)) {
+    throw new Error(`Pass options.removeUndefinedValues=true to remove undefined values from map/array/set.`);
+  }
+  if (setToOperate.size === 0) {
+    if (options?.convertEmptyValues) {
+      return convertToNullAttr();
+    }
+    throw new Error(`Pass a non-empty set, or options.convertEmptyValues=true.`);
+  }
+  const item = setToOperate.values().next().value;
+  if (item instanceof NumberValue) {
+    return {
+      NS: Array.from(setToOperate).map((_) => _.toString())
+    };
+  } else if (typeof item === "number") {
+    return {
+      NS: Array.from(setToOperate).map((num) => convertToNumberAttr(num, options)).map((item2) => item2.N)
+    };
+  } else if (typeof item === "bigint") {
+    return {
+      NS: Array.from(setToOperate).map(convertToBigIntAttr).map((item2) => item2.N)
+    };
+  } else if (typeof item === "string") {
+    return {
+      SS: Array.from(setToOperate).map(convertToStringAttr).map((item2) => item2.S)
+    };
+  } else if (isBinary(item)) {
+    return {
+      BS: Array.from(setToOperate).map(convertToBinaryAttr).map((item2) => item2.B)
+    };
+  } else {
+    throw new Error(`Only Number Set (NS), Binary Set (BS) or String Set (SS) are allowed.`);
+  }
+};
+var convertToMapAttrFromIterable = (data, options) => ({
+  M: ((data2) => {
+    const map = {};
+    for (const [key, value] of data2) {
+      if (typeof value !== "function" && (value !== void 0 || !options?.removeUndefinedValues)) {
+        map[key] = convertToAttr(value, options);
+      }
+    }
+    return map;
+  })(data)
+});
+var convertToMapAttrFromEnumerableProps = (data, options) => ({
+  M: ((data2) => {
+    const map = {};
+    for (const key in data2) {
+      const value = data2[key];
+      if (typeof value !== "function" && (value !== void 0 || !options?.removeUndefinedValues)) {
+        map[key] = convertToAttr(value, options);
+      }
+    }
+    return map;
+  })(data)
+});
+var convertToNullAttr = () => ({ NULL: true });
+var convertToBinaryAttr = (data) => ({ B: data });
+var convertToStringAttr = (data) => ({ S: data.toString() });
+var convertToBigIntAttr = (data) => ({ N: data.toString() });
+var validateBigIntAndThrow = (errorPrefix) => {
+  throw new Error(`${errorPrefix} Use NumberValue from @aws-sdk/lib-dynamodb.`);
+};
+var convertToNumberAttr = (num, options) => {
+  if ([Number.NaN, Number.POSITIVE_INFINITY, Number.NEGATIVE_INFINITY].map((val) => val.toString()).includes(num.toString())) {
+    throw new Error(`Special numeric value ${num.toString()} is not allowed`);
+  } else if (!options?.allowImpreciseNumbers) {
+    if (Number(num) > Number.MAX_SAFE_INTEGER) {
+      validateBigIntAndThrow(`Number ${num.toString()} is greater than Number.MAX_SAFE_INTEGER.`);
+    } else if (Number(num) < Number.MIN_SAFE_INTEGER) {
+      validateBigIntAndThrow(`Number ${num.toString()} is lesser than Number.MIN_SAFE_INTEGER.`);
+    }
+  }
+  return { N: num.toString() };
+};
+var isBinary = (data) => {
+  const binaryTypes = [
+    "ArrayBuffer",
+    "Blob",
+    "Buffer",
+    "DataView",
+    "File",
+    "Int8Array",
+    "Uint8Array",
+    "Uint8ClampedArray",
+    "Int16Array",
+    "Uint16Array",
+    "Int32Array",
+    "Uint32Array",
+    "Float32Array",
+    "Float64Array",
+    "BigInt64Array",
+    "BigUint64Array"
+  ];
+  if (data?.constructor) {
+    return binaryTypes.includes(data.constructor.name);
+  }
+  return false;
+};
+
+// ../../node_modules/@aws-sdk/util-dynamodb/dist-es/convertToNative.js
+var convertToNative = (data, options) => {
+  for (const [key, value] of Object.entries(data)) {
+    if (value !== void 0) {
+      switch (key) {
+        case "NULL":
+          return null;
+        case "BOOL":
+          return Boolean(value);
+        case "N":
+          return convertNumber(value, options);
+        case "B":
+          return convertBinary(value);
+        case "S":
+          return convertString(value);
+        case "L":
+          return convertList(value, options);
+        case "M":
+          return convertMap(value, options);
+        case "NS":
+          return new Set(value.map((item) => convertNumber(item, options)));
+        case "BS":
+          return new Set(value.map(convertBinary));
+        case "SS":
+          return new Set(value.map(convertString));
+        default:
+          throw new Error(`Unsupported type passed: ${key}`);
+      }
+    }
+  }
+  throw new Error(`No value defined: ${JSON.stringify(data)}`);
+};
+var convertNumber = (numString, options) => {
+  if (typeof options?.wrapNumbers === "function") {
+    return options?.wrapNumbers(numString);
+  }
+  if (options?.wrapNumbers) {
+    return NumberValue.from(numString);
+  }
+  const num = Number(numString);
+  const infinityValues = [Number.POSITIVE_INFINITY, Number.NEGATIVE_INFINITY];
+  const isLargeFiniteNumber = (num > Number.MAX_SAFE_INTEGER || num < Number.MIN_SAFE_INTEGER) && !infinityValues.includes(num);
+  if (isLargeFiniteNumber) {
+    if (typeof BigInt === "function") {
+      try {
+        return BigInt(numString);
+      } catch (error) {
+        throw new Error(`${numString} can't be converted to BigInt. Set options.wrapNumbers to get string value.`);
+      }
+    } else {
+      throw new Error(`${numString} is outside SAFE_INTEGER bounds. Set options.wrapNumbers to get string value.`);
+    }
+  }
+  return num;
+};
+var convertString = (stringValue) => stringValue;
+var convertBinary = (binaryValue) => binaryValue;
+var convertList = (list, options) => list.map((item) => convertToNative(item, options));
+var convertMap = (map, options) => Object.entries(map).reduce((acc, [key, value]) => (acc[key] = convertToNative(value, options), acc), {});
+
+// ../../node_modules/@aws-sdk/util-dynamodb/dist-es/marshall.js
+function marshall(data, options) {
+  const attributeValue = convertToAttr(data, options);
+  const [key, value] = Object.entries(attributeValue)[0];
+  switch (key) {
+    case "M":
+    case "L":
+      return options?.convertTopLevelContainer ? attributeValue : value;
+    case "SS":
+    case "NS":
+    case "BS":
+    case "S":
+    case "N":
+    case "B":
+    case "NULL":
+    case "BOOL":
+    case "$unknown":
+    default:
+      return attributeValue;
+  }
+}
+
+// ../../node_modules/@aws-sdk/util-dynamodb/dist-es/unmarshall.js
+var unmarshall = (data, options) => {
+  if (options?.convertWithoutMapWrapper) {
+    return convertToNative(data, options);
+  }
+  return convertToNative({ M: data }, options);
+};
+
+// ../../node_modules/@aws-sdk/lib-dynamodb/dist-es/commands/utils.js
+var SELF = null;
+var ALL_VALUES = {};
+var ALL_MEMBERS = [];
+var NEXT_LEVEL = "*";
+var processObj = (obj, processFunc, keyNodes) => {
+  if (obj !== void 0) {
+    if (keyNodes == null) {
+      return processFunc(obj);
+    } else {
+      const keys = Object.keys(keyNodes);
+      const goToNextLevel = keys.length === 1 && keys[0] === NEXT_LEVEL;
+      const someChildren = keys.length >= 1 && !goToNextLevel;
+      const allChildren = keys.length === 0;
+      if (someChildren) {
+        return processKeysInObj(obj, processFunc, keyNodes);
+      } else if (allChildren) {
+        return processAllKeysInObj(obj, processFunc, SELF);
+      } else if (goToNextLevel) {
+        return Object.entries(obj ?? {}).reduce((acc, [k3, v3]) => {
+          if (typeof v3 !== "function") {
+            acc[k3] = processObj(v3, processFunc, keyNodes[NEXT_LEVEL]);
+          }
+          return acc;
+        }, Array.isArray(obj) ? [] : {});
+      }
+    }
+  }
+  return void 0;
+};
+var processKeysInObj = (obj, processFunc, keyNodes) => {
+  let accumulator;
+  if (Array.isArray(obj)) {
+    accumulator = obj.filter((item) => typeof item !== "function");
+  } else {
+    accumulator = {};
+    for (const [k3, v3] of Object.entries(obj)) {
+      if (typeof v3 !== "function") {
+        accumulator[k3] = v3;
+      }
+    }
+  }
+  for (const [nodeKey, nodes] of Object.entries(keyNodes)) {
+    if (typeof obj[nodeKey] === "function") {
+      continue;
+    }
+    const processedValue = processObj(obj[nodeKey], processFunc, nodes);
+    if (processedValue !== void 0 && typeof processedValue !== "function") {
+      accumulator[nodeKey] = processedValue;
+    }
+  }
+  return accumulator;
+};
+var processAllKeysInObj = (obj, processFunc, keyNodes) => {
+  if (Array.isArray(obj)) {
+    return obj.filter((item) => typeof item !== "function").map((item) => processObj(item, processFunc, keyNodes));
+  }
+  return Object.entries(obj).reduce((acc, [key, value]) => {
+    if (typeof value === "function") {
+      return acc;
+    }
+    const processedValue = processObj(value, processFunc, keyNodes);
+    if (processedValue !== void 0 && typeof processedValue !== "function") {
+      acc[key] = processedValue;
+    }
+    return acc;
+  }, {});
+};
+var marshallInput = (obj, keyNodes, options) => {
+  const marshallFunc = (toMarshall) => marshall(toMarshall, options);
+  return processKeysInObj(obj, marshallFunc, keyNodes);
+};
+var unmarshallOutput = (obj, keyNodes, options) => {
+  const unmarshallFunc = (toMarshall) => unmarshall(toMarshall, options);
+  return processKeysInObj(obj, unmarshallFunc, keyNodes);
+};
+
+// ../../node_modules/@aws-sdk/lib-dynamodb/dist-es/baseCommand/DynamoDBDocumentClientCommand.js
+var DynamoDBDocumentClientCommand = class extends Command {
+  addMarshallingMiddleware(configuration) {
+    const { marshallOptions = {}, unmarshallOptions = {} } = configuration.translateConfig || {};
+    marshallOptions.convertTopLevelContainer = marshallOptions.convertTopLevelContainer ?? true;
+    unmarshallOptions.convertWithoutMapWrapper = unmarshallOptions.convertWithoutMapWrapper ?? true;
+    this.clientCommand.middlewareStack.addRelativeTo((next, context) => async (args) => {
+      setFeature(context, "DDB_MAPPER", "d");
+      args.input = marshallInput(args.input, this.inputKeyNodes, marshallOptions);
+      return next(args);
+    }, {
+      name: "DocumentMarshall",
+      relation: "before",
+      toMiddleware: "serializerMiddleware",
+      override: true
+    });
+    this.clientCommand.middlewareStack.addRelativeTo((next, context) => async (args) => {
+      const deserialized = await next(args);
+      deserialized.output = unmarshallOutput(deserialized.output, this.outputKeyNodes, unmarshallOptions);
+      return deserialized;
+    }, {
+      name: "DocumentUnmarshall",
+      relation: "before",
+      toMiddleware: "deserializerMiddleware",
+      override: true
+    });
+  }
+};
+
+// ../../node_modules/@aws-sdk/lib-dynamodb/dist-es/commands/QueryCommand.js
+var QueryCommand2 = class extends DynamoDBDocumentClientCommand {
+  input;
+  inputKeyNodes = {
+    KeyConditions: {
+      "*": {
+        AttributeValueList: ALL_MEMBERS
+      }
+    },
+    QueryFilter: {
+      "*": {
+        AttributeValueList: ALL_MEMBERS
+      }
+    },
+    ExclusiveStartKey: ALL_VALUES,
+    ExpressionAttributeValues: ALL_VALUES
+  };
+  outputKeyNodes = {
+    Items: {
+      "*": ALL_VALUES
+    },
+    LastEvaluatedKey: ALL_VALUES
+  };
+  clientCommand;
+  middlewareStack;
+  constructor(input) {
+    super();
+    this.input = input;
+    this.clientCommand = new QueryCommand(this.input);
+    this.middlewareStack = this.clientCommand.middlewareStack;
+  }
+  resolveMiddleware(clientStack, configuration, options) {
+    this.addMarshallingMiddleware(configuration);
+    const stack = clientStack.concat(this.middlewareStack);
+    const handler = this.clientCommand.resolveMiddleware(stack, configuration, options);
+    return async () => handler(this.clientCommand);
+  }
+};
+
+// ../../node_modules/@aws-sdk/lib-dynamodb/dist-es/commands/ScanCommand.js
+var ScanCommand2 = class extends DynamoDBDocumentClientCommand {
+  input;
+  inputKeyNodes = {
+    ScanFilter: {
+      "*": {
+        AttributeValueList: ALL_MEMBERS
+      }
+    },
+    ExclusiveStartKey: ALL_VALUES,
+    ExpressionAttributeValues: ALL_VALUES
+  };
+  outputKeyNodes = {
+    Items: {
+      "*": ALL_VALUES
+    },
+    LastEvaluatedKey: ALL_VALUES
+  };
+  clientCommand;
+  middlewareStack;
+  constructor(input) {
+    super();
+    this.input = input;
+    this.clientCommand = new ScanCommand(this.input);
+    this.middlewareStack = this.clientCommand.middlewareStack;
+  }
+  resolveMiddleware(clientStack, configuration, options) {
+    this.addMarshallingMiddleware(configuration);
+    const stack = clientStack.concat(this.middlewareStack);
+    const handler = this.clientCommand.resolveMiddleware(stack, configuration, options);
+    return async () => handler(this.clientCommand);
+  }
+};
+
+// ../../node_modules/@aws-sdk/lib-dynamodb/dist-es/commands/UpdateCommand.js
+var UpdateCommand = class extends DynamoDBDocumentClientCommand {
+  input;
+  inputKeyNodes = {
+    Key: ALL_VALUES,
+    AttributeUpdates: {
+      "*": {
+        Value: SELF
+      }
+    },
+    Expected: {
+      "*": {
+        Value: SELF,
+        AttributeValueList: ALL_MEMBERS
+      }
+    },
+    ExpressionAttributeValues: ALL_VALUES
+  };
+  outputKeyNodes = {
+    Attributes: ALL_VALUES,
+    ItemCollectionMetrics: {
+      ItemCollectionKey: ALL_VALUES
+    }
+  };
+  clientCommand;
+  middlewareStack;
+  constructor(input) {
+    super();
+    this.input = input;
+    this.clientCommand = new UpdateItemCommand(this.input);
+    this.middlewareStack = this.clientCommand.middlewareStack;
+  }
+  resolveMiddleware(clientStack, configuration, options) {
+    this.addMarshallingMiddleware(configuration);
+    const stack = clientStack.concat(this.middlewareStack);
+    const handler = this.clientCommand.resolveMiddleware(stack, configuration, options);
+    return async () => handler(this.clientCommand);
+  }
+};
+
+// ../../node_modules/@aws-sdk/lib-dynamodb/dist-es/DynamoDBDocumentClient.js
+var DynamoDBDocumentClient = class _DynamoDBDocumentClient extends Client {
+  config;
+  constructor(client2, translateConfig) {
+    super(client2.config);
+    this.config = client2.config;
+    this.config.translateConfig = translateConfig;
+    this.middlewareStack = client2.middlewareStack;
+    if (this.config?.cacheMiddleware) {
+      throw new Error("@aws-sdk/lib-dynamodb - cacheMiddleware=true is not compatible with the DynamoDBDocumentClient. This option must be set to false.");
+    }
+  }
+  static from(client2, translateConfig) {
+    return new _DynamoDBDocumentClient(client2, translateConfig);
+  }
+  destroy() {
+  }
+};
+
+// ../../node_modules/@aws-sdk/lib-dynamodb/dist-es/pagination/QueryPaginator.js
+createPaginator(DynamoDBDocumentClient, QueryCommand2, "ExclusiveStartKey", "LastEvaluatedKey", "Limit");
+
+// ../../node_modules/@aws-sdk/lib-dynamodb/dist-es/pagination/ScanPaginator.js
+createPaginator(DynamoDBDocumentClient, ScanCommand2, "ExclusiveStartKey", "LastEvaluatedKey", "Limit");
+
+// ../task-sqs-adapter/dist/esm/queue-stats.js
+var client = new DynamoDBClient();
+async function incrementFinished(id) {
+  const response = await client.send(updateCommandInput({ task: id, attribute: "finished" }));
+  return response.Attributes?.finished;
+}
+async function incrementFailed(id) {
+  const response = await client.send(updateCommandInput({ task: id, attribute: "failed" }));
+  return response.Attributes?.failed;
+}
+function updateCommandInput({ task, attribute }) {
+  return new UpdateCommand({
+    TableName: process.env.DYNAMODB_TABLE_NAME,
+    Key: { PK: `STATS-${task}`, SK: `STATS-${task}` },
+    UpdateExpression: `SET ${attribute} = if_not_exists(${attribute}, :zero) + :inc`,
+    ExpressionAttributeValues: {
+      ":zero": 0,
+      ":inc": 1
+    },
+    ReturnValues: "UPDATED_NEW"
+  });
+}
+
+// ../task-sqs-adapter/dist/esm/handler.js
+var sqsClient2 = new SQSClient();
+var dynamoDbClient = new DynamoDBClient({});
+function makeSQSTaskHandler(task) {
+  const handler = async (event) => {
+    const failedRecords = [];
+    for (const record of event.Records) {
+      try {
+        await putIdempotencyRecord(record);
+        await runTask(task, record);
+      } catch (error) {
+        console.error("Could not process record", error, record);
+        failedRecords.push(record);
+      }
+    }
+    try {
+      await putFailures(failedRecords);
+      return { batchItemFailures: [] };
+    } catch {
+      await changeMessageVisibility(failedRecords);
+      return {
+        batchItemFailures: failedRecords.map((record) => ({
+          itemIdentifier: record.messageId
+        }))
+      };
+    }
+  };
+  return handler;
+}
+async function changeMessageVisibility(failedRecords) {
+  for (const record of failedRecords) {
+    try {
+      await sqsClient2.send(new ChangeMessageVisibilityCommand({
+        QueueUrl: process.env.QUEUE_URL,
+        ReceiptHandle: record.receiptHandle,
+        VisibilityTimeout: 0
+      }));
+    } catch (e3) {
+      console.debug("Could not change message visibility", e3);
+    }
+  }
+}
+async function runTask(task, record) {
+  let error;
+  try {
+    await task.work({
+      taskId: record.messageId,
+      data: JSON.parse(record.body)
+    });
+  } catch (e3) {
+    console.error(`Error in task: ${task.id}`, e3, record);
+    const options = task.options;
+    if (options?.onError) {
+      try {
+        options.onError(new Error("Task error", { cause: e3 }));
+      } catch {
+      }
+    }
+    error = e3;
+  }
+  try {
+    const incrementFn = error ? incrementFailed : incrementFinished;
+    await incrementFn(task.id);
+  } catch (e3) {
+    console.error("error while setting counter", e3);
+  }
+  if (error) {
+    throw error;
+  }
+}
+async function putIdempotencyRecord(record) {
+  const messageAttributes = record.messageAttributes;
+  const taskId = messageAttributes["taskId"]?.stringValue;
+  if (taskId === void 0) {
+    throw new Error("Expected message attribute with taskId");
+  }
+  const idempotencyId = messageAttributes["executionId"]?.stringValue;
+  if (idempotencyId === void 0) {
+    throw new Error("Expected message attribute with executionId");
+  }
+  await insertId(idempotencyId, 600, { client: dynamoDbClient });
+}
+async function putFailures(records) {
+  if (records.length === 0)
+    return;
+  await dynamoDbClient.send(new BatchWriteItemCommand({
+    RequestItems: {
+      [process.env.DYNAMODB_TABLE_NAME]: records.map((record) => ({
+        PutRequest: {
+          Item: {
+            PK: { S: `FAILED-${process.env.TASK_ID}` },
+            SK: { S: (/* @__PURE__ */ new Date()).toISOString() },
+            data: { S: record.body }
+          }
+        }
+      }))
+    }
+  }));
+}
+
+export { dispatcher, makeSQSTaskHandler };