@digipair/skill-s3 0.136.1 → 0.136.4

package/dist/index.esm20.js

@@ -0,0 +1,4885 @@
+import { H as HttpRequest, n as normalizeProvider, i as isValidHostLabel, e as isIpAddress, h as customEndpointFunctions, j as setFeature, k as CONFIG_PREFIX_SEPARATOR, l as loadConfig, p as parseUrl, m as getSmithyContext, o as setFeature$1, q as normalizeProvider$1, v as toUint8Array, w as fromString, x as fromArrayBuffer } from './index.esm2.js';
+import { release, platform } from 'os';
+import { versions, env } from 'process';
+import { Buffer } from 'buffer';
+import { createHmac, createHash } from 'crypto';
+
+function _array_like_to_array$8(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes$5(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _array_without_holes$3(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array$8(arr);
+}
+function asyncGeneratorStep$f(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator$f(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$f(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$f(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _define_property$7(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _iterable_to_array$4(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _iterable_to_array_limit$4(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest$5() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _non_iterable_spread$3() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _object_spread$5(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property$7(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys$3(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props$3(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys$3(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+function _sliced_to_array$4(arr, i) {
+    return _array_with_holes$5(arr) || _iterable_to_array_limit$4(arr, i) || _unsupported_iterable_to_array$8(arr, i) || _non_iterable_rest$5();
+}
+function _to_consumable_array$3(arr) {
+    return _array_without_holes$3(arr) || _iterable_to_array$4(arr) || _unsupported_iterable_to_array$8(arr) || _non_iterable_spread$3();
+}
+function _type_of$3(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _unsupported_iterable_to_array$8(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array$8(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$8(o, minLen);
+}
+function _ts_generator$f(thisArg, body) {
+    var f, y, t, g, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    };
+    return g = {
+        next: verb(0),
+        "throw": verb(1),
+        "return": verb(2)
+    }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(_)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+var createAggregatedClient = function(commands, Client, options) {
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        var _loop = function() {
+            var _step_value = _sliced_to_array$4(_step.value, 2), command = _step_value[0], CommandCtor = _step_value[1];
+            var methodImpl = function() {
+                var _ref = _async_to_generator$f(function(args, optionsOrCb, cb) {
+                    var command;
+                    return _ts_generator$f(this, function(_state) {
+                        command = new CommandCtor(args);
+                        if (typeof optionsOrCb === "function") {
+                            this.send(command, optionsOrCb);
+                        } else if (typeof cb === "function") {
+                            if ((typeof optionsOrCb === "undefined" ? "undefined" : _type_of$3(optionsOrCb)) !== "object") throw new Error("Expected http options but got ".concat(typeof optionsOrCb === "undefined" ? "undefined" : _type_of$3(optionsOrCb)));
+                            this.send(command, optionsOrCb || {}, cb);
+                        } else {
+                            return [
+                                2,
+                                this.send(command, optionsOrCb)
+                            ];
+                        }
+                        return [
+                            2
+                        ];
+                    });
+                });
+                return function methodImpl(args, optionsOrCb, cb) {
+                    return _ref.apply(this, arguments);
+                };
+            }();
+            var methodName = (command[0].toLowerCase() + command.slice(1)).replace(/Command$/, "");
+            Client.prototype[methodName] = methodImpl;
+        };
+        for(var _iterator = Object.entries(commands)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true)_loop();
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    var _ref = {}, _ref_paginators = _ref.paginators, paginators = _ref_paginators === void 0 ? {} : _ref_paginators, _ref_waiters = _ref.waiters, waiters = _ref_waiters === void 0 ? {} : _ref_waiters;
+    var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+    try {
+        var _loop1 = function() {
+            var _step_value = _sliced_to_array$4(_step1.value, 2), paginatorName = _step_value[0], paginatorFn = _step_value[1];
+            if (Client.prototype[paginatorName] === void 0) {
+                Client.prototype[paginatorName] = function createAggregatedClient() {
+                    var commandInput = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}, paginationConfiguration = arguments.length > 1 ? arguments[1] : void 0;
+                    for(var _len = arguments.length, rest = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++){
+                        rest[_key - 2] = arguments[_key];
+                    }
+                    return paginatorFn.apply(void 0, [
+                        _object_spread_props$3(_object_spread$5({}, paginationConfiguration), {
+                            client: this
+                        }),
+                        commandInput
+                    ].concat(_to_consumable_array$3(rest)));
+                };
+            }
+        };
+        for(var _iterator1 = Object.entries(paginators)[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true)_loop1();
+    } catch (err) {
+        _didIteratorError1 = true;
+        _iteratorError1 = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                _iterator1.return();
+            }
+        } finally{
+            if (_didIteratorError1) {
+                throw _iteratorError1;
+            }
+        }
+    }
+    var _iteratorNormalCompletion2 = true, _didIteratorError2 = false, _iteratorError2 = undefined;
+    try {
+        var _loop2 = function() {
+            var _step_value = _sliced_to_array$4(_step2.value, 2), waiterName = _step_value[0], waiterFn = _step_value[1];
+            if (Client.prototype[waiterName] === void 0) {
+                Client.prototype[waiterName] = /*#__PURE__*/ _async_to_generator$f(function() {
+                    var commandInput, waiterConfiguration, _len, rest, _key, config;
+                    var _arguments = arguments;
+                    return _ts_generator$f(this, function(_state) {
+                        commandInput = _arguments.length > 0 && _arguments[0] !== void 0 ? _arguments[0] : {}, waiterConfiguration = _arguments.length > 1 ? _arguments[1] : void 0;
+                        for(_len = _arguments.length, rest = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++){
+                            rest[_key - 2] = _arguments[_key];
+                        }
+                        config = waiterConfiguration;
+                        if (typeof waiterConfiguration === "number") {
+                            config = {
+                                maxWaitTime: waiterConfiguration
+                            };
+                        }
+                        return [
+                            2,
+                            waiterFn.apply(void 0, [
+                                _object_spread_props$3(_object_spread$5({}, config), {
+                                    client: this
+                                }),
+                                commandInput
+                            ].concat(_to_consumable_array$3(rest)))
+                        ];
+                    });
+                });
+            }
+        };
+        for(var _iterator2 = Object.entries(waiters)[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true)_loop2();
+    } catch (err) {
+        _didIteratorError2 = true;
+        _iteratorError2 = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+                _iterator2.return();
+            }
+        } finally{
+            if (_didIteratorError2) {
+                throw _iteratorError2;
+            }
+        }
+    }
+};
+
+function asyncGeneratorStep$e(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator$e(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$e(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$e(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _ts_generator$e(thisArg, body) {
+    var f, y, t, g, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    };
+    return g = {
+        next: verb(0),
+        "throw": verb(1),
+        "return": verb(2)
+    }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(_)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+function resolveHostHeaderConfig(input) {
+    return input;
+}
+var hostHeaderMiddleware = function(options) {
+    return function(next) {
+        return function() {
+            var _ref = _async_to_generator$e(function(args) {
+                var request, _ref, _ref_handlerProtocol, handlerProtocol, host;
+                return _ts_generator$e(this, function(_state) {
+                    if (!HttpRequest.isInstance(args.request)) return [
+                        2,
+                        next(args)
+                    ];
+                    request = args.request;
+                    _ref = options.requestHandler.metadata || {}, _ref_handlerProtocol = _ref.handlerProtocol, handlerProtocol = _ref_handlerProtocol === void 0 ? "" : _ref_handlerProtocol;
+                    if (handlerProtocol.indexOf("h2") >= 0 && !request.headers[":authority"]) {
+                        delete request.headers["host"];
+                        request.headers[":authority"] = request.hostname + (request.port ? ":" + request.port : "");
+                    } else if (!request.headers["host"]) {
+                        host = request.hostname;
+                        if (request.port != null) host += ":".concat(request.port);
+                        request.headers["host"] = host;
+                    }
+                    return [
+                        2,
+                        next(args)
+                    ];
+                });
+            });
+            return function(args) {
+                return _ref.apply(this, arguments);
+            };
+        }();
+    };
+};
+var hostHeaderMiddlewareOptions = {
+    name: "hostHeaderMiddleware",
+    step: "build",
+    priority: "low",
+    tags: [
+        "HOST"
+    ],
+    override: true
+};
+var getHostHeaderPlugin = function(options) {
+    return {
+        applyToStack: function(clientStack) {
+            clientStack.add(hostHeaderMiddleware(options), hostHeaderMiddlewareOptions);
+        }
+    };
+};
+
+function asyncGeneratorStep$d(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator$d(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$d(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$d(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _object_without_properties(source, excluded) {
+    if (source == null) return {};
+    var target = _object_without_properties_loose(source, excluded);
+    var key, i;
+    if (Object.getOwnPropertySymbols) {
+        var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+        for(i = 0; i < sourceSymbolKeys.length; i++){
+            key = sourceSymbolKeys[i];
+            if (excluded.indexOf(key) >= 0) continue;
+            if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+            target[key] = source[key];
+        }
+    }
+    return target;
+}
+function _object_without_properties_loose(source, excluded) {
+    if (source == null) return {};
+    var target = {};
+    var sourceKeys = Object.keys(source);
+    var key, i;
+    for(i = 0; i < sourceKeys.length; i++){
+        key = sourceKeys[i];
+        if (excluded.indexOf(key) >= 0) continue;
+        target[key] = source[key];
+    }
+    return target;
+}
+function _ts_generator$d(thisArg, body) {
+    var f, y, t, g, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    };
+    return g = {
+        next: verb(0),
+        "throw": verb(1),
+        "return": verb(2)
+    }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(_)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+var loggerMiddleware = function() {
+    return function(next, context) {
+        return function() {
+            var _ref = _async_to_generator$d(function(args) {
+                var _logger_info, response, clientName, commandName, logger, _context_dynamoDbDocumentClientOptions, dynamoDbDocumentClientOptions, overrideInputFilterSensitiveLog, overrideOutputFilterSensitiveLog, inputFilterSensitiveLog, outputFilterSensitiveLog, _response_output, $metadata, outputWithoutMetadata, error, _logger_error, clientName1, commandName1, logger1, _context_dynamoDbDocumentClientOptions1, dynamoDbDocumentClientOptions1, overrideInputFilterSensitiveLog1, inputFilterSensitiveLog1;
+                return _ts_generator$d(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            _state.trys.push([
+                                0,
+                                2,
+                                ,
+                                3
+                            ]);
+                            return [
+                                4,
+                                next(args)
+                            ];
+                        case 1:
+                            response = _state.sent();
+                            clientName = context.clientName, commandName = context.commandName, logger = context.logger, _context_dynamoDbDocumentClientOptions = context.dynamoDbDocumentClientOptions, dynamoDbDocumentClientOptions = _context_dynamoDbDocumentClientOptions === void 0 ? {} : _context_dynamoDbDocumentClientOptions;
+                            overrideInputFilterSensitiveLog = dynamoDbDocumentClientOptions.overrideInputFilterSensitiveLog, overrideOutputFilterSensitiveLog = dynamoDbDocumentClientOptions.overrideOutputFilterSensitiveLog;
+                            inputFilterSensitiveLog = overrideInputFilterSensitiveLog !== null && overrideInputFilterSensitiveLog !== void 0 ? overrideInputFilterSensitiveLog : context.inputFilterSensitiveLog;
+                            outputFilterSensitiveLog = overrideOutputFilterSensitiveLog !== null && overrideOutputFilterSensitiveLog !== void 0 ? overrideOutputFilterSensitiveLog : context.outputFilterSensitiveLog;
+                            _response_output = response.output, $metadata = _response_output.$metadata, outputWithoutMetadata = _object_without_properties(_response_output, [
+                                "$metadata"
+                            ]);
+                            logger === null || logger === void 0 ? void 0 : (_logger_info = logger.info) === null || _logger_info === void 0 ? void 0 : _logger_info.call(logger, {
+                                clientName: clientName,
+                                commandName: commandName,
+                                input: inputFilterSensitiveLog(args.input),
+                                output: outputFilterSensitiveLog(outputWithoutMetadata),
+                                metadata: $metadata
+                            });
+                            return [
+                                2,
+                                response
+                            ];
+                        case 2:
+                            error = _state.sent();
+                            clientName1 = context.clientName, commandName1 = context.commandName, logger1 = context.logger, _context_dynamoDbDocumentClientOptions1 = context.dynamoDbDocumentClientOptions, dynamoDbDocumentClientOptions1 = _context_dynamoDbDocumentClientOptions1 === void 0 ? {} : _context_dynamoDbDocumentClientOptions1;
+                            overrideInputFilterSensitiveLog1 = dynamoDbDocumentClientOptions1.overrideInputFilterSensitiveLog;
+                            inputFilterSensitiveLog1 = overrideInputFilterSensitiveLog1 !== null && overrideInputFilterSensitiveLog1 !== void 0 ? overrideInputFilterSensitiveLog1 : context.inputFilterSensitiveLog;
+                            logger1 === null || logger1 === void 0 ? void 0 : (_logger_error = logger1.error) === null || _logger_error === void 0 ? void 0 : _logger_error.call(logger1, {
+                                clientName: clientName1,
+                                commandName: commandName1,
+                                input: inputFilterSensitiveLog1(args.input),
+                                error: error,
+                                metadata: error.$metadata
+                            });
+                            throw error;
+                        case 3:
+                            return [
+                                2
+                            ];
+                    }
+                });
+            });
+            return function(args) {
+                return _ref.apply(this, arguments);
+            };
+        }();
+    };
+};
+var loggerMiddlewareOptions = {
+    name: "loggerMiddleware",
+    tags: [
+        "LOGGER"
+    ],
+    step: "initialize",
+    override: true
+};
+var getLoggerPlugin = function(options) {
+    return {
+        applyToStack: function(clientStack) {
+            clientStack.add(loggerMiddleware(), loggerMiddlewareOptions);
+        }
+    };
+};
+
+var recursionDetectionMiddlewareOptions = {
+    step: "build",
+    tags: [
+        "RECURSION_DETECTION"
+    ],
+    name: "recursionDetectionMiddleware",
+    override: true,
+    priority: "low"
+};
+
+function _assert_this_initialized(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function asyncGeneratorStep$c(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator$c(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$c(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$c(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _class_call_check$1(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties$1(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class$1(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties$1(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties$1(Constructor, staticProps);
+    return Constructor;
+}
+function _define_property$6(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _get_prototype_of(o) {
+    _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _get_prototype_of(o);
+}
+function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _set_prototype_of(subClass, superClass);
+}
+function _possible_constructor_return(self, call) {
+    if (call && (_type_of$2(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assert_this_initialized(self);
+}
+function _set_prototype_of(o, p) {
+    _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of(o, p);
+}
+function _type_of$2(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _is_native_reflect_construct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _create_super(Derived) {
+    var hasNativeReflectConstruct = _is_native_reflect_construct();
+    return function _createSuperInternal() {
+        var Super = _get_prototype_of(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _get_prototype_of(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possible_constructor_return(this, result);
+    };
+}
+function _ts_generator$c(thisArg, body) {
+    var f, y, t, g, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    };
+    return g = {
+        next: verb(0),
+        "throw": verb(1),
+        "return": verb(2)
+    }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(_)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+var _process_env;
+var PROTECTED_KEYS = {
+    REQUEST_ID: Symbol.for("_AWS_LAMBDA_REQUEST_ID"),
+    X_RAY_TRACE_ID: Symbol.for("_AWS_LAMBDA_X_RAY_TRACE_ID"),
+    TENANT_ID: Symbol.for("_AWS_LAMBDA_TENANT_ID")
+};
+var _process_env_AWS_LAMBDA_NODEJS_NO_GLOBAL_AWSLAMBDA;
+var NO_GLOBAL_AWS_LAMBDA = [
+    "true",
+    "1"
+].includes((_process_env_AWS_LAMBDA_NODEJS_NO_GLOBAL_AWSLAMBDA = (_process_env = process.env) === null || _process_env === void 0 ? void 0 : _process_env.AWS_LAMBDA_NODEJS_NO_GLOBAL_AWSLAMBDA) !== null && _process_env_AWS_LAMBDA_NODEJS_NO_GLOBAL_AWSLAMBDA !== void 0 ? _process_env_AWS_LAMBDA_NODEJS_NO_GLOBAL_AWSLAMBDA : "");
+if (!NO_GLOBAL_AWS_LAMBDA) {
+    globalThis.awslambda = globalThis.awslambda || {};
+}
+var InvokeStoreBase = /*#__PURE__*/ function() {
+    function InvokeStoreBase() {
+        _class_call_check$1(this, InvokeStoreBase);
+    }
+    _create_class$1(InvokeStoreBase, [
+        {
+            key: "isProtectedKey",
+            value: function isProtectedKey(key) {
+                return Object.values(PROTECTED_KEYS).includes(key);
+            }
+        },
+        {
+            key: "getRequestId",
+            value: function getRequestId() {
+                var _this_get;
+                return (_this_get = this.get(PROTECTED_KEYS.REQUEST_ID)) !== null && _this_get !== void 0 ? _this_get : "-";
+            }
+        },
+        {
+            key: "getXRayTraceId",
+            value: function getXRayTraceId() {
+                return this.get(PROTECTED_KEYS.X_RAY_TRACE_ID);
+            }
+        },
+        {
+            key: "getTenantId",
+            value: function getTenantId() {
+                return this.get(PROTECTED_KEYS.TENANT_ID);
+            }
+        }
+    ]);
+    return InvokeStoreBase;
+}();
+_define_property$6(InvokeStoreBase, "PROTECTED_KEYS", PROTECTED_KEYS);
+var InvokeStoreSingle = /*#__PURE__*/ function(InvokeStoreBase) {
+    _inherits(InvokeStoreSingle, InvokeStoreBase);
+    var _super = _create_super(InvokeStoreSingle);
+    function InvokeStoreSingle() {
+        _class_call_check$1(this, InvokeStoreSingle);
+        var _this;
+        _this = _super.apply(this, arguments);
+        _define_property$6(_assert_this_initialized(_this), "currentContext", void 0);
+        return _this;
+    }
+    _create_class$1(InvokeStoreSingle, [
+        {
+            key: "getContext",
+            value: function getContext() {
+                return this.currentContext;
+            }
+        },
+        {
+            key: "hasContext",
+            value: function hasContext() {
+                return this.currentContext !== undefined;
+            }
+        },
+        {
+            key: "get",
+            value: function get(key) {
+                var _this_currentContext;
+                return (_this_currentContext = this.currentContext) === null || _this_currentContext === void 0 ? void 0 : _this_currentContext[key];
+            }
+        },
+        {
+            key: "set",
+            value: function set(key, value) {
+                if (this.isProtectedKey(key)) {
+                    throw new Error("Cannot modify protected Lambda context field: ".concat(String(key)));
+                }
+                this.currentContext = this.currentContext || {};
+                this.currentContext[key] = value;
+            }
+        },
+        {
+            key: "run",
+            value: function run(context, fn) {
+                this.currentContext = context;
+                return fn();
+            }
+        }
+    ]);
+    return InvokeStoreSingle;
+}(InvokeStoreBase);
+var InvokeStoreMulti = /*#__PURE__*/ function(InvokeStoreBase) {
+    _inherits(InvokeStoreMulti, InvokeStoreBase);
+    var _super = _create_super(InvokeStoreMulti);
+    function InvokeStoreMulti() {
+        _class_call_check$1(this, InvokeStoreMulti);
+        var _this;
+        _this = _super.apply(this, arguments);
+        _define_property$6(_assert_this_initialized(_this), "als", void 0);
+        return _this;
+    }
+    _create_class$1(InvokeStoreMulti, [
+        {
+            key: "getContext",
+            value: function getContext() {
+                return this.als.getStore();
+            }
+        },
+        {
+            key: "hasContext",
+            value: function hasContext() {
+                return this.als.getStore() !== undefined;
+            }
+        },
+        {
+            key: "get",
+            value: function get(key) {
+                var _this_als_getStore;
+                return (_this_als_getStore = this.als.getStore()) === null || _this_als_getStore === void 0 ? void 0 : _this_als_getStore[key];
+            }
+        },
+        {
+            key: "set",
+            value: function set(key, value) {
+                if (this.isProtectedKey(key)) {
+                    throw new Error("Cannot modify protected Lambda context field: ".concat(String(key)));
+                }
+                var store = this.als.getStore();
+                if (!store) {
+                    throw new Error("No context available");
+                }
+                store[key] = value;
+            }
+        },
+        {
+            key: "run",
+            value: function run(context, fn) {
+                return this.als.run(context, fn);
+            }
+        }
+    ], [
+        {
+            key: "create",
+            value: function create() {
+                return _async_to_generator$c(function() {
+                    var instance, asyncHooks;
+                    return _ts_generator$c(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                instance = new InvokeStoreMulti();
+                                return [
+                                    4,
+                                    import('node:async_hooks')
+                                ];
+                            case 1:
+                                asyncHooks = _state.sent();
+                                instance.als = new asyncHooks.AsyncLocalStorage();
+                                return [
+                                    2,
+                                    instance
+                                ];
+                        }
+                    });
+                })();
+            }
+        }
+    ]);
+    return InvokeStoreMulti;
+}(InvokeStoreBase);
+var InvokeStore;
+(function(InvokeStore) {
+    var instance = null;
+    function getInstanceAsync() {
+        return _getInstanceAsync.apply(this, arguments);
+    }
+    function _getInstanceAsync() {
+        _getInstanceAsync = _async_to_generator$c(function() {
+            return _ts_generator$c(this, function(_state) {
+                if (!instance) {
+                    instance = _async_to_generator$c(function() {
+                        var _globalThis_awslambda, isMulti, newInstance, _tmp;
+                        return _ts_generator$c(this, function(_state) {
+                            switch(_state.label){
+                                case 0:
+                                    isMulti = "AWS_LAMBDA_MAX_CONCURRENCY" in process.env;
+                                    if (!isMulti) return [
+                                        3,
+                                        2
+                                    ];
+                                    return [
+                                        4,
+                                        InvokeStoreMulti.create()
+                                    ];
+                                case 1:
+                                    _tmp = _state.sent();
+                                    return [
+                                        3,
+                                        3
+                                    ];
+                                case 2:
+                                    _tmp = new InvokeStoreSingle();
+                                    _state.label = 3;
+                                case 3:
+                                    newInstance = _tmp;
+                                    if (!NO_GLOBAL_AWS_LAMBDA && ((_globalThis_awslambda = globalThis.awslambda) === null || _globalThis_awslambda === void 0 ? void 0 : _globalThis_awslambda.InvokeStore)) {
+                                        return [
+                                            2,
+                                            globalThis.awslambda.InvokeStore
+                                        ];
+                                    } else if (!NO_GLOBAL_AWS_LAMBDA && globalThis.awslambda) {
+                                        globalThis.awslambda.InvokeStore = newInstance;
+                                        return [
+                                            2,
+                                            newInstance
+                                        ];
+                                    } else {
+                                        return [
+                                            2,
+                                            newInstance
+                                        ];
+                                    }
+                            }
+                        });
+                    })();
+                }
+                return [
+                    2,
+                    instance
+                ];
+            });
+        });
+        return _getInstanceAsync.apply(this, arguments);
+    }
+    InvokeStore.getInstanceAsync = getInstanceAsync;
+    InvokeStore._testing = process.env.AWS_LAMBDA_BENCHMARK_MODE === "1" ? {
+        reset: function() {
+            var _globalThis_awslambda;
+            instance = null;
+            if ((_globalThis_awslambda = globalThis.awslambda) === null || _globalThis_awslambda === void 0 ? void 0 : _globalThis_awslambda.InvokeStore) {
+                delete globalThis.awslambda.InvokeStore;
+            }
+            globalThis.awslambda = {
+                InvokeStore: undefined
+            };
+        }
+    } : undefined;
+})(InvokeStore || (InvokeStore = {}));
+
+function asyncGeneratorStep$b(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator$b(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$b(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$b(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _define_property$5(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _object_spread$4(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property$5(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys$2(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props$2(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys$2(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+function _ts_generator$b(thisArg, body) {
+    var f, y, t, g, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    };
+    return g = {
+        next: verb(0),
+        "throw": verb(1),
+        "return": verb(2)
+    }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(_)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+var TRACE_ID_HEADER_NAME = "X-Amzn-Trace-Id";
+var ENV_LAMBDA_FUNCTION_NAME = "AWS_LAMBDA_FUNCTION_NAME";
+var ENV_TRACE_ID = "_X_AMZN_TRACE_ID";
+var recursionDetectionMiddleware = function() {
+    return function(next) {
+        return function() {
+            var _ref = _async_to_generator$b(function(args) {
+                var request, _request_headers, _Object_keys_find, traceIdHeader, functionName, traceIdFromEnv, invokeStore, traceIdFromInvokeStore, traceId, nonEmptyString;
+                return _ts_generator$b(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            request = args.request;
+                            if (!HttpRequest.isInstance(request)) {
+                                return [
+                                    2,
+                                    next(args)
+                                ];
+                            }
+                            traceIdHeader = (_Object_keys_find = Object.keys((_request_headers = request.headers) !== null && _request_headers !== void 0 ? _request_headers : {}).find(function(h) {
+                                return h.toLowerCase() === TRACE_ID_HEADER_NAME.toLowerCase();
+                            })) !== null && _Object_keys_find !== void 0 ? _Object_keys_find : TRACE_ID_HEADER_NAME;
+                            if (request.headers.hasOwnProperty(traceIdHeader)) {
+                                return [
+                                    2,
+                                    next(args)
+                                ];
+                            }
+                            functionName = process.env[ENV_LAMBDA_FUNCTION_NAME];
+                            traceIdFromEnv = process.env[ENV_TRACE_ID];
+                            return [
+                                4,
+                                InvokeStore.getInstanceAsync()
+                            ];
+                        case 1:
+                            invokeStore = _state.sent();
+                            traceIdFromInvokeStore = invokeStore === null || invokeStore === void 0 ? void 0 : invokeStore.getXRayTraceId();
+                            traceId = traceIdFromInvokeStore !== null && traceIdFromInvokeStore !== void 0 ? traceIdFromInvokeStore : traceIdFromEnv;
+                            nonEmptyString = function(str) {
+                                return typeof str === "string" && str.length > 0;
+                            };
+                            if (nonEmptyString(functionName) && nonEmptyString(traceId)) {
+                                request.headers[TRACE_ID_HEADER_NAME] = traceId;
+                            }
+                            return [
+                                2,
+                                next(_object_spread_props$2(_object_spread$4({}, args), {
+                                    request: request
+                                }))
+                            ];
+                    }
+                });
+            });
+            return function(args) {
+                return _ref.apply(this, arguments);
+            };
+        }();
+    };
+};
+
+var getRecursionDetectionPlugin = function(options) {
+    return {
+        applyToStack: function(clientStack) {
+            clientStack.add(recursionDetectionMiddleware(), recursionDetectionMiddlewareOptions);
+        }
+    };
+};
+
+function asyncGeneratorStep$a(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator$a(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$a(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$a(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _ts_generator$a(thisArg, body) {
+    var f, y, t, g, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    };
+    return g = {
+        next: verb(0),
+        "throw": verb(1),
+        "return": verb(2)
+    }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(_)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+var DEFAULT_UA_APP_ID = undefined;
+function isValidUserAgentAppId(appId) {
+    if (appId === undefined) {
+        return true;
+    }
+    return typeof appId === "string" && appId.length <= 50;
+}
+function resolveUserAgentConfig(input) {
+    var _input_userAgentAppId;
+    var normalizedAppIdProvider = normalizeProvider((_input_userAgentAppId = input.userAgentAppId) !== null && _input_userAgentAppId !== void 0 ? _input_userAgentAppId : DEFAULT_UA_APP_ID);
+    var customUserAgent = input.customUserAgent;
+    return Object.assign(input, {
+        customUserAgent: typeof customUserAgent === "string" ? [
+            [
+                customUserAgent
+            ]
+        ] : customUserAgent,
+        userAgentAppId: /*#__PURE__*/ _async_to_generator$a(function() {
+            var appId, _input_logger_constructor, _input_logger, logger;
+            return _ts_generator$a(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        return [
+                            4,
+                            normalizedAppIdProvider()
+                        ];
+                    case 1:
+                        appId = _state.sent();
+                        if (!isValidUserAgentAppId(appId)) {
+                            logger = ((_input_logger = input.logger) === null || _input_logger === void 0 ? void 0 : (_input_logger_constructor = _input_logger.constructor) === null || _input_logger_constructor === void 0 ? void 0 : _input_logger_constructor.name) === "NoOpLogger" || !input.logger ? console : input.logger;
+                            if (typeof appId !== "string") {
+                                logger === null || logger === void 0 ? void 0 : logger.warn("userAgentAppId must be a string or undefined.");
+                            } else if (appId.length > 50) {
+                                logger === null || logger === void 0 ? void 0 : logger.warn("The provided userAgentAppId exceeds the maximum length of 50 characters.");
+                            }
+                        }
+                        return [
+                            2,
+                            appId
+                        ];
+                }
+            });
+        })
+    });
+}
+
+var isVirtualHostableS3Bucket = function(value) {
+    var allowSubDomains = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false;
+    if (allowSubDomains) {
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            for(var _iterator = value.split(".")[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                var label = _step.value;
+                if (!isVirtualHostableS3Bucket(label)) {
+                    return false;
+                }
+            }
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
+        return true;
+    }
+    if (!isValidHostLabel(value)) {
+        return false;
+    }
+    if (value.length < 3 || value.length > 63) {
+        return false;
+    }
+    if (value !== value.toLowerCase()) {
+        return false;
+    }
+    if (isIpAddress(value)) {
+        return false;
+    }
+    return true;
+};
+
+function _array_like_to_array$7(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes$4(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _iterable_to_array$3(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_rest$4() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _to_array(arr) {
+    return _array_with_holes$4(arr) || _iterable_to_array$3(arr) || _unsupported_iterable_to_array$7(arr) || _non_iterable_rest$4();
+}
+function _unsupported_iterable_to_array$7(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array$7(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$7(o, minLen);
+}
+var ARN_DELIMITER = ":";
+var RESOURCE_DELIMITER = "/";
+var parseArn = function(value) {
+    var segments = value.split(ARN_DELIMITER);
+    if (segments.length < 6) return null;
+    var _segments = _to_array(segments), arn = _segments[0], partition = _segments[1], service = _segments[2], region = _segments[3], accountId = _segments[4], resourcePath = _segments.slice(5);
+    if (arn !== "arn" || partition === "" || service === "" || resourcePath.join(ARN_DELIMITER) === "") return null;
+    var resourceId = resourcePath.map(function(resource) {
+        return resource.split(RESOURCE_DELIMITER);
+    }).flat();
+    return {
+        partition: partition,
+        service: service,
+        region: region,
+        accountId: accountId,
+        resourceId: resourceId
+    };
+};
+
+var partitions = [
+    {
+        id: "aws",
+        outputs: {
+            dnsSuffix: "amazonaws.com",
+            dualStackDnsSuffix: "api.aws",
+            implicitGlobalRegion: "us-east-1",
+            name: "aws",
+            supportsDualStack: true,
+            supportsFIPS: true
+        },
+        regionRegex: "^(us|eu|ap|sa|ca|me|af|il|mx)\\-\\w+\\-\\d+$",
+        regions: {
+            "af-south-1": {
+                description: "Africa (Cape Town)"
+            },
+            "ap-east-1": {
+                description: "Asia Pacific (Hong Kong)"
+            },
+            "ap-east-2": {
+                description: "Asia Pacific (Taipei)"
+            },
+            "ap-northeast-1": {
+                description: "Asia Pacific (Tokyo)"
+            },
+            "ap-northeast-2": {
+                description: "Asia Pacific (Seoul)"
+            },
+            "ap-northeast-3": {
+                description: "Asia Pacific (Osaka)"
+            },
+            "ap-south-1": {
+                description: "Asia Pacific (Mumbai)"
+            },
+            "ap-south-2": {
+                description: "Asia Pacific (Hyderabad)"
+            },
+            "ap-southeast-1": {
+                description: "Asia Pacific (Singapore)"
+            },
+            "ap-southeast-2": {
+                description: "Asia Pacific (Sydney)"
+            },
+            "ap-southeast-3": {
+                description: "Asia Pacific (Jakarta)"
+            },
+            "ap-southeast-4": {
+                description: "Asia Pacific (Melbourne)"
+            },
+            "ap-southeast-5": {
+                description: "Asia Pacific (Malaysia)"
+            },
+            "ap-southeast-6": {
+                description: "Asia Pacific (New Zealand)"
+            },
+            "ap-southeast-7": {
+                description: "Asia Pacific (Thailand)"
+            },
+            "aws-global": {
+                description: "aws global region"
+            },
+            "ca-central-1": {
+                description: "Canada (Central)"
+            },
+            "ca-west-1": {
+                description: "Canada West (Calgary)"
+            },
+            "eu-central-1": {
+                description: "Europe (Frankfurt)"
+            },
+            "eu-central-2": {
+                description: "Europe (Zurich)"
+            },
+            "eu-north-1": {
+                description: "Europe (Stockholm)"
+            },
+            "eu-south-1": {
+                description: "Europe (Milan)"
+            },
+            "eu-south-2": {
+                description: "Europe (Spain)"
+            },
+            "eu-west-1": {
+                description: "Europe (Ireland)"
+            },
+            "eu-west-2": {
+                description: "Europe (London)"
+            },
+            "eu-west-3": {
+                description: "Europe (Paris)"
+            },
+            "il-central-1": {
+                description: "Israel (Tel Aviv)"
+            },
+            "me-central-1": {
+                description: "Middle East (UAE)"
+            },
+            "me-south-1": {
+                description: "Middle East (Bahrain)"
+            },
+            "mx-central-1": {
+                description: "Mexico (Central)"
+            },
+            "sa-east-1": {
+                description: "South America (Sao Paulo)"
+            },
+            "us-east-1": {
+                description: "US East (N. Virginia)"
+            },
+            "us-east-2": {
+                description: "US East (Ohio)"
+            },
+            "us-west-1": {
+                description: "US West (N. California)"
+            },
+            "us-west-2": {
+                description: "US West (Oregon)"
+            }
+        }
+    },
+    {
+        id: "aws-cn",
+        outputs: {
+            dnsSuffix: "amazonaws.com.cn",
+            dualStackDnsSuffix: "api.amazonwebservices.com.cn",
+            implicitGlobalRegion: "cn-northwest-1",
+            name: "aws-cn",
+            supportsDualStack: true,
+            supportsFIPS: true
+        },
+        regionRegex: "^cn\\-\\w+\\-\\d+$",
+        regions: {
+            "aws-cn-global": {
+                description: "aws-cn global region"
+            },
+            "cn-north-1": {
+                description: "China (Beijing)"
+            },
+            "cn-northwest-1": {
+                description: "China (Ningxia)"
+            }
+        }
+    },
+    {
+        id: "aws-eusc",
+        outputs: {
+            dnsSuffix: "amazonaws.eu",
+            dualStackDnsSuffix: "api.amazonwebservices.eu",
+            implicitGlobalRegion: "eusc-de-east-1",
+            name: "aws-eusc",
+            supportsDualStack: true,
+            supportsFIPS: true
+        },
+        regionRegex: "^eusc\\-(de)\\-\\w+\\-\\d+$",
+        regions: {
+            "eusc-de-east-1": {
+                description: "AWS European Sovereign Cloud (Germany)"
+            }
+        }
+    },
+    {
+        id: "aws-iso",
+        outputs: {
+            dnsSuffix: "c2s.ic.gov",
+            dualStackDnsSuffix: "api.aws.ic.gov",
+            implicitGlobalRegion: "us-iso-east-1",
+            name: "aws-iso",
+            supportsDualStack: true,
+            supportsFIPS: true
+        },
+        regionRegex: "^us\\-iso\\-\\w+\\-\\d+$",
+        regions: {
+            "aws-iso-global": {
+                description: "aws-iso global region"
+            },
+            "us-iso-east-1": {
+                description: "US ISO East"
+            },
+            "us-iso-west-1": {
+                description: "US ISO WEST"
+            }
+        }
+    },
+    {
+        id: "aws-iso-b",
+        outputs: {
+            dnsSuffix: "sc2s.sgov.gov",
+            dualStackDnsSuffix: "api.aws.scloud",
+            implicitGlobalRegion: "us-isob-east-1",
+            name: "aws-iso-b",
+            supportsDualStack: true,
+            supportsFIPS: true
+        },
+        regionRegex: "^us\\-isob\\-\\w+\\-\\d+$",
+        regions: {
+            "aws-iso-b-global": {
+                description: "aws-iso-b global region"
+            },
+            "us-isob-east-1": {
+                description: "US ISOB East (Ohio)"
+            },
+            "us-isob-west-1": {
+                description: "US ISOB West"
+            }
+        }
+    },
+    {
+        id: "aws-iso-e",
+        outputs: {
+            dnsSuffix: "cloud.adc-e.uk",
+            dualStackDnsSuffix: "api.cloud-aws.adc-e.uk",
+            implicitGlobalRegion: "eu-isoe-west-1",
+            name: "aws-iso-e",
+            supportsDualStack: true,
+            supportsFIPS: true
+        },
+        regionRegex: "^eu\\-isoe\\-\\w+\\-\\d+$",
+        regions: {
+            "aws-iso-e-global": {
+                description: "aws-iso-e global region"
+            },
+            "eu-isoe-west-1": {
+                description: "EU ISOE West"
+            }
+        }
+    },
+    {
+        id: "aws-iso-f",
+        outputs: {
+            dnsSuffix: "csp.hci.ic.gov",
+            dualStackDnsSuffix: "api.aws.hci.ic.gov",
+            implicitGlobalRegion: "us-isof-south-1",
+            name: "aws-iso-f",
+            supportsDualStack: true,
+            supportsFIPS: true
+        },
+        regionRegex: "^us\\-isof\\-\\w+\\-\\d+$",
+        regions: {
+            "aws-iso-f-global": {
+                description: "aws-iso-f global region"
+            },
+            "us-isof-east-1": {
+                description: "US ISOF EAST"
+            },
+            "us-isof-south-1": {
+                description: "US ISOF SOUTH"
+            }
+        }
+    },
+    {
+        id: "aws-us-gov",
+        outputs: {
+            dnsSuffix: "amazonaws.com",
+            dualStackDnsSuffix: "api.aws",
+            implicitGlobalRegion: "us-gov-west-1",
+            name: "aws-us-gov",
+            supportsDualStack: true,
+            supportsFIPS: true
+        },
+        regionRegex: "^us\\-gov\\-\\w+\\-\\d+$",
+        regions: {
+            "aws-us-gov-global": {
+                description: "aws-us-gov global region"
+            },
+            "us-gov-east-1": {
+                description: "AWS GovCloud (US-East)"
+            },
+            "us-gov-west-1": {
+                description: "AWS GovCloud (US-West)"
+            }
+        }
+    }
+];
+var partitionsInfo = {
+    partitions: partitions};
+
+function _array_like_to_array$6(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes$3(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _define_property$4(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _iterable_to_array_limit$3(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest$3() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _object_spread$3(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property$4(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function _sliced_to_array$3(arr, i) {
+    return _array_with_holes$3(arr) || _iterable_to_array_limit$3(arr, i) || _unsupported_iterable_to_array$6(arr, i) || _non_iterable_rest$3();
+}
+function _unsupported_iterable_to_array$6(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array$6(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$6(o, minLen);
+}
+var selectedPartitionsInfo = partitionsInfo;
+var selectedUserAgentPrefix = "";
+var partition = function(value) {
+    var partitions = selectedPartitionsInfo.partitions;
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = partitions[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var partition = _step.value;
+            var regions = partition.regions, outputs = partition.outputs;
+            var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+            try {
+                for(var _iterator1 = Object.entries(regions)[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+                    var _step_value = _sliced_to_array$3(_step1.value, 2), region = _step_value[0], regionData = _step_value[1];
+                    if (region === value) {
+                        return _object_spread$3({}, outputs, regionData);
+                    }
+                }
+            } catch (err) {
+                _didIteratorError1 = true;
+                _iteratorError1 = err;
+            } finally{
+                try {
+                    if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                        _iterator1.return();
+                    }
+                } finally{
+                    if (_didIteratorError1) {
+                        throw _iteratorError1;
+                    }
+                }
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    var _iteratorNormalCompletion2 = true, _didIteratorError2 = false, _iteratorError2 = undefined;
+    try {
+        for(var _iterator2 = partitions[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true){
+            var partition1 = _step2.value;
+            var regionRegex = partition1.regionRegex, outputs1 = partition1.outputs;
+            if (new RegExp(regionRegex).test(value)) {
+                return _object_spread$3({}, outputs1);
+            }
+        }
+    } catch (err) {
+        _didIteratorError2 = true;
+        _iteratorError2 = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+                _iterator2.return();
+            }
+        } finally{
+            if (_didIteratorError2) {
+                throw _iteratorError2;
+            }
+        }
+    }
+    var DEFAULT_PARTITION = partitions.find(function(partition) {
+        return partition.id === "aws";
+    });
+    if (!DEFAULT_PARTITION) {
+        throw new Error("Provided region was not found in the partition array or regex," + " and default partition with id 'aws' doesn't exist.");
+    }
+    return _object_spread$3({}, DEFAULT_PARTITION.outputs);
+};
+var getUserAgentPrefix = function() {
+    return selectedUserAgentPrefix;
+};
+
+var awsEndpointFunctions = {
+    isVirtualHostableS3Bucket: isVirtualHostableS3Bucket,
+    parseArn: parseArn,
+    partition: partition
+};
+customEndpointFunctions.aws = awsEndpointFunctions;
+
+function _array_like_to_array$5(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes$2(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function asyncGeneratorStep$9(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator$9(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$9(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$9(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _iterable_to_array_limit$2(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest$2() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _sliced_to_array$2(arr, i) {
+    return _array_with_holes$2(arr) || _iterable_to_array_limit$2(arr, i) || _unsupported_iterable_to_array$5(arr, i) || _non_iterable_rest$2();
+}
+function _unsupported_iterable_to_array$5(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array$5(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$5(o, minLen);
+}
+function _ts_generator$9(thisArg, body) {
+    var f, y, t, g, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    };
+    return g = {
+        next: verb(0),
+        "throw": verb(1),
+        "return": verb(2)
+    }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(_)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+var ACCOUNT_ID_ENDPOINT_REGEX = /\d{12}\.ddb/;
+function checkFeatures(context, config, args) {
+    return _checkFeatures.apply(this, arguments);
+}
+function _checkFeatures() {
+    _checkFeatures = _async_to_generator$9(function(context, config, args) {
+        var _request_headers, _context___smithy_context_selectedHttpAuthScheme, _context___smithy_context, request, retryStrategy, _retryStrategy_constructor_name, _retryStrategy_constructor, _endpointV2_url, _config_accountIdEndpointMode, endpointV2, identity, credentials, _credentials_$source, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _step_value, key, value;
+        return _ts_generator$9(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    request = args.request;
+                    if ((request === null || request === void 0 ? void 0 : (_request_headers = request.headers) === null || _request_headers === void 0 ? void 0 : _request_headers["smithy-protocol"]) === "rpc-v2-cbor") {
+                        setFeature(context, "PROTOCOL_RPC_V2_CBOR", "M");
+                    }
+                    if (!(typeof config.retryStrategy === "function")) return [
+                        3,
+                        2
+                    ];
+                    return [
+                        4,
+                        config.retryStrategy()
+                    ];
+                case 1:
+                    retryStrategy = _state.sent();
+                    if (typeof retryStrategy.acquireInitialRetryToken === "function") {
+                        if ((_retryStrategy_constructor = retryStrategy.constructor) === null || _retryStrategy_constructor === void 0 ? void 0 : (_retryStrategy_constructor_name = _retryStrategy_constructor.name) === null || _retryStrategy_constructor_name === void 0 ? void 0 : _retryStrategy_constructor_name.includes("Adaptive")) {
+                            setFeature(context, "RETRY_MODE_ADAPTIVE", "F");
+                        } else {
+                            setFeature(context, "RETRY_MODE_STANDARD", "E");
+                        }
+                    } else {
+                        setFeature(context, "RETRY_MODE_LEGACY", "D");
+                    }
+                    _state.label = 2;
+                case 2:
+                    if (!(typeof config.accountIdEndpointMode === "function")) return [
+                        3,
+                        4
+                    ];
+                    endpointV2 = context.endpointV2;
+                    if (String(endpointV2 === null || endpointV2 === void 0 ? void 0 : (_endpointV2_url = endpointV2.url) === null || _endpointV2_url === void 0 ? void 0 : _endpointV2_url.hostname).match(ACCOUNT_ID_ENDPOINT_REGEX)) {
+                        setFeature(context, "ACCOUNT_ID_ENDPOINT", "O");
+                    }
+                    return [
+                        4,
+                        (_config_accountIdEndpointMode = config.accountIdEndpointMode) === null || _config_accountIdEndpointMode === void 0 ? void 0 : _config_accountIdEndpointMode.call(config)
+                    ];
+                case 3:
+                    switch(_state.sent()){
+                        case "disabled":
+                            setFeature(context, "ACCOUNT_ID_MODE_DISABLED", "Q");
+                            break;
+                        case "preferred":
+                            setFeature(context, "ACCOUNT_ID_MODE_PREFERRED", "P");
+                            break;
+                        case "required":
+                            setFeature(context, "ACCOUNT_ID_MODE_REQUIRED", "R");
+                            break;
+                    }
+                    _state.label = 4;
+                case 4:
+                    identity = (_context___smithy_context = context.__smithy_context) === null || _context___smithy_context === void 0 ? void 0 : (_context___smithy_context_selectedHttpAuthScheme = _context___smithy_context.selectedHttpAuthScheme) === null || _context___smithy_context_selectedHttpAuthScheme === void 0 ? void 0 : _context___smithy_context_selectedHttpAuthScheme.identity;
+                    if (identity === null || identity === void 0 ? void 0 : identity.$source) {
+                        credentials = identity;
+                        if (credentials.accountId) {
+                            setFeature(context, "RESOLVED_ACCOUNT_ID", "T");
+                        }
+                        _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                        try {
+                            for(_iterator = Object.entries((_credentials_$source = credentials.$source) !== null && _credentials_$source !== void 0 ? _credentials_$source : {})[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                                _step_value = _sliced_to_array$2(_step.value, 2), key = _step_value[0], value = _step_value[1];
+                                setFeature(context, key, value);
+                            }
+                        } catch (err) {
+                            _didIteratorError = true;
+                            _iteratorError = err;
+                        } finally{
+                            try {
+                                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                    _iterator.return();
+                                }
+                            } finally{
+                                if (_didIteratorError) {
+                                    throw _iteratorError;
+                                }
+                            }
+                        }
+                    }
+                    return [
+                        2
+                    ];
+            }
+        });
+    });
+    return _checkFeatures.apply(this, arguments);
+}
+
+var USER_AGENT = "user-agent";
+var X_AMZ_USER_AGENT = "x-amz-user-agent";
+var SPACE = " ";
+var UA_NAME_SEPARATOR = "/";
+var UA_NAME_ESCAPE_REGEX = /[^!$%&'*+\-.^_`|~\w]/g;
+var UA_VALUE_ESCAPE_REGEX = /[^!$%&'*+\-.^_`|~\w#]/g;
+var UA_ESCAPE_CHAR = "-";
+
+var BYTE_LIMIT = 1024;
+function encodeFeatures(features) {
+    var buffer = "";
+    for(var key in features){
+        var val = features[key];
+        if (buffer.length + val.length + 1 <= BYTE_LIMIT) {
+            if (buffer.length) {
+                buffer += "," + val;
+            } else {
+                buffer += val;
+            }
+            continue;
+        }
+        break;
+    }
+    return buffer;
+}
+
+function _array_like_to_array$4(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes$2(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array$4(arr);
+}
+function asyncGeneratorStep$8(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator$8(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$8(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$8(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _define_property$3(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _iterable_to_array$2(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread$2() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _object_spread$2(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property$3(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys$1(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props$1(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys$1(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+function _to_consumable_array$2(arr) {
+    return _array_without_holes$2(arr) || _iterable_to_array$2(arr) || _unsupported_iterable_to_array$4(arr) || _non_iterable_spread$2();
+}
+function _unsupported_iterable_to_array$4(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array$4(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$4(o, minLen);
+}
+function _ts_generator$8(thisArg, body) {
+    var f, y, t, g, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    };
+    return g = {
+        next: verb(0),
+        "throw": verb(1),
+        "return": verb(2)
+    }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(_)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+var userAgentMiddleware = function(options) {
+    return function(next, context) {
+        return function() {
+            var _ref = _async_to_generator$8(function(args) {
+                var _context_userAgent, _context___smithy_context, _awsContext___aws_sdk_context, _options_customUserAgent, request, headers, userAgent, defaultUserAgent, awsContext, customUserAgent, appId, prefix, sdkUserAgentValue, normalUAValue;
+                return _ts_generator$8(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            request = args.request;
+                            if (!HttpRequest.isInstance(request)) {
+                                return [
+                                    2,
+                                    next(args)
+                                ];
+                            }
+                            headers = request.headers;
+                            userAgent = (context === null || context === void 0 ? void 0 : (_context_userAgent = context.userAgent) === null || _context_userAgent === void 0 ? void 0 : _context_userAgent.map(escapeUserAgent)) || [];
+                            return [
+                                4,
+                                options.defaultUserAgentProvider()
+                            ];
+                        case 1:
+                            defaultUserAgent = _state.sent().map(escapeUserAgent);
+                            return [
+                                4,
+                                checkFeatures(context, options, args)
+                            ];
+                        case 2:
+                            _state.sent();
+                            awsContext = context;
+                            defaultUserAgent.push("m/".concat(encodeFeatures(Object.assign({}, (_context___smithy_context = context.__smithy_context) === null || _context___smithy_context === void 0 ? void 0 : _context___smithy_context.features, (_awsContext___aws_sdk_context = awsContext.__aws_sdk_context) === null || _awsContext___aws_sdk_context === void 0 ? void 0 : _awsContext___aws_sdk_context.features))));
+                            customUserAgent = (options === null || options === void 0 ? void 0 : (_options_customUserAgent = options.customUserAgent) === null || _options_customUserAgent === void 0 ? void 0 : _options_customUserAgent.map(escapeUserAgent)) || [];
+                            return [
+                                4,
+                                options.userAgentAppId()
+                            ];
+                        case 3:
+                            appId = _state.sent();
+                            if (appId) {
+                                defaultUserAgent.push(escapeUserAgent([
+                                    "app",
+                                    "".concat(appId)
+                                ]));
+                            }
+                            prefix = getUserAgentPrefix();
+                            sdkUserAgentValue = (prefix ? [
+                                prefix
+                            ] : []).concat(_to_consumable_array$2(defaultUserAgent).concat(_to_consumable_array$2(userAgent), _to_consumable_array$2(customUserAgent))).join(SPACE);
+                            normalUAValue = _to_consumable_array$2(defaultUserAgent.filter(function(section) {
+                                return section.startsWith("aws-sdk-");
+                            })).concat(_to_consumable_array$2(customUserAgent)).join(SPACE);
+                            if (options.runtime !== "browser") {
+                                if (normalUAValue) {
+                                    headers[X_AMZ_USER_AGENT] = headers[X_AMZ_USER_AGENT] ? "".concat(headers[USER_AGENT], " ").concat(normalUAValue) : normalUAValue;
+                                }
+                                headers[USER_AGENT] = sdkUserAgentValue;
+                            } else {
+                                headers[X_AMZ_USER_AGENT] = sdkUserAgentValue;
+                            }
+                            return [
+                                2,
+                                next(_object_spread_props$1(_object_spread$2({}, args), {
+                                    request: request
+                                }))
+                            ];
+                    }
+                });
+            });
+            return function(args) {
+                return _ref.apply(this, arguments);
+            };
+        }();
+    };
+};
+var escapeUserAgent = function(userAgentPair) {
+    var _userAgentPair_;
+    var name = userAgentPair[0].split(UA_NAME_SEPARATOR).map(function(part) {
+        return part.replace(UA_NAME_ESCAPE_REGEX, UA_ESCAPE_CHAR);
+    }).join(UA_NAME_SEPARATOR);
+    var version = (_userAgentPair_ = userAgentPair[1]) === null || _userAgentPair_ === void 0 ? void 0 : _userAgentPair_.replace(UA_VALUE_ESCAPE_REGEX, UA_ESCAPE_CHAR);
+    var prefixSeparatorIndex = name.indexOf(UA_NAME_SEPARATOR);
+    var prefix = name.substring(0, prefixSeparatorIndex);
+    var uaName = name.substring(prefixSeparatorIndex + 1);
+    if (prefix === "api") {
+        uaName = uaName.toLowerCase();
+    }
+    return [
+        prefix,
+        uaName,
+        version
+    ].filter(function(item) {
+        return item && item.length > 0;
+    }).reduce(function(acc, item, index) {
+        switch(index){
+            case 0:
+                return item;
+            case 1:
+                return "".concat(acc, "/").concat(item);
+            default:
+                return "".concat(acc, "#").concat(item);
+        }
+    }, "");
+};
+var getUserAgentMiddlewareOptions = {
+    name: "getUserAgentMiddleware",
+    step: "build",
+    priority: "low",
+    tags: [
+        "SET_USER_AGENT",
+        "USER_AGENT"
+    ],
+    override: true
+};
+var getUserAgentPlugin = function(config) {
+    return {
+        applyToStack: function(clientStack) {
+            clientStack.add(userAgentMiddleware(config), getUserAgentMiddlewareOptions);
+        }
+    };
+};
+
+function asyncGeneratorStep$7(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator$7(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$7(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$7(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _define_property$2(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _object_spread$1(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property$2(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+function _ts_generator$7(thisArg, body) {
+    var f, y, t, g, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    };
+    return g = {
+        next: verb(0),
+        "throw": verb(1),
+        "return": verb(2)
+    }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(_)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+var CONTENT_LENGTH_HEADER = "content-length";
+function contentLengthMiddleware(bodyLengthChecker) {
+    return function(next) {
+        return function() {
+            var _ref = _async_to_generator$7(function(args) {
+                var request, body, headers, length;
+                return _ts_generator$7(this, function(_state) {
+                    request = args.request;
+                    if (HttpRequest.isInstance(request)) {
+                        body = request.body, headers = request.headers;
+                        if (body && Object.keys(headers).map(function(str) {
+                            return str.toLowerCase();
+                        }).indexOf(CONTENT_LENGTH_HEADER) === -1) {
+                            try {
+                                length = bodyLengthChecker(body);
+                                request.headers = _object_spread_props(_object_spread$1({}, request.headers), _define_property$2({}, CONTENT_LENGTH_HEADER, String(length)));
+                            } catch (error) {}
+                        }
+                    }
+                    return [
+                        2,
+                        next(_object_spread_props(_object_spread$1({}, args), {
+                            request: request
+                        }))
+                    ];
+                });
+            });
+            return function(args) {
+                return _ref.apply(this, arguments);
+            };
+        }();
+    };
+}
+var contentLengthMiddlewareOptions = {
+    step: "build",
+    tags: [
+        "SET_CONTENT_LENGTH",
+        "CONTENT_LENGTH"
+    ],
+    name: "contentLengthMiddleware",
+    override: true
+};
+var getContentLengthPlugin = function(options) {
+    return {
+        applyToStack: function(clientStack) {
+            clientStack.add(contentLengthMiddleware(options.bodyLengthChecker), contentLengthMiddlewareOptions);
+        }
+    };
+};
+
+function _array_like_to_array$3(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes$1(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function asyncGeneratorStep$6(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator$6(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$6(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$6(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _iterable_to_array_limit$1(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest$1() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _sliced_to_array$1(arr, i) {
+    return _array_with_holes$1(arr) || _iterable_to_array_limit$1(arr, i) || _unsupported_iterable_to_array$3(arr, i) || _non_iterable_rest$1();
+}
+function _unsupported_iterable_to_array$3(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array$3(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$3(o, minLen);
+}
+function _ts_generator$6(thisArg, body) {
+    var f, y, t, g, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    };
+    return g = {
+        next: verb(0),
+        "throw": verb(1),
+        "return": verb(2)
+    }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(_)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+var resolveParamsForS3 = function() {
+    var _ref = _async_to_generator$6(function(endpointParams) {
+        var bucket;
+        return _ts_generator$6(this, function(_state) {
+            bucket = (endpointParams === null || endpointParams === void 0 ? void 0 : endpointParams.Bucket) || "";
+            if (typeof endpointParams.Bucket === "string") {
+                endpointParams.Bucket = bucket.replace(/#/g, encodeURIComponent("#")).replace(/\?/g, encodeURIComponent("?"));
+            }
+            if (isArnBucketName(bucket)) {
+                if (endpointParams.ForcePathStyle === true) {
+                    throw new Error("Path-style addressing cannot be used with ARN buckets");
+                }
+            } else if (!isDnsCompatibleBucketName(bucket) || bucket.indexOf(".") !== -1 && !String(endpointParams.Endpoint).startsWith("http:") || bucket.toLowerCase() !== bucket || bucket.length < 3) {
+                endpointParams.ForcePathStyle = true;
+            }
+            if (endpointParams.DisableMultiRegionAccessPoints) {
+                endpointParams.disableMultiRegionAccessPoints = true;
+                endpointParams.DisableMRAP = true;
+            }
+            return [
+                2,
+                endpointParams
+            ];
+        });
+    });
+    return function resolveParamsForS3(endpointParams) {
+        return _ref.apply(this, arguments);
+    };
+}();
+var DOMAIN_PATTERN = /^[a-z0-9][a-z0-9\.\-]{1,61}[a-z0-9]$/;
+var IP_ADDRESS_PATTERN = /(\d+\.){3}\d+/;
+var DOTS_PATTERN = /\.\./;
+var isDnsCompatibleBucketName = function(bucketName) {
+    return DOMAIN_PATTERN.test(bucketName) && !IP_ADDRESS_PATTERN.test(bucketName) && !DOTS_PATTERN.test(bucketName);
+};
+var isArnBucketName = function(bucketName) {
+    var _bucketName_split = _sliced_to_array$1(bucketName.split(":"), 6), arn = _bucketName_split[0], partition = _bucketName_split[1], service = _bucketName_split[2], bucket = _bucketName_split[5];
+    var isArn = arn === "arn" && bucketName.split(":").length >= 6;
+    var isValidArn = Boolean(isArn && partition && service && bucket);
+    if (isArn && !isValidArn) {
+        throw new Error("Invalid ARN: ".concat(bucketName, " was an invalid ARN."));
+    }
+    return isValidArn;
+};
+
+function asyncGeneratorStep$5(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator$5(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$5(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$5(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _type_of$1(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _ts_generator$5(thisArg, body) {
+    var f, y, t, g, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    };
+    return g = {
+        next: verb(0),
+        "throw": verb(1),
+        "return": verb(2)
+    }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(_)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+var createConfigValueProvider = function(configKey, canonicalEndpointParamKey, config) {
+    var isClientContextParam = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : false;
+    var configProvider = function() {
+        var _ref = _async_to_generator$5(function() {
+            var configValue, clientContextParams, nestedValue, _ref, _config_configKey;
+            return _ts_generator$5(this, function(_state) {
+                if (isClientContextParam) {
+                    clientContextParams = config.clientContextParams;
+                    nestedValue = clientContextParams === null || clientContextParams === void 0 ? void 0 : clientContextParams[configKey];
+                    configValue = (_ref = nestedValue !== null && nestedValue !== void 0 ? nestedValue : config[configKey]) !== null && _ref !== void 0 ? _ref : config[canonicalEndpointParamKey];
+                } else {
+                    configValue = (_config_configKey = config[configKey]) !== null && _config_configKey !== void 0 ? _config_configKey : config[canonicalEndpointParamKey];
+                }
+                if (typeof configValue === "function") {
+                    return [
+                        2,
+                        configValue()
+                    ];
+                }
+                return [
+                    2,
+                    configValue
+                ];
+            });
+        });
+        return function configProvider() {
+            return _ref.apply(this, arguments);
+        };
+    }();
+    if (configKey === "credentialScope" || canonicalEndpointParamKey === "CredentialScope") {
+        return /*#__PURE__*/ _async_to_generator$5(function() {
+            var credentials, _tmp, _credentials_credentialScope, configValue;
+            return _ts_generator$5(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        if (!(typeof config.credentials === "function")) return [
+                            3,
+                            2
+                        ];
+                        return [
+                            4,
+                            config.credentials()
+                        ];
+                    case 1:
+                        _tmp = _state.sent();
+                        return [
+                            3,
+                            3
+                        ];
+                    case 2:
+                        _tmp = config.credentials;
+                        _state.label = 3;
+                    case 3:
+                        credentials = _tmp;
+                        configValue = (_credentials_credentialScope = credentials === null || credentials === void 0 ? void 0 : credentials.credentialScope) !== null && _credentials_credentialScope !== void 0 ? _credentials_credentialScope : credentials === null || credentials === void 0 ? void 0 : credentials.CredentialScope;
+                        return [
+                            2,
+                            configValue
+                        ];
+                }
+            });
+        });
+    }
+    if (configKey === "accountId" || canonicalEndpointParamKey === "AccountId") {
+        return /*#__PURE__*/ _async_to_generator$5(function() {
+            var credentials, _tmp, _credentials_accountId, configValue;
+            return _ts_generator$5(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        if (!(typeof config.credentials === "function")) return [
+                            3,
+                            2
+                        ];
+                        return [
+                            4,
+                            config.credentials()
+                        ];
+                    case 1:
+                        _tmp = _state.sent();
+                        return [
+                            3,
+                            3
+                        ];
+                    case 2:
+                        _tmp = config.credentials;
+                        _state.label = 3;
+                    case 3:
+                        credentials = _tmp;
+                        configValue = (_credentials_accountId = credentials === null || credentials === void 0 ? void 0 : credentials.accountId) !== null && _credentials_accountId !== void 0 ? _credentials_accountId : credentials === null || credentials === void 0 ? void 0 : credentials.AccountId;
+                        return [
+                            2,
+                            configValue
+                        ];
+                }
+            });
+        });
+    }
+    if (configKey === "endpoint" || canonicalEndpointParamKey === "endpoint") {
+        return /*#__PURE__*/ _async_to_generator$5(function() {
+            var endpoint, protocol, hostname, port, path;
+            return _ts_generator$5(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        if (config.isCustomEndpoint === false) {
+                            return [
+                                2,
+                                undefined
+                            ];
+                        }
+                        return [
+                            4,
+                            configProvider()
+                        ];
+                    case 1:
+                        endpoint = _state.sent();
+                        if (endpoint && (typeof endpoint === "undefined" ? "undefined" : _type_of$1(endpoint)) === "object") {
+                            if ("url" in endpoint) {
+                                return [
+                                    2,
+                                    endpoint.url.href
+                                ];
+                            }
+                            if ("hostname" in endpoint) {
+                                protocol = endpoint.protocol, hostname = endpoint.hostname, port = endpoint.port, path = endpoint.path;
+                                return [
+                                    2,
+                                    "".concat(protocol, "//").concat(hostname).concat(port ? ":" + port : "").concat(path)
+                                ];
+                            }
+                        }
+                        return [
+                            2,
+                            endpoint
+                        ];
+                }
+            });
+        });
+    }
+    return configProvider;
+};
+
+function _array_like_to_array$2(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes$1(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array$2(arr);
+}
+function _iterable_to_array$1(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread$1() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _to_consumable_array$1(arr) {
+    return _array_without_holes$1(arr) || _iterable_to_array$1(arr) || _unsupported_iterable_to_array$2(arr) || _non_iterable_spread$1();
+}
+function _unsupported_iterable_to_array$2(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array$2(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$2(o, minLen);
+}
+var ENV_ENDPOINT_URL = "AWS_ENDPOINT_URL";
+var CONFIG_ENDPOINT_URL = "endpoint_url";
+var getEndpointUrlConfig = function(serviceId) {
+    return {
+        environmentVariableSelector: function(env) {
+            var serviceSuffixParts = serviceId.split(" ").map(function(w) {
+                return w.toUpperCase();
+            });
+            var serviceEndpointUrl = env[[
+                ENV_ENDPOINT_URL
+            ].concat(_to_consumable_array$1(serviceSuffixParts)).join("_")];
+            if (serviceEndpointUrl) return serviceEndpointUrl;
+            var endpointUrl = env[ENV_ENDPOINT_URL];
+            if (endpointUrl) return endpointUrl;
+            return undefined;
+        },
+        configFileSelector: function(profile, config) {
+            if (config && profile.services) {
+                var servicesSection = config[[
+                    "services",
+                    profile.services
+                ].join(CONFIG_PREFIX_SEPARATOR)];
+                if (servicesSection) {
+                    var servicePrefixParts = serviceId.split(" ").map(function(w) {
+                        return w.toLowerCase();
+                    });
+                    var endpointUrl = servicesSection[[
+                        servicePrefixParts.join("_"),
+                        CONFIG_ENDPOINT_URL
+                    ].join(CONFIG_PREFIX_SEPARATOR)];
+                    if (endpointUrl) return endpointUrl;
+                }
+            }
+            var endpointUrl1 = profile[CONFIG_ENDPOINT_URL];
+            if (endpointUrl1) return endpointUrl1;
+            return undefined;
+        },
+        default: undefined
+    };
+};
+
+function asyncGeneratorStep$4(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator$4(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$4(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$4(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _ts_generator$4(thisArg, body) {
+    var f, y, t, g, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    };
+    return g = {
+        next: verb(0),
+        "throw": verb(1),
+        "return": verb(2)
+    }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(_)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+var getEndpointFromConfig = function() {
+    var _ref = _async_to_generator$4(function(serviceId) {
+        return _ts_generator$4(this, function(_state) {
+            return [
+                2,
+                loadConfig(getEndpointUrlConfig(serviceId !== null && serviceId !== void 0 ? serviceId : ""))()
+            ];
+        });
+    });
+    return function getEndpointFromConfig(serviceId) {
+        return _ref.apply(this, arguments);
+    };
+}();
+
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+var toEndpointV1 = function(endpoint) {
+    if ((typeof endpoint === "undefined" ? "undefined" : _type_of(endpoint)) === "object") {
+        if ("url" in endpoint) {
+            return parseUrl(endpoint.url);
+        }
+        return endpoint;
+    }
+    return parseUrl(endpoint);
+};
+
+function _array_like_to_array$1(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function asyncGeneratorStep$3(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator$3(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$3(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$3(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array$1(arr, i) || _non_iterable_rest();
+}
+function _unsupported_iterable_to_array$1(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array$1(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$1(o, minLen);
+}
+function _ts_generator$3(thisArg, body) {
+    var f, y, t, g, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    };
+    return g = {
+        next: verb(0),
+        "throw": verb(1),
+        "return": verb(2)
+    }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(_)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+var getEndpointFromInstructions = function() {
+    var _ref = _async_to_generator$3(function(commandInput, instructionsSupplier, clientConfig, context) {
+        var endpointFromConfig, endpointParams, endpoint;
+        return _ts_generator$3(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    if (!!clientConfig.isCustomEndpoint) return [
+                        3,
+                        5
+                    ];
+                    if (!clientConfig.serviceConfiguredEndpoint) return [
+                        3,
+                        2
+                    ];
+                    return [
+                        4,
+                        clientConfig.serviceConfiguredEndpoint()
+                    ];
+                case 1:
+                    endpointFromConfig = _state.sent();
+                    return [
+                        3,
+                        4
+                    ];
+                case 2:
+                    return [
+                        4,
+                        getEndpointFromConfig(clientConfig.serviceId)
+                    ];
+                case 3:
+                    endpointFromConfig = _state.sent();
+                    _state.label = 4;
+                case 4:
+                    if (endpointFromConfig) {
+                        clientConfig.endpoint = function() {
+                            return Promise.resolve(toEndpointV1(endpointFromConfig));
+                        };
+                        clientConfig.isCustomEndpoint = true;
+                    }
+                    _state.label = 5;
+                case 5:
+                    return [
+                        4,
+                        resolveParams(commandInput, instructionsSupplier, clientConfig)
+                    ];
+                case 6:
+                    endpointParams = _state.sent();
+                    if (typeof clientConfig.endpointProvider !== "function") {
+                        throw new Error("config.endpointProvider is not set.");
+                    }
+                    endpoint = clientConfig.endpointProvider(endpointParams, context);
+                    return [
+                        2,
+                        endpoint
+                    ];
+            }
+        });
+    });
+    return function getEndpointFromInstructions(commandInput, instructionsSupplier, clientConfig, context) {
+        return _ref.apply(this, arguments);
+    };
+}();
+var resolveParams = function() {
+    var _ref = _async_to_generator$3(function(commandInput, instructionsSupplier, clientConfig) {
+        var _instructionsSupplier_getEndpointParameterInstructions, endpointParams, instructions, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _step_value, name, instruction, _, err;
+        return _ts_generator$3(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    endpointParams = {};
+                    instructions = (instructionsSupplier === null || instructionsSupplier === void 0 ? void 0 : (_instructionsSupplier_getEndpointParameterInstructions = instructionsSupplier.getEndpointParameterInstructions) === null || _instructionsSupplier_getEndpointParameterInstructions === void 0 ? void 0 : _instructionsSupplier_getEndpointParameterInstructions.call(instructionsSupplier)) || {};
+                    _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                    _state.label = 1;
+                case 1:
+                    _state.trys.push([
+                        1,
+                        11,
+                        12,
+                        13
+                    ]);
+                    _iterator = Object.entries(instructions)[Symbol.iterator]();
+                    _state.label = 2;
+                case 2:
+                    if (!!(_iteratorNormalCompletion = (_step = _iterator.next()).done)) return [
+                        3,
+                        10
+                    ];
+                    _step_value = _sliced_to_array(_step.value, 2), name = _step_value[0], instruction = _step_value[1];
+                    _ = instruction.type;
+                    switch(_){
+                        case "staticContextParams":
+                            return [
+                                3,
+                                3
+                            ];
+                        case "contextParams":
+                            return [
+                                3,
+                                4
+                            ];
+                        case "clientContextParams":
+                            return [
+                                3,
+                                5
+                            ];
+                        case "builtInParams":
+                            return [
+                                3,
+                                5
+                            ];
+                        case "operationContextParams":
+                            return [
+                                3,
+                                7
+                            ];
+                    }
+                    return [
+                        3,
+                        8
+                    ];
+                case 3:
+                    endpointParams[name] = instruction.value;
+                    return [
+                        3,
+                        9
+                    ];
+                case 4:
+                    endpointParams[name] = commandInput[instruction.name];
+                    return [
+                        3,
+                        9
+                    ];
+                case 5:
+                    return [
+                        4,
+                        createConfigValueProvider(instruction.name, name, clientConfig, instruction.type !== "builtInParams")()
+                    ];
+                case 6:
+                    endpointParams[name] = _state.sent();
+                    return [
+                        3,
+                        9
+                    ];
+                case 7:
+                    endpointParams[name] = instruction.get(commandInput);
+                    return [
+                        3,
+                        9
+                    ];
+                case 8:
+                    throw new Error("Unrecognized endpoint parameter instruction: " + JSON.stringify(instruction));
+                case 9:
+                    _iteratorNormalCompletion = true;
+                    return [
+                        3,
+                        2
+                    ];
+                case 10:
+                    return [
+                        3,
+                        13
+                    ];
+                case 11:
+                    err = _state.sent();
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                    return [
+                        3,
+                        13
+                    ];
+                case 12:
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                    return [
+                        7
+                    ];
+                case 13:
+                    if (Object.keys(instructions).length === 0) {
+                        Object.assign(endpointParams, clientConfig);
+                    }
+                    if (!(String(clientConfig.serviceId).toLowerCase() === "s3")) return [
+                        3,
+                        15
+                    ];
+                    return [
+                        4,
+                        resolveParamsForS3(endpointParams)
+                    ];
+                case 14:
+                    _state.sent();
+                    _state.label = 15;
+                case 15:
+                    return [
+                        2,
+                        endpointParams
+                    ];
+            }
+        });
+    });
+    return function resolveParams(commandInput, instructionsSupplier, clientConfig) {
+        return _ref.apply(this, arguments);
+    };
+}();
+
+function asyncGeneratorStep$2(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator$2(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$2(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$2(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _define_property$1(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property$1(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function _ts_generator$2(thisArg, body) {
+    var f, y, t, g, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    };
+    return g = {
+        next: verb(0),
+        "throw": verb(1),
+        "return": verb(2)
+    }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(_)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+var endpointMiddleware = function(param) {
+    var config = param.config, instructions = param.instructions;
+    return function(next, context) {
+        return function() {
+            var _ref = _async_to_generator$2(function(args) {
+                var _endpoint_properties, _context_authSchemes, endpoint, authScheme, _smithyContext_selectedHttpAuthScheme, smithyContext, httpAuthOption;
+                return _ts_generator$2(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            if (config.isCustomEndpoint) {
+                                setFeature$1(context, "ENDPOINT_OVERRIDE", "N");
+                            }
+                            return [
+                                4,
+                                getEndpointFromInstructions(args.input, {
+                                    getEndpointParameterInstructions: function getEndpointParameterInstructions() {
+                                        return instructions;
+                                    }
+                                }, _object_spread({}, config), context)
+                            ];
+                        case 1:
+                            endpoint = _state.sent();
+                            context.endpointV2 = endpoint;
+                            context.authSchemes = (_endpoint_properties = endpoint.properties) === null || _endpoint_properties === void 0 ? void 0 : _endpoint_properties.authSchemes;
+                            authScheme = (_context_authSchemes = context.authSchemes) === null || _context_authSchemes === void 0 ? void 0 : _context_authSchemes[0];
+                            if (authScheme) {
+                                context["signing_region"] = authScheme.signingRegion;
+                                context["signing_service"] = authScheme.signingName;
+                                smithyContext = getSmithyContext(context);
+                                httpAuthOption = smithyContext === null || smithyContext === void 0 ? void 0 : (_smithyContext_selectedHttpAuthScheme = smithyContext.selectedHttpAuthScheme) === null || _smithyContext_selectedHttpAuthScheme === void 0 ? void 0 : _smithyContext_selectedHttpAuthScheme.httpAuthOption;
+                                if (httpAuthOption) {
+                                    httpAuthOption.signingProperties = Object.assign(httpAuthOption.signingProperties || {}, {
+                                        signing_region: authScheme.signingRegion,
+                                        signingRegion: authScheme.signingRegion,
+                                        signing_service: authScheme.signingName,
+                                        signingName: authScheme.signingName,
+                                        signingRegionSet: authScheme.signingRegionSet
+                                    }, authScheme.properties);
+                                }
+                            }
+                            return [
+                                2,
+                                next(_object_spread({}, args))
+                            ];
+                    }
+                });
+            });
+            return function(args) {
+                return _ref.apply(this, arguments);
+            };
+        }();
+    };
+};
+
+var serializerMiddlewareOption = {
+    name: "serializerMiddleware"};
+
+var endpointMiddlewareOptions = {
+    step: "serialize",
+    tags: [
+        "ENDPOINT_PARAMETERS",
+        "ENDPOINT_V2",
+        "ENDPOINT"
+    ],
+    name: "endpointV2Middleware",
+    override: true,
+    relation: "before",
+    toMiddleware: serializerMiddlewareOption.name
+};
+var getEndpointPlugin = function(config, instructions) {
+    return {
+        applyToStack: function(clientStack) {
+            clientStack.addRelativeTo(endpointMiddleware({
+                config: config,
+                instructions: instructions
+            }), endpointMiddlewareOptions);
+        }
+    };
+};
+
+function asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator$1(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _ts_generator$1(thisArg, body) {
+    var f, y, t, g, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    };
+    return g = {
+        next: verb(0),
+        "throw": verb(1),
+        "return": verb(2)
+    }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(_)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+var resolveEndpointConfig = function(input) {
+    var _input_tls;
+    var tls = (_input_tls = input.tls) !== null && _input_tls !== void 0 ? _input_tls : true;
+    var endpoint = input.endpoint, useDualstackEndpoint = input.useDualstackEndpoint, useFipsEndpoint = input.useFipsEndpoint;
+    var customEndpointProvider = endpoint != null ? /*#__PURE__*/ _async_to_generator$1(function() {
+        return _ts_generator$1(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    return [
+                        4,
+                        normalizeProvider$1(endpoint)()
+                    ];
+                case 1:
+                    return [
+                        2,
+                        toEndpointV1.apply(void 0, [
+                            _state.sent()
+                        ])
+                    ];
+            }
+        });
+    }) : undefined;
+    var isCustomEndpoint = !!endpoint;
+    var resolvedConfig = Object.assign(input, {
+        endpoint: customEndpointProvider,
+        tls: tls,
+        isCustomEndpoint: isCustomEndpoint,
+        useDualstackEndpoint: normalizeProvider$1(useDualstackEndpoint !== null && useDualstackEndpoint !== void 0 ? useDualstackEndpoint : false),
+        useFipsEndpoint: normalizeProvider$1(useFipsEndpoint !== null && useFipsEndpoint !== void 0 ? useFipsEndpoint : false)
+    });
+    var configuredEndpointPromise = undefined;
+    resolvedConfig.serviceConfiguredEndpoint = /*#__PURE__*/ _async_to_generator$1(function() {
+        return _ts_generator$1(this, function(_state) {
+            if (input.serviceId && !configuredEndpointPromise) {
+                configuredEndpointPromise = getEndpointFromConfig(input.serviceId);
+            }
+            return [
+                2,
+                configuredEndpointPromise
+            ];
+        });
+    });
+    return resolvedConfig;
+};
+
+var version = "3.993.0";
+var packageInfo = {
+    version: version};
+
+var getRuntimeUserAgentPair = function() {
+    var runtimesToCheck = [
+        "deno",
+        "bun",
+        "llrt"
+    ];
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = runtimesToCheck[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var runtime = _step.value;
+            if (versions[runtime]) {
+                return [
+                    "md/".concat(runtime),
+                    versions[runtime]
+                ];
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    return [
+        "md/nodejs",
+        versions.node
+    ];
+};
+
+var isCrtAvailable = function() {
+    return null;
+};
+
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, g, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    };
+    return g = {
+        next: verb(0),
+        "throw": verb(1),
+        "return": verb(2)
+    }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(_)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+var createDefaultUserAgentProvider = function(param) {
+    var serviceId = param.serviceId, clientVersion = param.clientVersion;
+    var runtimeUserAgentPair = getRuntimeUserAgentPair();
+    return function() {
+        var _ref = _async_to_generator(function(config) {
+            var _config_userAgentAppId, sections, crtAvailable, appId, resolvedUserAgent;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        sections = [
+                            [
+                                "aws-sdk-js",
+                                clientVersion
+                            ],
+                            [
+                                "ua",
+                                "2.1"
+                            ],
+                            [
+                                "os/".concat(platform()),
+                                release()
+                            ],
+                            [
+                                "lang/js"
+                            ],
+                            runtimeUserAgentPair
+                        ];
+                        crtAvailable = isCrtAvailable();
+                        if (crtAvailable) {
+                            sections.push(crtAvailable);
+                        }
+                        if (serviceId) {
+                            sections.push([
+                                "api/".concat(serviceId),
+                                clientVersion
+                            ]);
+                        }
+                        if (env.AWS_EXECUTION_ENV) {
+                            sections.push([
+                                "exec-env/".concat(env.AWS_EXECUTION_ENV)
+                            ]);
+                        }
+                        return [
+                            4,
+                            config === null || config === void 0 ? void 0 : (_config_userAgentAppId = config.userAgentAppId) === null || _config_userAgentAppId === void 0 ? void 0 : _config_userAgentAppId.call(config)
+                        ];
+                    case 1:
+                        appId = _state.sent();
+                        resolvedUserAgent = appId ? _to_consumable_array(sections).concat([
+                            [
+                                "app/".concat(appId)
+                            ]
+                        ]) : _to_consumable_array(sections);
+                        return [
+                            2,
+                            resolvedUserAgent
+                        ];
+                }
+            });
+        });
+        return function(config) {
+            return _ref.apply(this, arguments);
+        };
+    }();
+};
+
+var UA_APP_ID_ENV_NAME = "AWS_SDK_UA_APP_ID";
+var UA_APP_ID_INI_NAME = "sdk_ua_app_id";
+var UA_APP_ID_INI_NAME_DEPRECATED = "sdk-ua-app-id";
+var NODE_APP_ID_CONFIG_OPTIONS = {
+    environmentVariableSelector: function(env) {
+        return env[UA_APP_ID_ENV_NAME];
+    },
+    configFileSelector: function(profile) {
+        var _profile_UA_APP_ID_INI_NAME;
+        return (_profile_UA_APP_ID_INI_NAME = profile[UA_APP_ID_INI_NAME]) !== null && _profile_UA_APP_ID_INI_NAME !== void 0 ? _profile_UA_APP_ID_INI_NAME : profile[UA_APP_ID_INI_NAME_DEPRECATED];
+    },
+    default: DEFAULT_UA_APP_ID
+};
+
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    return Constructor;
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+var Hash = /*#__PURE__*/ function() {
+    function Hash(algorithmIdentifier, secret) {
+        _class_call_check(this, Hash);
+        _define_property(this, "algorithmIdentifier", void 0);
+        _define_property(this, "secret", void 0);
+        _define_property(this, "hash", void 0);
+        this.algorithmIdentifier = algorithmIdentifier;
+        this.secret = secret;
+        this.reset();
+    }
+    _create_class(Hash, [
+        {
+            key: "update",
+            value: function update(toHash, encoding) {
+                this.hash.update(toUint8Array(castSourceData(toHash, encoding)));
+            }
+        },
+        {
+            key: "digest",
+            value: function digest() {
+                return Promise.resolve(this.hash.digest());
+            }
+        },
+        {
+            key: "reset",
+            value: function reset() {
+                this.hash = this.secret ? createHmac(this.algorithmIdentifier, castSourceData(this.secret)) : createHash(this.algorithmIdentifier);
+            }
+        }
+    ]);
+    return Hash;
+}();
+function castSourceData(toCast, encoding) {
+    if (Buffer.isBuffer(toCast)) {
+        return toCast;
+    }
+    if (typeof toCast === "string") {
+        return fromString(toCast, encoding);
+    }
+    if (ArrayBuffer.isView(toCast)) {
+        return fromArrayBuffer(toCast.buffer, toCast.byteOffset, toCast.byteLength);
+    }
+    return fromArrayBuffer(toCast);
+}
+
+var RETRY_MODES;
+(function(RETRY_MODES) {
+    RETRY_MODES["STANDARD"] = "standard";
+    RETRY_MODES["ADAPTIVE"] = "adaptive";
+})(RETRY_MODES || (RETRY_MODES = {}));
+var DEFAULT_RETRY_MODE = RETRY_MODES.STANDARD;
+
+var getAwsRegionExtensionConfiguration = function(runtimeConfig) {
+    return {
+        setRegion: function setRegion(region) {
+            runtimeConfig.region = region;
+        },
+        region: function region() {
+            return runtimeConfig.region;
+        }
+    };
+};
+var resolveAwsRegionExtensionConfiguration = function(awsRegionExtensionConfiguration) {
+    return {
+        region: awsRegionExtensionConfiguration.region()
+    };
+};
+
+export { DEFAULT_RETRY_MODE as D, Hash as H, NODE_APP_ID_CONFIG_OPTIONS as N, awsEndpointFunctions as a, resolveUserAgentConfig as b, createDefaultUserAgentProvider as c, resolveEndpointConfig as d, resolveHostHeaderConfig as e, getUserAgentPlugin as f, getAwsRegionExtensionConfiguration as g, getContentLengthPlugin as h, getHostHeaderPlugin as i, getLoggerPlugin as j, getRecursionDetectionPlugin as k, getEndpointPlugin as l, createAggregatedClient as m, packageInfo as p, resolveAwsRegionExtensionConfiguration as r };