index.js

#!/usr/bin/env node
"use strict";
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __esm = (fn, res) => function __init() {
  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
};
var __commonJS = (cb, mod) => function __require() {
  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __export = (target, all3) => {
  for (var name in all3)
    __defProp(target, name, { get: all3[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  // If the importer is in node compatibility mode or this is not an ESM
  // file that has been converted to a CommonJS file using a Babel-
  // compatible transform (i.e. "__esModule" has not been set), then set
  // "default" to the CommonJS "module.exports" for node compatibility.
  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
  mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// ../../node_modules/.pnpm/tslib@2.4.0/node_modules/tslib/tslib.es6.js
var tslib_es6_exports = {};
__export(tslib_es6_exports, {
  __assign: () => __assign,
  __asyncDelegator: () => __asyncDelegator,
  __asyncGenerator: () => __asyncGenerator,
  __asyncValues: () => __asyncValues,
  __await: () => __await,
  __awaiter: () => __awaiter,
  __classPrivateFieldGet: () => __classPrivateFieldGet,
  __classPrivateFieldIn: () => __classPrivateFieldIn,
  __classPrivateFieldSet: () => __classPrivateFieldSet,
  __createBinding: () => __createBinding,
  __decorate: () => __decorate,
  __exportStar: () => __exportStar,
  __extends: () => __extends,
  __generator: () => __generator,
  __importDefault: () => __importDefault,
  __importStar: () => __importStar,
  __makeTemplateObject: () => __makeTemplateObject,
  __metadata: () => __metadata,
  __param: () => __param,
  __read: () => __read,
  __rest: () => __rest,
  __spread: () => __spread,
  __spreadArray: () => __spreadArray,
  __spreadArrays: () => __spreadArrays,
  __values: () => __values
});
function __extends(d, b) {
  if (typeof b !== "function" && b !== null)
    throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
  extendStatics(d, b);
  function __() {
    this.constructor = d;
  }
  d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
}
function __rest(s, e) {
  var t = {};
  for (var p in s)
    if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
      t[p] = s[p];
  if (s != null && typeof Object.getOwnPropertySymbols === "function")
    for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
      if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
        t[p[i]] = s[p[i]];
    }
  return t;
}
function __decorate(decorators, target, key, desc) {
  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
    r = Reflect.decorate(decorators, target, key, desc);
  else
    for (var i = decorators.length - 1; i >= 0; i--)
      if (d = decorators[i])
        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
  return c > 3 && r && Object.defineProperty(target, key, r), r;
}
function __param(paramIndex, decorator) {
  return function(target, key) {
    decorator(target, key, paramIndex);
  };
}
function __metadata(metadataKey, metadataValue) {
  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
    return Reflect.metadata(metadataKey, metadataValue);
}
function __awaiter(thisArg, _arguments, P, generator) {
  function adopt(value) {
    return value instanceof P ? value : new P(function(resolve) {
      resolve(value);
    });
  }
  return new (P || (P = Promise))(function(resolve, reject) {
    function fulfilled(value) {
      try {
        step(generator.next(value));
      } catch (e) {
        reject(e);
      }
    }
    function rejected(value) {
      try {
        step(generator["throw"](value));
      } catch (e) {
        reject(e);
      }
    }
    function step(result) {
      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
    }
    step((generator = generator.apply(thisArg, _arguments || [])).next());
  });
}
function __generator(thisArg, body) {
  var _ = { label: 0, sent: function() {
    if (t[0] & 1)
      throw t[1];
    return t[1];
  }, trys: [], ops: [] }, f, y, t, g;
  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 __exportStar(m, o) {
  for (var p in m)
    if (p !== "default" && !Object.prototype.hasOwnProperty.call(o, p))
      __createBinding(o, m, p);
}
function __values(o) {
  var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
  if (m)
    return m.call(o);
  if (o && typeof o.length === "number")
    return {
      next: function() {
        if (o && i >= o.length)
          o = void 0;
        return { value: o && o[i++], done: !o };
      }
    };
  throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
}
function __read(o, n) {
  var m = typeof Symbol === "function" && o[Symbol.iterator];
  if (!m)
    return o;
  var i = m.call(o), r, ar = [], e;
  try {
    while ((n === void 0 || n-- > 0) && !(r = i.next()).done)
      ar.push(r.value);
  } catch (error) {
    e = { error };
  } finally {
    try {
      if (r && !r.done && (m = i["return"]))
        m.call(i);
    } finally {
      if (e)
        throw e.error;
    }
  }
  return ar;
}
function __spread() {
  for (var ar = [], i = 0; i < arguments.length; i++)
    ar = ar.concat(__read(arguments[i]));
  return ar;
}
function __spreadArrays() {
  for (var s = 0, i = 0, il = arguments.length; i < il; i++)
    s += arguments[i].length;
  for (var r = Array(s), k = 0, i = 0; i < il; i++)
    for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
      r[k] = a[j];
  return r;
}
function __spreadArray(to, from, pack) {
  if (pack || arguments.length === 2)
    for (var i = 0, l = from.length, ar; i < l; i++) {
      if (ar || !(i in from)) {
        if (!ar)
          ar = Array.prototype.slice.call(from, 0, i);
        ar[i] = from[i];
      }
    }
  return to.concat(ar || Array.prototype.slice.call(from));
}
function __await(v) {
  return this instanceof __await ? (this.v = v, this) : new __await(v);
}
function __asyncGenerator(thisArg, _arguments, generator) {
  if (!Symbol.asyncIterator)
    throw new TypeError("Symbol.asyncIterator is not defined.");
  var g = generator.apply(thisArg, _arguments || []), i, q = [];
  return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() {
    return this;
  }, i;
  function verb(n) {
    if (g[n])
      i[n] = function(v) {
        return new Promise(function(a, b) {
          q.push([n, v, a, b]) > 1 || resume(n, v);
        });
      };
  }
  function resume(n, v) {
    try {
      step(g[n](v));
    } catch (e) {
      settle2(q[0][3], e);
    }
  }
  function step(r) {
    r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle2(q[0][2], r);
  }
  function fulfill(value) {
    resume("next", value);
  }
  function reject(value) {
    resume("throw", value);
  }
  function settle2(f, v) {
    if (f(v), q.shift(), q.length)
      resume(q[0][0], q[0][1]);
  }
}
function __asyncDelegator(o) {
  var i, p;
  return i = {}, verb("next"), verb("throw", function(e) {
    throw e;
  }), verb("return"), i[Symbol.iterator] = function() {
    return this;
  }, i;
  function verb(n, f) {
    i[n] = o[n] ? function(v) {
      return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v;
    } : f;
  }
}
function __asyncValues(o) {
  if (!Symbol.asyncIterator)
    throw new TypeError("Symbol.asyncIterator is not defined.");
  var m = o[Symbol.asyncIterator], i;
  return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() {
    return this;
  }, i);
  function verb(n) {
    i[n] = o[n] && function(v) {
      return new Promise(function(resolve, reject) {
        v = o[n](v), settle2(resolve, reject, v.done, v.value);
      });
    };
  }
  function settle2(resolve, reject, d, v) {
    Promise.resolve(v).then(function(v2) {
      resolve({ value: v2, done: d });
    }, reject);
  }
}
function __makeTemplateObject(cooked, raw) {
  if (Object.defineProperty) {
    Object.defineProperty(cooked, "raw", { value: raw });
  } else {
    cooked.raw = raw;
  }
  return cooked;
}
function __importStar(mod) {
  if (mod && mod.__esModule)
    return mod;
  var result = {};
  if (mod != null) {
    for (var k in mod)
      if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k))
        __createBinding(result, mod, k);
  }
  __setModuleDefault(result, mod);
  return result;
}
function __importDefault(mod) {
  return mod && mod.__esModule ? mod : { default: mod };
}
function __classPrivateFieldGet(receiver, state, kind, f) {
  if (kind === "a" && !f)
    throw new TypeError("Private accessor was defined without a getter");
  if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
    throw new TypeError("Cannot read private member from an object whose class did not declare it");
  return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
}
function __classPrivateFieldSet(receiver, state, value, kind, f) {
  if (kind === "m")
    throw new TypeError("Private method is not writable");
  if (kind === "a" && !f)
    throw new TypeError("Private accessor was defined without a setter");
  if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
    throw new TypeError("Cannot write private member to an object whose class did not declare it");
  return kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value), value;
}
function __classPrivateFieldIn(state, receiver) {
  if (receiver === null || typeof receiver !== "object" && typeof receiver !== "function")
    throw new TypeError("Cannot use 'in' operator on non-object");
  return typeof state === "function" ? receiver === state : state.has(receiver);
}
var extendStatics, __assign, __createBinding, __setModuleDefault;
var init_tslib_es6 = __esm({
  "../../node_modules/.pnpm/tslib@2.4.0/node_modules/tslib/tslib.es6.js"() {
    extendStatics = function(d, b) {
      extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
        d2.__proto__ = b2;
      } || function(d2, b2) {
        for (var p in b2)
          if (Object.prototype.hasOwnProperty.call(b2, p))
            d2[p] = b2[p];
      };
      return extendStatics(d, b);
    };
    __assign = function() {
      __assign = Object.assign || function __assign3(t) {
        for (var s, i = 1, n = arguments.length; i < n; i++) {
          s = arguments[i];
          for (var p in s)
            if (Object.prototype.hasOwnProperty.call(s, p))
              t[p] = s[p];
        }
        return t;
      };
      return __assign.apply(this, arguments);
    };
    __createBinding = Object.create ? function(o, m, k, k2) {
      if (k2 === void 0)
        k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    } : function(o, m, k, k2) {
      if (k2 === void 0)
        k2 = k;
      o[k2] = m[k];
    };
    __setModuleDefault = Object.create ? function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
    } : function(o, v) {
      o["default"] = v;
    };
  }
});

// ../../node_modules/.pnpm/@aws-sdk+middleware-endpoint@3.272.0/node_modules/@aws-sdk/middleware-endpoint/dist-cjs/service-customizations/s3.js
var require_s3 = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+middleware-endpoint@3.272.0/node_modules/@aws-sdk/middleware-endpoint/dist-cjs/service-customizations/s3.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.isArnBucketName = exports.isDnsCompatibleBucketName = exports.S3_HOSTNAME_PATTERN = exports.DOT_PATTERN = exports.resolveParamsForS3 = void 0;
    var resolveParamsForS3 = async (endpointParams) => {
      const 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 ((0, exports.isArnBucketName)(bucket)) {
        if (endpointParams.ForcePathStyle === true) {
          throw new Error("Path-style addressing cannot be used with ARN buckets");
        }
      } else if (!(0, exports.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 endpointParams;
    };
    exports.resolveParamsForS3 = resolveParamsForS3;
    var DOMAIN_PATTERN = /^[a-z0-9][a-z0-9\.\-]{1,61}[a-z0-9]$/;
    var IP_ADDRESS_PATTERN = /(\d+\.){3}\d+/;
    var DOTS_PATTERN = /\.\./;
    exports.DOT_PATTERN = /\./;
    exports.S3_HOSTNAME_PATTERN = /^(.+\.)?s3(-fips)?(\.dualstack)?[.-]([a-z0-9-]+)\./;
    var isDnsCompatibleBucketName = (bucketName) => DOMAIN_PATTERN.test(bucketName) && !IP_ADDRESS_PATTERN.test(bucketName) && !DOTS_PATTERN.test(bucketName);
    exports.isDnsCompatibleBucketName = isDnsCompatibleBucketName;
    var isArnBucketName = (bucketName) => {
      const [arn, partition, service, region, account, typeOrId] = bucketName.split(":");
      const isArn = arn === "arn" && bucketName.split(":").length >= 6;
      const isValidArn = [arn, partition, service, account, typeOrId].filter(Boolean).length === 5;
      if (isArn && !isValidArn) {
        throw new Error(`Invalid ARN: ${bucketName} was an invalid ARN.`);
      }
      return arn === "arn" && !!partition && !!service && !!account && !!typeOrId;
    };
    exports.isArnBucketName = isArnBucketName;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+middleware-endpoint@3.272.0/node_modules/@aws-sdk/middleware-endpoint/dist-cjs/service-customizations/index.js
var require_service_customizations = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+middleware-endpoint@3.272.0/node_modules/@aws-sdk/middleware-endpoint/dist-cjs/service-customizations/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    var tslib_1 = (init_tslib_es6(), __toCommonJS(tslib_es6_exports));
    tslib_1.__exportStar(require_s3(), exports);
  }
});

// ../../node_modules/.pnpm/@aws-sdk+middleware-endpoint@3.272.0/node_modules/@aws-sdk/middleware-endpoint/dist-cjs/adaptors/createConfigValueProvider.js
var require_createConfigValueProvider = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+middleware-endpoint@3.272.0/node_modules/@aws-sdk/middleware-endpoint/dist-cjs/adaptors/createConfigValueProvider.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.createConfigValueProvider = void 0;
    var createConfigValueProvider = (configKey, canonicalEndpointParamKey, config) => {
      const configProvider = async () => {
        var _a;
        const configValue = (_a = config[configKey]) !== null && _a !== void 0 ? _a : config[canonicalEndpointParamKey];
        if (typeof configValue === "function") {
          return configValue();
        }
        return configValue;
      };
      if (configKey === "endpoint" || canonicalEndpointParamKey === "endpoint") {
        return async () => {
          const endpoint = await configProvider();
          if (endpoint && typeof endpoint === "object") {
            if ("url" in endpoint) {
              return endpoint.url.href;
            }
            if ("hostname" in endpoint) {
              const { protocol, hostname, port, path: path3 } = endpoint;
              return `${protocol}//${hostname}${port ? ":" + port : ""}${path3}`;
            }
          }
          return endpoint;
        };
      }
      return configProvider;
    };
    exports.createConfigValueProvider = createConfigValueProvider;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+middleware-endpoint@3.272.0/node_modules/@aws-sdk/middleware-endpoint/dist-cjs/adaptors/getEndpointFromInstructions.js
var require_getEndpointFromInstructions = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+middleware-endpoint@3.272.0/node_modules/@aws-sdk/middleware-endpoint/dist-cjs/adaptors/getEndpointFromInstructions.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.resolveParams = exports.getEndpointFromInstructions = void 0;
    var service_customizations_1 = require_service_customizations();
    var createConfigValueProvider_1 = require_createConfigValueProvider();
    var getEndpointFromInstructions = async (commandInput, instructionsSupplier, clientConfig, context) => {
      const endpointParams = await (0, exports.resolveParams)(commandInput, instructionsSupplier, clientConfig);
      if (typeof clientConfig.endpointProvider !== "function") {
        throw new Error("config.endpointProvider is not set.");
      }
      const endpoint = clientConfig.endpointProvider(endpointParams, context);
      return endpoint;
    };
    exports.getEndpointFromInstructions = getEndpointFromInstructions;
    var resolveParams = async (commandInput, instructionsSupplier, clientConfig) => {
      var _a;
      const endpointParams = {};
      const instructions = ((_a = instructionsSupplier === null || instructionsSupplier === void 0 ? void 0 : instructionsSupplier.getEndpointParameterInstructions) === null || _a === void 0 ? void 0 : _a.call(instructionsSupplier)) || {};
      for (const [name, instruction] of Object.entries(instructions)) {
        switch (instruction.type) {
          case "staticContextParams":
            endpointParams[name] = instruction.value;
            break;
          case "contextParams":
            endpointParams[name] = commandInput[instruction.name];
            break;
          case "clientContextParams":
          case "builtInParams":
            endpointParams[name] = await (0, createConfigValueProvider_1.createConfigValueProvider)(instruction.name, name, clientConfig)();
            break;
          default:
            throw new Error("Unrecognized endpoint parameter instruction: " + JSON.stringify(instruction));
        }
      }
      if (Object.keys(instructions).length === 0) {
        Object.assign(endpointParams, clientConfig);
      }
      if (String(clientConfig.serviceId).toLowerCase() === "s3") {
        await (0, service_customizations_1.resolveParamsForS3)(endpointParams);
      }
      return endpointParams;
    };
    exports.resolveParams = resolveParams;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+querystring-parser@3.272.0/node_modules/@aws-sdk/querystring-parser/dist-cjs/index.js
var require_dist_cjs = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+querystring-parser@3.272.0/node_modules/@aws-sdk/querystring-parser/dist-cjs/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.parseQueryString = void 0;
    function parseQueryString(querystring) {
      const query = {};
      querystring = querystring.replace(/^\?/, "");
      if (querystring) {
        for (const pair of querystring.split("&")) {
          let [key, value = null] = pair.split("=");
          key = decodeURIComponent(key);
          if (value) {
            value = decodeURIComponent(value);
          }
          if (!(key in query)) {
            query[key] = value;
          } else if (Array.isArray(query[key])) {
            query[key].push(value);
          } else {
            query[key] = [query[key], value];
          }
        }
      }
      return query;
    }
    exports.parseQueryString = parseQueryString;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+url-parser@3.272.0/node_modules/@aws-sdk/url-parser/dist-cjs/index.js
var require_dist_cjs2 = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+url-parser@3.272.0/node_modules/@aws-sdk/url-parser/dist-cjs/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.parseUrl = void 0;
    var querystring_parser_1 = require_dist_cjs();
    var parseUrl = (url2) => {
      if (typeof url2 === "string") {
        return (0, exports.parseUrl)(new URL(url2));
      }
      const { hostname, pathname, port, protocol, search } = url2;
      let query;
      if (search) {
        query = (0, querystring_parser_1.parseQueryString)(search);
      }
      return {
        hostname,
        port: port ? parseInt(port) : void 0,
        protocol,
        path: pathname,
        query
      };
    };
    exports.parseUrl = parseUrl;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+middleware-endpoint@3.272.0/node_modules/@aws-sdk/middleware-endpoint/dist-cjs/adaptors/toEndpointV1.js
var require_toEndpointV1 = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+middleware-endpoint@3.272.0/node_modules/@aws-sdk/middleware-endpoint/dist-cjs/adaptors/toEndpointV1.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.toEndpointV1 = void 0;
    var url_parser_1 = require_dist_cjs2();
    var toEndpointV1 = (endpoint) => {
      if (typeof endpoint === "object") {
        if ("url" in endpoint) {
          return (0, url_parser_1.parseUrl)(endpoint.url);
        }
        return endpoint;
      }
      return (0, url_parser_1.parseUrl)(endpoint);
    };
    exports.toEndpointV1 = toEndpointV1;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+middleware-endpoint@3.272.0/node_modules/@aws-sdk/middleware-endpoint/dist-cjs/adaptors/index.js
var require_adaptors = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+middleware-endpoint@3.272.0/node_modules/@aws-sdk/middleware-endpoint/dist-cjs/adaptors/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    var tslib_1 = (init_tslib_es6(), __toCommonJS(tslib_es6_exports));
    tslib_1.__exportStar(require_getEndpointFromInstructions(), exports);
    tslib_1.__exportStar(require_toEndpointV1(), exports);
  }
});

// ../../node_modules/.pnpm/@aws-sdk+middleware-endpoint@3.272.0/node_modules/@aws-sdk/middleware-endpoint/dist-cjs/endpointMiddleware.js
var require_endpointMiddleware = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+middleware-endpoint@3.272.0/node_modules/@aws-sdk/middleware-endpoint/dist-cjs/endpointMiddleware.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.endpointMiddleware = void 0;
    var getEndpointFromInstructions_1 = require_getEndpointFromInstructions();
    var endpointMiddleware = ({ config, instructions }) => {
      return (next, context) => async (args) => {
        var _a, _b;
        const endpoint = await (0, getEndpointFromInstructions_1.getEndpointFromInstructions)(args.input, {
          getEndpointParameterInstructions() {
            return instructions;
          }
        }, { ...config }, context);
        context.endpointV2 = endpoint;
        context.authSchemes = (_a = endpoint.properties) === null || _a === void 0 ? void 0 : _a.authSchemes;
        const authScheme = (_b = context.authSchemes) === null || _b === void 0 ? void 0 : _b[0];
        if (authScheme) {
          context["signing_region"] = authScheme.signingRegion;
          context["signing_service"] = authScheme.signingName;
        }
        return next({
          ...args
        });
      };
    };
    exports.endpointMiddleware = endpointMiddleware;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+middleware-serde@3.272.0/node_modules/@aws-sdk/middleware-serde/dist-cjs/deserializerMiddleware.js
var require_deserializerMiddleware = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+middleware-serde@3.272.0/node_modules/@aws-sdk/middleware-serde/dist-cjs/deserializerMiddleware.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.deserializerMiddleware = void 0;
    var deserializerMiddleware = (options, deserializer) => (next, context) => async (args) => {
      const { response } = await next(args);
      try {
        const parsed = await deserializer(response, options);
        return {
          response,
          output: parsed
        };
      } catch (error) {
        Object.defineProperty(error, "$response", {
          value: response
        });
        throw error;
      }
    };
    exports.deserializerMiddleware = deserializerMiddleware;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+middleware-serde@3.272.0/node_modules/@aws-sdk/middleware-serde/dist-cjs/serializerMiddleware.js
var require_serializerMiddleware = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+middleware-serde@3.272.0/node_modules/@aws-sdk/middleware-serde/dist-cjs/serializerMiddleware.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.serializerMiddleware = void 0;
    var serializerMiddleware = (options, serializer) => (next, context) => async (args) => {
      var _a;
      const endpoint = ((_a = context.endpointV2) === null || _a === void 0 ? void 0 : _a.url) && options.urlParser ? async () => options.urlParser(context.endpointV2.url) : options.endpoint;
      if (!endpoint) {
        throw new Error("No valid endpoint provider available.");
      }
      const request = await serializer(args.input, { ...options, endpoint });
      return next({
        ...args,
        request
      });
    };
    exports.serializerMiddleware = serializerMiddleware;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+middleware-serde@3.272.0/node_modules/@aws-sdk/middleware-serde/dist-cjs/serdePlugin.js
var require_serdePlugin = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+middleware-serde@3.272.0/node_modules/@aws-sdk/middleware-serde/dist-cjs/serdePlugin.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.getSerdePlugin = exports.serializerMiddlewareOption = exports.deserializerMiddlewareOption = void 0;
    var deserializerMiddleware_1 = require_deserializerMiddleware();
    var serializerMiddleware_1 = require_serializerMiddleware();
    exports.deserializerMiddlewareOption = {
      name: "deserializerMiddleware",
      step: "deserialize",
      tags: ["DESERIALIZER"],
      override: true
    };
    exports.serializerMiddlewareOption = {
      name: "serializerMiddleware",
      step: "serialize",
      tags: ["SERIALIZER"],
      override: true
    };
    function getSerdePlugin(config, serializer, deserializer) {
      return {
        applyToStack: (commandStack) => {
          commandStack.add((0, deserializerMiddleware_1.deserializerMiddleware)(config, deserializer), exports.deserializerMiddlewareOption);
          commandStack.add((0, serializerMiddleware_1.serializerMiddleware)(config, serializer), exports.serializerMiddlewareOption);
        }
      };
    }
    exports.getSerdePlugin = getSerdePlugin;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+middleware-serde@3.272.0/node_modules/@aws-sdk/middleware-serde/dist-cjs/index.js
var require_dist_cjs3 = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+middleware-serde@3.272.0/node_modules/@aws-sdk/middleware-serde/dist-cjs/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    var tslib_1 = (init_tslib_es6(), __toCommonJS(tslib_es6_exports));
    tslib_1.__exportStar(require_deserializerMiddleware(), exports);
    tslib_1.__exportStar(require_serdePlugin(), exports);
    tslib_1.__exportStar(require_serializerMiddleware(), exports);
  }
});

// ../../node_modules/.pnpm/@aws-sdk+middleware-endpoint@3.272.0/node_modules/@aws-sdk/middleware-endpoint/dist-cjs/getEndpointPlugin.js
var require_getEndpointPlugin = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+middleware-endpoint@3.272.0/node_modules/@aws-sdk/middleware-endpoint/dist-cjs/getEndpointPlugin.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.getEndpointPlugin = exports.endpointMiddlewareOptions = void 0;
    var middleware_serde_1 = require_dist_cjs3();
    var endpointMiddleware_1 = require_endpointMiddleware();
    exports.endpointMiddlewareOptions = {
      step: "serialize",
      tags: ["ENDPOINT_PARAMETERS", "ENDPOINT_V2", "ENDPOINT"],
      name: "endpointV2Middleware",
      override: true,
      relation: "before",
      toMiddleware: middleware_serde_1.serializerMiddlewareOption.name
    };
    var getEndpointPlugin = (config, instructions) => ({
      applyToStack: (clientStack) => {
        clientStack.addRelativeTo((0, endpointMiddleware_1.endpointMiddleware)({
          config,
          instructions
        }), exports.endpointMiddlewareOptions);
      }
    });
    exports.getEndpointPlugin = getEndpointPlugin;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+util-middleware@3.272.0/node_modules/@aws-sdk/util-middleware/dist-cjs/normalizeProvider.js
var require_normalizeProvider = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+util-middleware@3.272.0/node_modules/@aws-sdk/util-middleware/dist-cjs/normalizeProvider.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.normalizeProvider = void 0;
    var normalizeProvider = (input) => {
      if (typeof input === "function")
        return input;
      const promisified = Promise.resolve(input);
      return () => promisified;
    };
    exports.normalizeProvider = normalizeProvider;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+util-middleware@3.272.0/node_modules/@aws-sdk/util-middleware/dist-cjs/index.js
var require_dist_cjs4 = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+util-middleware@3.272.0/node_modules/@aws-sdk/util-middleware/dist-cjs/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    var tslib_1 = (init_tslib_es6(), __toCommonJS(tslib_es6_exports));
    tslib_1.__exportStar(require_normalizeProvider(), exports);
  }
});

// ../../node_modules/.pnpm/@aws-sdk+middleware-endpoint@3.272.0/node_modules/@aws-sdk/middleware-endpoint/dist-cjs/resolveEndpointConfig.js
var require_resolveEndpointConfig = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+middleware-endpoint@3.272.0/node_modules/@aws-sdk/middleware-endpoint/dist-cjs/resolveEndpointConfig.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.resolveEndpointConfig = void 0;
    var util_middleware_1 = require_dist_cjs4();
    var toEndpointV1_1 = require_toEndpointV1();
    var resolveEndpointConfig = (input) => {
      var _a, _b, _c;
      const tls = (_a = input.tls) !== null && _a !== void 0 ? _a : true;
      const { endpoint } = input;
      const customEndpointProvider = endpoint != null ? async () => (0, toEndpointV1_1.toEndpointV1)(await (0, util_middleware_1.normalizeProvider)(endpoint)()) : void 0;
      const isCustomEndpoint = !!endpoint;
      return {
        ...input,
        endpoint: customEndpointProvider,
        tls,
        isCustomEndpoint,
        useDualstackEndpoint: (0, util_middleware_1.normalizeProvider)((_b = input.useDualstackEndpoint) !== null && _b !== void 0 ? _b : false),
        useFipsEndpoint: (0, util_middleware_1.normalizeProvider)((_c = input.useFipsEndpoint) !== null && _c !== void 0 ? _c : false)
      };
    };
    exports.resolveEndpointConfig = resolveEndpointConfig;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+middleware-endpoint@3.272.0/node_modules/@aws-sdk/middleware-endpoint/dist-cjs/types.js
var require_types = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+middleware-endpoint@3.272.0/node_modules/@aws-sdk/middleware-endpoint/dist-cjs/types.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
  }
});

// ../../node_modules/.pnpm/@aws-sdk+middleware-endpoint@3.272.0/node_modules/@aws-sdk/middleware-endpoint/dist-cjs/index.js
var require_dist_cjs5 = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+middleware-endpoint@3.272.0/node_modules/@aws-sdk/middleware-endpoint/dist-cjs/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    var tslib_1 = (init_tslib_es6(), __toCommonJS(tslib_es6_exports));
    tslib_1.__exportStar(require_adaptors(), exports);
    tslib_1.__exportStar(require_endpointMiddleware(), exports);
    tslib_1.__exportStar(require_getEndpointPlugin(), exports);
    tslib_1.__exportStar(require_resolveEndpointConfig(), exports);
    tslib_1.__exportStar(require_types(), exports);
  }
});

// ../../node_modules/.pnpm/@aws-sdk+smithy-client@3.272.0/node_modules/@aws-sdk/smithy-client/dist-cjs/NoOpLogger.js
var require_NoOpLogger = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+smithy-client@3.272.0/node_modules/@aws-sdk/smithy-client/dist-cjs/NoOpLogger.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.NoOpLogger = void 0;
    var NoOpLogger = class {
      trace() {
      }
      debug() {
      }
      info() {
      }
      warn() {
      }
      error() {
      }
    };
    exports.NoOpLogger = NoOpLogger;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+middleware-stack@3.272.0/node_modules/@aws-sdk/middleware-stack/dist-cjs/MiddlewareStack.js
var require_MiddlewareStack = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+middleware-stack@3.272.0/node_modules/@aws-sdk/middleware-stack/dist-cjs/MiddlewareStack.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.constructStack = void 0;
    var constructStack = () => {
      let absoluteEntries = [];
      let relativeEntries = [];
      const entriesNameSet = /* @__PURE__ */ new Set();
      const sort = (entries) => entries.sort((a, b) => stepWeights[b.step] - stepWeights[a.step] || priorityWeights[b.priority || "normal"] - priorityWeights[a.priority || "normal"]);
      const removeByName = (toRemove) => {
        let isRemoved = false;
        const filterCb = (entry) => {
          if (entry.name && entry.name === toRemove) {
            isRemoved = true;
            entriesNameSet.delete(toRemove);
            return false;
          }
          return true;
        };
        absoluteEntries = absoluteEntries.filter(filterCb);
        relativeEntries = relativeEntries.filter(filterCb);
        return isRemoved;
      };
      const removeByReference = (toRemove) => {
        let isRemoved = false;
        const filterCb = (entry) => {
          if (entry.middleware === toRemove) {
            isRemoved = true;
            if (entry.name)
              entriesNameSet.delete(entry.name);
            return false;
          }
          return true;
        };
        absoluteEntries = absoluteEntries.filter(filterCb);
        relativeEntries = relativeEntries.filter(filterCb);
        return isRemoved;
      };
      const cloneTo = (toStack) => {
        absoluteEntries.forEach((entry) => {
          toStack.add(entry.middleware, { ...entry });
        });
        relativeEntries.forEach((entry) => {
          toStack.addRelativeTo(entry.middleware, { ...entry });
        });
        return toStack;
      };
      const expandRelativeMiddlewareList = (from) => {
        const expandedMiddlewareList = [];
        from.before.forEach((entry) => {
          if (entry.before.length === 0 && entry.after.length === 0) {
            expandedMiddlewareList.push(entry);
          } else {
            expandedMiddlewareList.push(...expandRelativeMiddlewareList(entry));
          }
        });
        expandedMiddlewareList.push(from);
        from.after.reverse().forEach((entry) => {
          if (entry.before.length === 0 && entry.after.length === 0) {
            expandedMiddlewareList.push(entry);
          } else {
            expandedMiddlewareList.push(...expandRelativeMiddlewareList(entry));
          }
        });
        return expandedMiddlewareList;
      };
      const getMiddlewareList = (debug = false) => {
        const normalizedAbsoluteEntries = [];
        const normalizedRelativeEntries = [];
        const normalizedEntriesNameMap = {};
        absoluteEntries.forEach((entry) => {
          const normalizedEntry = {
            ...entry,
            before: [],
            after: []
          };
          if (normalizedEntry.name)
            normalizedEntriesNameMap[normalizedEntry.name] = normalizedEntry;
          normalizedAbsoluteEntries.push(normalizedEntry);
        });
        relativeEntries.forEach((entry) => {
          const normalizedEntry = {
            ...entry,
            before: [],
            after: []
          };
          if (normalizedEntry.name)
            normalizedEntriesNameMap[normalizedEntry.name] = normalizedEntry;
          normalizedRelativeEntries.push(normalizedEntry);
        });
        normalizedRelativeEntries.forEach((entry) => {
          if (entry.toMiddleware) {
            const toMiddleware = normalizedEntriesNameMap[entry.toMiddleware];
            if (toMiddleware === void 0) {
              if (debug) {
                return;
              }
              throw new Error(`${entry.toMiddleware} is not found when adding ${entry.name || "anonymous"} middleware ${entry.relation} ${entry.toMiddleware}`);
            }
            if (entry.relation === "after") {
              toMiddleware.after.push(entry);
            }
            if (entry.relation === "before") {
              toMiddleware.before.push(entry);
            }
          }
        });
        const mainChain = sort(normalizedAbsoluteEntries).map(expandRelativeMiddlewareList).reduce((wholeList, expendedMiddlewareList) => {
          wholeList.push(...expendedMiddlewareList);
          return wholeList;
        }, []);
        return mainChain;
      };
      const stack = {
        add: (middleware, options = {}) => {
          const { name, override } = options;
          const entry = {
            step: "initialize",
            priority: "normal",
            middleware,
            ...options
          };
          if (name) {
            if (entriesNameSet.has(name)) {
              if (!override)
                throw new Error(`Duplicate middleware name '${name}'`);
              const toOverrideIndex = absoluteEntries.findIndex((entry2) => entry2.name === name);
              const toOverride = absoluteEntries[toOverrideIndex];
              if (toOverride.step !== entry.step || toOverride.priority !== entry.priority) {
                throw new Error(`"${name}" middleware with ${toOverride.priority} priority in ${toOverride.step} step cannot be overridden by same-name middleware with ${entry.priority} priority in ${entry.step} step.`);
              }
              absoluteEntries.splice(toOverrideIndex, 1);
            }
            entriesNameSet.add(name);
          }
          absoluteEntries.push(entry);
        },
        addRelativeTo: (middleware, options) => {
          const { name, override } = options;
          const entry = {
            middleware,
            ...options
          };
          if (name) {
            if (entriesNameSet.has(name)) {
              if (!override)
                throw new Error(`Duplicate middleware name '${name}'`);
              const toOverrideIndex = relativeEntries.findIndex((entry2) => entry2.name === name);
              const toOverride = relativeEntries[toOverrideIndex];
              if (toOverride.toMiddleware !== entry.toMiddleware || toOverride.relation !== entry.relation) {
                throw new Error(`"${name}" middleware ${toOverride.relation} "${toOverride.toMiddleware}" middleware cannot be overridden by same-name middleware ${entry.relation} "${entry.toMiddleware}" middleware.`);
              }
              relativeEntries.splice(toOverrideIndex, 1);
            }
            entriesNameSet.add(name);
          }
          relativeEntries.push(entry);
        },
        clone: () => cloneTo((0, exports.constructStack)()),
        use: (plugin) => {
          plugin.applyToStack(stack);
        },
        remove: (toRemove) => {
          if (typeof toRemove === "string")
            return removeByName(toRemove);
          else
            return removeByReference(toRemove);
        },
        removeByTag: (toRemove) => {
          let isRemoved = false;
          const filterCb = (entry) => {
            const { tags, name } = entry;
            if (tags && tags.includes(toRemove)) {
              if (name)
                entriesNameSet.delete(name);
              isRemoved = true;
              return false;
            }
            return true;
          };
          absoluteEntries = absoluteEntries.filter(filterCb);
          relativeEntries = relativeEntries.filter(filterCb);
          return isRemoved;
        },
        concat: (from) => {
          const cloned = cloneTo((0, exports.constructStack)());
          cloned.use(from);
          return cloned;
        },
        applyToStack: cloneTo,
        identify: () => {
          return getMiddlewareList(true).map((mw) => {
            return mw.name + ": " + (mw.tags || []).join(",");
          });
        },
        resolve: (handler, context) => {
          for (const middleware of getMiddlewareList().map((entry) => entry.middleware).reverse()) {
            handler = middleware(handler, context);
          }
          return handler;
        }
      };
      return stack;
    };
    exports.constructStack = constructStack;
    var stepWeights = {
      initialize: 5,
      serialize: 4,
      build: 3,
      finalizeRequest: 2,
      deserialize: 1
    };
    var priorityWeights = {
      high: 3,
      normal: 2,
      low: 1
    };
  }
});

// ../../node_modules/.pnpm/@aws-sdk+middleware-stack@3.272.0/node_modules/@aws-sdk/middleware-stack/dist-cjs/index.js
var require_dist_cjs6 = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+middleware-stack@3.272.0/node_modules/@aws-sdk/middleware-stack/dist-cjs/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    var tslib_1 = (init_tslib_es6(), __toCommonJS(tslib_es6_exports));
    tslib_1.__exportStar(require_MiddlewareStack(), exports);
  }
});

// ../../node_modules/.pnpm/@aws-sdk+smithy-client@3.272.0/node_modules/@aws-sdk/smithy-client/dist-cjs/client.js
var require_client = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+smithy-client@3.272.0/node_modules/@aws-sdk/smithy-client/dist-cjs/client.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.Client = void 0;
    var middleware_stack_1 = require_dist_cjs6();
    var Client = class {
      constructor(config) {
        this.middlewareStack = (0, middleware_stack_1.constructStack)();
        this.config = config;
      }
      send(command, optionsOrCb, cb) {
        const options = typeof optionsOrCb !== "function" ? optionsOrCb : void 0;
        const callback = typeof optionsOrCb === "function" ? optionsOrCb : cb;
        const handler = command.resolveMiddleware(this.middlewareStack, this.config, options);
        if (callback) {
          handler(command).then((result) => callback(null, result.output), (err) => callback(err)).catch(() => {
          });
        } else {
          return handler(command).then((result) => result.output);
        }
      }
      destroy() {
        if (this.config.requestHandler.destroy)
          this.config.requestHandler.destroy();
      }
    };
    exports.Client = Client;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+smithy-client@3.272.0/node_modules/@aws-sdk/smithy-client/dist-cjs/command.js
var require_command = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+smithy-client@3.272.0/node_modules/@aws-sdk/smithy-client/dist-cjs/command.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.Command = void 0;
    var middleware_stack_1 = require_dist_cjs6();
    var Command = class {
      constructor() {
        this.middlewareStack = (0, middleware_stack_1.constructStack)();
      }
    };
    exports.Command = Command;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+smithy-client@3.272.0/node_modules/@aws-sdk/smithy-client/dist-cjs/constants.js
var require_constants = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+smithy-client@3.272.0/node_modules/@aws-sdk/smithy-client/dist-cjs/constants.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.SENSITIVE_STRING = void 0;
    exports.SENSITIVE_STRING = "***SensitiveInformation***";
  }
});

// ../../node_modules/.pnpm/@aws-sdk+smithy-client@3.272.0/node_modules/@aws-sdk/smithy-client/dist-cjs/parse-utils.js
var require_parse_utils = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+smithy-client@3.272.0/node_modules/@aws-sdk/smithy-client/dist-cjs/parse-utils.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.logger = exports.strictParseByte = exports.strictParseShort = exports.strictParseInt32 = exports.strictParseInt = exports.strictParseLong = exports.limitedParseFloat32 = exports.limitedParseFloat = exports.handleFloat = exports.limitedParseDouble = exports.strictParseFloat32 = exports.strictParseFloat = exports.strictParseDouble = exports.expectUnion = exports.expectString = exports.expectObject = exports.expectNonNull = exports.expectByte = exports.expectShort = exports.expectInt32 = exports.expectInt = exports.expectLong = exports.expectFloat32 = exports.expectNumber = exports.expectBoolean = exports.parseBoolean = void 0;
    var parseBoolean = (value) => {
      switch (value) {
        case "true":
          return true;
        case "false":
          return false;
        default:
          throw new Error(`Unable to parse boolean value "${value}"`);
      }
    };
    exports.parseBoolean = parseBoolean;
    var expectBoolean = (value) => {
      if (value === null || value === void 0) {
        return void 0;
      }
      if (typeof value === "number") {
        if (value === 0 || value === 1) {
          exports.logger.warn(stackTraceWarning(`Expected boolean, got ${typeof value}: ${value}`));
        }
        if (value === 0) {
          return false;
        }
        if (value === 1) {
          return true;
        }
      }
      if (typeof value === "string") {
        const lower = value.toLowerCase();
        if (lower === "false" || lower === "true") {
          exports.logger.warn(stackTraceWarning(`Expected boolean, got ${typeof value}: ${value}`));
        }
        if (lower === "false") {
          return false;
        }
        if (lower === "true") {
          return true;
        }
      }
      if (typeof value === "boolean") {
        return value;
      }
      throw new TypeError(`Expected boolean, got ${typeof value}: ${value}`);
    };
    exports.expectBoolean = expectBoolean;
    var expectNumber = (value) => {
      if (value === null || value === void 0) {
        return void 0;
      }
      if (typeof value === "string") {
        const parsed = parseFloat(value);
        if (!Number.isNaN(parsed)) {
          if (String(parsed) !== String(value)) {
            exports.logger.warn(stackTraceWarning(`Expected number but observed string: ${value}`));
          }
          return parsed;
        }
      }
      if (typeof value === "number") {
        return value;
      }
      throw new TypeError(`Expected number, got ${typeof value}: ${value}`);
    };
    exports.expectNumber = expectNumber;
    var MAX_FLOAT = Math.ceil(2 ** 127 * (2 - 2 ** -23));
    var expectFloat32 = (value) => {
      const expected = (0, exports.expectNumber)(value);
      if (expected !== void 0 && !Number.isNaN(expected) && expected !== Infinity && expected !== -Infinity) {
        if (Math.abs(expected) > MAX_FLOAT) {
          throw new TypeError(`Expected 32-bit float, got ${value}`);
        }
      }
      return expected;
    };
    exports.expectFloat32 = expectFloat32;
    var expectLong = (value) => {
      if (value === null || value === void 0) {
        return void 0;
      }
      if (Number.isInteger(value) && !Number.isNaN(value)) {
        return value;
      }
      throw new TypeError(`Expected integer, got ${typeof value}: ${value}`);
    };
    exports.expectLong = expectLong;
    exports.expectInt = exports.expectLong;
    var expectInt32 = (value) => expectSizedInt(value, 32);
    exports.expectInt32 = expectInt32;
    var expectShort = (value) => expectSizedInt(value, 16);
    exports.expectShort = expectShort;
    var expectByte = (value) => expectSizedInt(value, 8);
    exports.expectByte = expectByte;
    var expectSizedInt = (value, size) => {
      const expected = (0, exports.expectLong)(value);
      if (expected !== void 0 && castInt(expected, size) !== expected) {
        throw new TypeError(`Expected ${size}-bit integer, got ${value}`);
      }
      return expected;
    };
    var castInt = (value, size) => {
      switch (size) {
        case 32:
          return Int32Array.of(value)[0];
        case 16:
          return Int16Array.of(value)[0];
        case 8:
          return Int8Array.of(value)[0];
      }
    };
    var expectNonNull = (value, location) => {
      if (value === null || value === void 0) {
        if (location) {
          throw new TypeError(`Expected a non-null value for ${location}`);
        }
        throw new TypeError("Expected a non-null value");
      }
      return value;
    };
    exports.expectNonNull = expectNonNull;
    var expectObject = (value) => {
      if (value === null || value === void 0) {
        return void 0;
      }
      if (typeof value === "object" && !Array.isArray(value)) {
        return value;
      }
      const receivedType = Array.isArray(value) ? "array" : typeof value;
      throw new TypeError(`Expected object, got ${receivedType}: ${value}`);
    };
    exports.expectObject = expectObject;
    var expectString = (value) => {
      if (value === null || value === void 0) {
        return void 0;
      }
      if (typeof value === "string") {
        return value;
      }
      if (["boolean", "number", "bigint"].includes(typeof value)) {
        exports.logger.warn(stackTraceWarning(`Expected string, got ${typeof value}: ${value}`));
        return String(value);
      }
      throw new TypeError(`Expected string, got ${typeof value}: ${value}`);
    };
    exports.expectString = expectString;
    var expectUnion = (value) => {
      if (value === null || value === void 0) {
        return void 0;
      }
      const asObject = (0, exports.expectObject)(value);
      const setKeys = Object.entries(asObject).filter(([, v]) => v != null).map(([k]) => k);
      if (setKeys.length === 0) {
        throw new TypeError(`Unions must have exactly one non-null member. None were found.`);
      }
      if (setKeys.length > 1) {
        throw new TypeError(`Unions must have exactly one non-null member. Keys ${setKeys} were not null.`);
      }
      return asObject;
    };
    exports.expectUnion = expectUnion;
    var strictParseDouble = (value) => {
      if (typeof value == "string") {
        return (0, exports.expectNumber)(parseNumber(value));
      }
      return (0, exports.expectNumber)(value);
    };
    exports.strictParseDouble = strictParseDouble;
    exports.strictParseFloat = exports.strictParseDouble;
    var strictParseFloat32 = (value) => {
      if (typeof value == "string") {
        return (0, exports.expectFloat32)(parseNumber(value));
      }
      return (0, exports.expectFloat32)(value);
    };
    exports.strictParseFloat32 = strictParseFloat32;
    var NUMBER_REGEX = /(-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?)|(-?Infinity)|(NaN)/g;
    var parseNumber = (value) => {
      const matches = value.match(NUMBER_REGEX);
      if (matches === null || matches[0].length !== value.length) {
        throw new TypeError(`Expected real number, got implicit NaN`);
      }
      return parseFloat(value);
    };
    var limitedParseDouble = (value) => {
      if (typeof value == "string") {
        return parseFloatString(value);
      }
      return (0, exports.expectNumber)(value);
    };
    exports.limitedParseDouble = limitedParseDouble;
    exports.handleFloat = exports.limitedParseDouble;
    exports.limitedParseFloat = exports.limitedParseDouble;
    var limitedParseFloat32 = (value) => {
      if (typeof value == "string") {
        return parseFloatString(value);
      }
      return (0, exports.expectFloat32)(value);
    };
    exports.limitedParseFloat32 = limitedParseFloat32;
    var parseFloatString = (value) => {
      switch (value) {
        case "NaN":
          return NaN;
        case "Infinity":
          return Infinity;
        case "-Infinity":
          return -Infinity;
        default:
          throw new Error(`Unable to parse float value: ${value}`);
      }
    };
    var strictParseLong = (value) => {
      if (typeof value === "string") {
        return (0, exports.expectLong)(parseNumber(value));
      }
      return (0, exports.expectLong)(value);
    };
    exports.strictParseLong = strictParseLong;
    exports.strictParseInt = exports.strictParseLong;
    var strictParseInt32 = (value) => {
      if (typeof value === "string") {
        return (0, exports.expectInt32)(parseNumber(value));
      }
      return (0, exports.expectInt32)(value);
    };
    exports.strictParseInt32 = strictParseInt32;
    var strictParseShort = (value) => {
      if (typeof value === "string") {
        return (0, exports.expectShort)(parseNumber(value));
      }
      return (0, exports.expectShort)(value);
    };
    exports.strictParseShort = strictParseShort;
    var strictParseByte = (value) => {
      if (typeof value === "string") {
        return (0, exports.expectByte)(parseNumber(value));
      }
      return (0, exports.expectByte)(value);
    };
    exports.strictParseByte = strictParseByte;
    var stackTraceWarning = (message) => {
      return String(new TypeError(message).stack || message).split("\n").slice(0, 5).filter((s) => !s.includes("stackTraceWarning")).join("\n");
    };
    exports.logger = {
      warn: console.warn
    };
  }
});

// ../../node_modules/.pnpm/@aws-sdk+smithy-client@3.272.0/node_modules/@aws-sdk/smithy-client/dist-cjs/date-utils.js
var require_date_utils = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+smithy-client@3.272.0/node_modules/@aws-sdk/smithy-client/dist-cjs/date-utils.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.parseEpochTimestamp = exports.parseRfc7231DateTime = exports.parseRfc3339DateTimeWithOffset = exports.parseRfc3339DateTime = exports.dateToUtcString = void 0;
    var parse_utils_1 = require_parse_utils();
    var DAYS = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
    var MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
    function dateToUtcString(date) {
      const year = date.getUTCFullYear();
      const month = date.getUTCMonth();
      const dayOfWeek = date.getUTCDay();
      const dayOfMonthInt = date.getUTCDate();
      const hoursInt = date.getUTCHours();
      const minutesInt = date.getUTCMinutes();
      const secondsInt = date.getUTCSeconds();
      const dayOfMonthString = dayOfMonthInt < 10 ? `0${dayOfMonthInt}` : `${dayOfMonthInt}`;
      const hoursString = hoursInt < 10 ? `0${hoursInt}` : `${hoursInt}`;
      const minutesString = minutesInt < 10 ? `0${minutesInt}` : `${minutesInt}`;
      const secondsString = secondsInt < 10 ? `0${secondsInt}` : `${secondsInt}`;
      return `${DAYS[dayOfWeek]}, ${dayOfMonthString} ${MONTHS[month]} ${year} ${hoursString}:${minutesString}:${secondsString} GMT`;
    }
    exports.dateToUtcString = dateToUtcString;
    var RFC3339 = new RegExp(/^(\d{4})-(\d{2})-(\d{2})[tT](\d{2}):(\d{2}):(\d{2})(?:\.(\d+))?[zZ]$/);
    var parseRfc3339DateTime = (value) => {
      if (value === null || value === void 0) {
        return void 0;
      }
      if (typeof value !== "string") {
        throw new TypeError("RFC-3339 date-times must be expressed as strings");
      }
      const match = RFC3339.exec(value);
      if (!match) {
        throw new TypeError("Invalid RFC-3339 date-time value");
      }
      const [_, yearStr, monthStr, dayStr, hours, minutes, seconds, fractionalMilliseconds] = match;
      const year = (0, parse_utils_1.strictParseShort)(stripLeadingZeroes(yearStr));
      const month = parseDateValue(monthStr, "month", 1, 12);
      const day = parseDateValue(dayStr, "day", 1, 31);
      return buildDate(year, month, day, { hours, minutes, seconds, fractionalMilliseconds });
    };
    exports.parseRfc3339DateTime = parseRfc3339DateTime;
    var RFC3339_WITH_OFFSET = new RegExp(/^(\d{4})-(\d{2})-(\d{2})[tT](\d{2}):(\d{2}):(\d{2})(?:\.(\d+))?(([-+]\d{2}\:\d{2})|[zZ])$/);
    var parseRfc3339DateTimeWithOffset = (value) => {
      if (value === null || value === void 0) {
        return void 0;
      }
      if (typeof value !== "string") {
        throw new TypeError("RFC-3339 date-times must be expressed as strings");
      }
      const match = RFC3339_WITH_OFFSET.exec(value);
      if (!match) {
        throw new TypeError("Invalid RFC-3339 date-time value");
      }
      const [_, yearStr, monthStr, dayStr, hours, minutes, seconds, fractionalMilliseconds, offsetStr] = match;
      const year = (0, parse_utils_1.strictParseShort)(stripLeadingZeroes(yearStr));
      const month = parseDateValue(monthStr, "month", 1, 12);
      const day = parseDateValue(dayStr, "day", 1, 31);
      const date = buildDate(year, month, day, { hours, minutes, seconds, fractionalMilliseconds });
      if (offsetStr.toUpperCase() != "Z") {
        date.setTime(date.getTime() - parseOffsetToMilliseconds(offsetStr));
      }
      return date;
    };
    exports.parseRfc3339DateTimeWithOffset = parseRfc3339DateTimeWithOffset;
    var IMF_FIXDATE = new RegExp(/^(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun), (\d{2}) (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) (\d{4}) (\d{1,2}):(\d{2}):(\d{2})(?:\.(\d+))? GMT$/);
    var RFC_850_DATE = new RegExp(/^(?:Monday|Tuesday|Wednesday|Thursday|Friday|Saturday|Sunday), (\d{2})-(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)-(\d{2}) (\d{1,2}):(\d{2}):(\d{2})(?:\.(\d+))? GMT$/);
    var ASC_TIME = new RegExp(/^(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun) (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) ( [1-9]|\d{2}) (\d{1,2}):(\d{2}):(\d{2})(?:\.(\d+))? (\d{4})$/);
    var parseRfc7231DateTime = (value) => {
      if (value === null || value === void 0) {
        return void 0;
      }
      if (typeof value !== "string") {
        throw new TypeError("RFC-7231 date-times must be expressed as strings");
      }
      let match = IMF_FIXDATE.exec(value);
      if (match) {
        const [_, dayStr, monthStr, yearStr, hours, minutes, seconds, fractionalMilliseconds] = match;
        return buildDate((0, parse_utils_1.strictParseShort)(stripLeadingZeroes(yearStr)), parseMonthByShortName(monthStr), parseDateValue(dayStr, "day", 1, 31), { hours, minutes, seconds, fractionalMilliseconds });
      }
      match = RFC_850_DATE.exec(value);
      if (match) {
        const [_, dayStr, monthStr, yearStr, hours, minutes, seconds, fractionalMilliseconds] = match;
        return adjustRfc850Year(buildDate(parseTwoDigitYear(yearStr), parseMonthByShortName(monthStr), parseDateValue(dayStr, "day", 1, 31), {
          hours,
          minutes,
          seconds,
          fractionalMilliseconds
        }));
      }
      match = ASC_TIME.exec(value);
      if (match) {
        const [_, monthStr, dayStr, hours, minutes, seconds, fractionalMilliseconds, yearStr] = match;
        return buildDate((0, parse_utils_1.strictParseShort)(stripLeadingZeroes(yearStr)), parseMonthByShortName(monthStr), parseDateValue(dayStr.trimLeft(), "day", 1, 31), { hours, minutes, seconds, fractionalMilliseconds });
      }
      throw new TypeError("Invalid RFC-7231 date-time value");
    };
    exports.parseRfc7231DateTime = parseRfc7231DateTime;
    var parseEpochTimestamp = (value) => {
      if (value === null || value === void 0) {
        return void 0;
      }
      let valueAsDouble;
      if (typeof value === "number") {
        valueAsDouble = value;
      } else if (typeof value === "string") {
        valueAsDouble = (0, parse_utils_1.strictParseDouble)(value);
      } else {
        throw new TypeError("Epoch timestamps must be expressed as floating point numbers or their string representation");
      }
      if (Number.isNaN(valueAsDouble) || valueAsDouble === Infinity || valueAsDouble === -Infinity) {
        throw new TypeError("Epoch timestamps must be valid, non-Infinite, non-NaN numerics");
      }
      return new Date(Math.round(valueAsDouble * 1e3));
    };
    exports.parseEpochTimestamp = parseEpochTimestamp;
    var buildDate = (year, month, day, time) => {
      const adjustedMonth = month - 1;
      validateDayOfMonth(year, adjustedMonth, day);
      return new Date(Date.UTC(year, adjustedMonth, day, parseDateValue(time.hours, "hour", 0, 23), parseDateValue(time.minutes, "minute", 0, 59), parseDateValue(time.seconds, "seconds", 0, 60), parseMilliseconds(time.fractionalMilliseconds)));
    };
    var parseTwoDigitYear = (value) => {
      const thisYear = (/* @__PURE__ */ new Date()).getUTCFullYear();
      const valueInThisCentury = Math.floor(thisYear / 100) * 100 + (0, parse_utils_1.strictParseShort)(stripLeadingZeroes(value));
      if (valueInThisCentury < thisYear) {
        return valueInThisCentury + 100;
      }
      return valueInThisCentury;
    };
    var FIFTY_YEARS_IN_MILLIS = 50 * 365 * 24 * 60 * 60 * 1e3;
    var adjustRfc850Year = (input) => {
      if (input.getTime() - (/* @__PURE__ */ new Date()).getTime() > FIFTY_YEARS_IN_MILLIS) {
        return new Date(Date.UTC(input.getUTCFullYear() - 100, input.getUTCMonth(), input.getUTCDate(), input.getUTCHours(), input.getUTCMinutes(), input.getUTCSeconds(), input.getUTCMilliseconds()));
      }
      return input;
    };
    var parseMonthByShortName = (value) => {
      const monthIdx = MONTHS.indexOf(value);
      if (monthIdx < 0) {
        throw new TypeError(`Invalid month: ${value}`);
      }
      return monthIdx + 1;
    };
    var DAYS_IN_MONTH = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
    var validateDayOfMonth = (year, month, day) => {
      let maxDays = DAYS_IN_MONTH[month];
      if (month === 1 && isLeapYear(year)) {
        maxDays = 29;
      }
      if (day > maxDays) {
        throw new TypeError(`Invalid day for ${MONTHS[month]} in ${year}: ${day}`);
      }
    };
    var isLeapYear = (year) => {
      return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
    };
    var parseDateValue = (value, type, lower, upper) => {
      const dateVal = (0, parse_utils_1.strictParseByte)(stripLeadingZeroes(value));
      if (dateVal < lower || dateVal > upper) {
        throw new TypeError(`${type} must be between ${lower} and ${upper}, inclusive`);
      }
      return dateVal;
    };
    var parseMilliseconds = (value) => {
      if (value === null || value === void 0) {
        return 0;
      }
      return (0, parse_utils_1.strictParseFloat32)("0." + value) * 1e3;
    };
    var parseOffsetToMilliseconds = (value) => {
      const directionStr = value[0];
      let direction = 1;
      if (directionStr == "+") {
        direction = 1;
      } else if (directionStr == "-") {
        direction = -1;
      } else {
        throw new TypeError(`Offset direction, ${directionStr}, must be "+" or "-"`);
      }
      const hour = Number(value.substring(1, 3));
      const minute = Number(value.substring(4, 6));
      return direction * (hour * 60 + minute) * 60 * 1e3;
    };
    var stripLeadingZeroes = (value) => {
      let idx = 0;
      while (idx < value.length - 1 && value.charAt(idx) === "0") {
        idx++;
      }
      if (idx === 0) {
        return value;
      }
      return value.slice(idx);
    };
  }
});

// ../../node_modules/.pnpm/@aws-sdk+smithy-client@3.272.0/node_modules/@aws-sdk/smithy-client/dist-cjs/exceptions.js
var require_exceptions = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+smithy-client@3.272.0/node_modules/@aws-sdk/smithy-client/dist-cjs/exceptions.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.decorateServiceException = exports.ServiceException = void 0;
    var ServiceException = class extends Error {
      constructor(options) {
        super(options.message);
        Object.setPrototypeOf(this, ServiceException.prototype);
        this.name = options.name;
        this.$fault = options.$fault;
        this.$metadata = options.$metadata;
      }
    };
    exports.ServiceException = ServiceException;
    var decorateServiceException = (exception, additions = {}) => {
      Object.entries(additions).filter(([, v]) => v !== void 0).forEach(([k, v]) => {
        if (exception[k] == void 0 || exception[k] === "") {
          exception[k] = v;
        }
      });
      const message = exception.message || exception.Message || "UnknownError";
      exception.message = message;
      delete exception.Message;
      return exception;
    };
    exports.decorateServiceException = decorateServiceException;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+smithy-client@3.272.0/node_modules/@aws-sdk/smithy-client/dist-cjs/default-error-handler.js
var require_default_error_handler = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+smithy-client@3.272.0/node_modules/@aws-sdk/smithy-client/dist-cjs/default-error-handler.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.throwDefaultError = void 0;
    var exceptions_1 = require_exceptions();
    var throwDefaultError = ({ output, parsedBody, exceptionCtor, errorCode }) => {
      const $metadata = deserializeMetadata(output);
      const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : void 0;
      const response = new exceptionCtor({
        name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknownError",
        $fault: "client",
        $metadata
      });
      throw (0, exceptions_1.decorateServiceException)(response, parsedBody);
    };
    exports.throwDefaultError = throwDefaultError;
    var deserializeMetadata = (output) => {
      var _a, _b;
      return {
        httpStatusCode: output.statusCode,
        requestId: (_b = (_a = output.headers["x-amzn-requestid"]) !== null && _a !== void 0 ? _a : output.headers["x-amzn-request-id"]) !== null && _b !== void 0 ? _b : output.headers["x-amz-request-id"],
        extendedRequestId: output.headers["x-amz-id-2"],
        cfId: output.headers["x-amz-cf-id"]
      };
    };
  }
});

// ../../node_modules/.pnpm/@aws-sdk+smithy-client@3.272.0/node_modules/@aws-sdk/smithy-client/dist-cjs/defaults-mode.js
var require_defaults_mode = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+smithy-client@3.272.0/node_modules/@aws-sdk/smithy-client/dist-cjs/defaults-mode.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.loadConfigsForDefaultMode = void 0;
    var loadConfigsForDefaultMode = (mode) => {
      switch (mode) {
        case "standard":
          return {
            retryMode: "standard",
            connectionTimeout: 3100
          };
        case "in-region":
          return {
            retryMode: "standard",
            connectionTimeout: 1100
          };
        case "cross-region":
          return {
            retryMode: "standard",
            connectionTimeout: 3100
          };
        case "mobile":
          return {
            retryMode: "standard",
            connectionTimeout: 3e4
          };
        default:
          return {};
      }
    };
    exports.loadConfigsForDefaultMode = loadConfigsForDefaultMode;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+smithy-client@3.272.0/node_modules/@aws-sdk/smithy-client/dist-cjs/emitWarningIfUnsupportedVersion.js
var require_emitWarningIfUnsupportedVersion = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+smithy-client@3.272.0/node_modules/@aws-sdk/smithy-client/dist-cjs/emitWarningIfUnsupportedVersion.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.emitWarningIfUnsupportedVersion = void 0;
    var warningEmitted = false;
    var emitWarningIfUnsupportedVersion = (version2) => {
      if (version2 && !warningEmitted && parseInt(version2.substring(1, version2.indexOf("."))) < 14) {
        warningEmitted = true;
      }
    };
    exports.emitWarningIfUnsupportedVersion = emitWarningIfUnsupportedVersion;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+smithy-client@3.272.0/node_modules/@aws-sdk/smithy-client/dist-cjs/extended-encode-uri-component.js
var require_extended_encode_uri_component = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+smithy-client@3.272.0/node_modules/@aws-sdk/smithy-client/dist-cjs/extended-encode-uri-component.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.extendedEncodeURIComponent = void 0;
    function extendedEncodeURIComponent(str) {
      return encodeURIComponent(str).replace(/[!'()*]/g, function(c) {
        return "%" + c.charCodeAt(0).toString(16).toUpperCase();
      });
    }
    exports.extendedEncodeURIComponent = extendedEncodeURIComponent;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+smithy-client@3.272.0/node_modules/@aws-sdk/smithy-client/dist-cjs/get-array-if-single-item.js
var require_get_array_if_single_item = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+smithy-client@3.272.0/node_modules/@aws-sdk/smithy-client/dist-cjs/get-array-if-single-item.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.getArrayIfSingleItem = void 0;
    var getArrayIfSingleItem = (mayBeArray) => Array.isArray(mayBeArray) ? mayBeArray : [mayBeArray];
    exports.getArrayIfSingleItem = getArrayIfSingleItem;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+smithy-client@3.272.0/node_modules/@aws-sdk/smithy-client/dist-cjs/get-value-from-text-node.js
var require_get_value_from_text_node = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+smithy-client@3.272.0/node_modules/@aws-sdk/smithy-client/dist-cjs/get-value-from-text-node.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.getValueFromTextNode = void 0;
    var getValueFromTextNode = (obj) => {
      const textNodeName = "#text";
      for (const key in obj) {
        if (obj.hasOwnProperty(key) && obj[key][textNodeName] !== void 0) {
          obj[key] = obj[key][textNodeName];
        } else if (typeof obj[key] === "object" && obj[key] !== null) {
          obj[key] = (0, exports.getValueFromTextNode)(obj[key]);
        }
      }
      return obj;
    };
    exports.getValueFromTextNode = getValueFromTextNode;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+smithy-client@3.272.0/node_modules/@aws-sdk/smithy-client/dist-cjs/lazy-json.js
var require_lazy_json = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+smithy-client@3.272.0/node_modules/@aws-sdk/smithy-client/dist-cjs/lazy-json.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.LazyJsonString = exports.StringWrapper = void 0;
    var StringWrapper = function() {
      const Class = Object.getPrototypeOf(this).constructor;
      const Constructor = Function.bind.apply(String, [null, ...arguments]);
      const instance = new Constructor();
      Object.setPrototypeOf(instance, Class.prototype);
      return instance;
    };
    exports.StringWrapper = StringWrapper;
    exports.StringWrapper.prototype = Object.create(String.prototype, {
      constructor: {
        value: exports.StringWrapper,
        enumerable: false,
        writable: true,
        configurable: true
      }
    });
    Object.setPrototypeOf(exports.StringWrapper, String);
    var LazyJsonString = class extends exports.StringWrapper {
      deserializeJSON() {
        return JSON.parse(super.toString());
      }
      toJSON() {
        return super.toString();
      }
      static fromObject(object) {
        if (object instanceof LazyJsonString) {
          return object;
        } else if (object instanceof String || typeof object === "string") {
          return new LazyJsonString(object);
        }
        return new LazyJsonString(JSON.stringify(object));
      }
    };
    exports.LazyJsonString = LazyJsonString;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+smithy-client@3.272.0/node_modules/@aws-sdk/smithy-client/dist-cjs/object-mapping.js
var require_object_mapping = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+smithy-client@3.272.0/node_modules/@aws-sdk/smithy-client/dist-cjs/object-mapping.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.convertMap = exports.map = void 0;
    function map(arg0, arg1, arg2) {
      let target;
      let filter2;
      let instructions;
      if (typeof arg1 === "undefined" && typeof arg2 === "undefined") {
        target = {};
        instructions = arg0;
      } else {
        target = arg0;
        if (typeof arg1 === "function") {
          filter2 = arg1;
          instructions = arg2;
          return mapWithFilter(target, filter2, instructions);
        } else {
          instructions = arg1;
        }
      }
      for (const key of Object.keys(instructions)) {
        if (!Array.isArray(instructions[key])) {
          target[key] = instructions[key];
          continue;
        }
        let [filter3, value] = instructions[key];
        if (typeof value === "function") {
          let _value;
          const defaultFilterPassed = filter3 === void 0 && (_value = value()) != null;
          const customFilterPassed = typeof filter3 === "function" && !!filter3(void 0) || typeof filter3 !== "function" && !!filter3;
          if (defaultFilterPassed) {
            target[key] = _value;
          } else if (customFilterPassed) {
            target[key] = value();
          }
        } else {
          const defaultFilterPassed = filter3 === void 0 && value != null;
          const customFilterPassed = typeof filter3 === "function" && !!filter3(value) || typeof filter3 !== "function" && !!filter3;
          if (defaultFilterPassed || customFilterPassed) {
            target[key] = value;
          }
        }
      }
      return target;
    }
    exports.map = map;
    var convertMap = (target) => {
      const output = {};
      for (const [k, v] of Object.entries(target || {})) {
        output[k] = [, v];
      }
      return output;
    };
    exports.convertMap = convertMap;
    var mapWithFilter = (target, filter2, instructions) => {
      return map(target, Object.entries(instructions).reduce((_instructions, [key, value]) => {
        if (Array.isArray(value)) {
          _instructions[key] = value;
        } else {
          if (typeof value === "function") {
            _instructions[key] = [filter2, value()];
          } else {
            _instructions[key] = [filter2, value];
          }
        }
        return _instructions;
      }, {}));
    };
  }
});

// ../../node_modules/.pnpm/@aws-sdk+smithy-client@3.272.0/node_modules/@aws-sdk/smithy-client/dist-cjs/resolve-path.js
var require_resolve_path = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+smithy-client@3.272.0/node_modules/@aws-sdk/smithy-client/dist-cjs/resolve-path.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.resolvedPath = void 0;
    var extended_encode_uri_component_1 = require_extended_encode_uri_component();
    var resolvedPath = (resolvedPath2, input, memberName, labelValueProvider, uriLabel, isGreedyLabel) => {
      if (input != null && input[memberName] !== void 0) {
        const labelValue = labelValueProvider();
        if (labelValue.length <= 0) {
          throw new Error("Empty value provided for input HTTP label: " + memberName + ".");
        }
        resolvedPath2 = resolvedPath2.replace(uriLabel, isGreedyLabel ? labelValue.split("/").map((segment) => (0, extended_encode_uri_component_1.extendedEncodeURIComponent)(segment)).join("/") : (0, extended_encode_uri_component_1.extendedEncodeURIComponent)(labelValue));
      } else {
        throw new Error("No value provided for input HTTP label: " + memberName + ".");
      }
      return resolvedPath2;
    };
    exports.resolvedPath = resolvedPath;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+smithy-client@3.272.0/node_modules/@aws-sdk/smithy-client/dist-cjs/ser-utils.js
var require_ser_utils = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+smithy-client@3.272.0/node_modules/@aws-sdk/smithy-client/dist-cjs/ser-utils.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.serializeFloat = void 0;
    var serializeFloat = (value) => {
      if (value !== value) {
        return "NaN";
      }
      switch (value) {
        case Infinity:
          return "Infinity";
        case -Infinity:
          return "-Infinity";
        default:
          return value;
      }
    };
    exports.serializeFloat = serializeFloat;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+smithy-client@3.272.0/node_modules/@aws-sdk/smithy-client/dist-cjs/split-every.js
var require_split_every = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+smithy-client@3.272.0/node_modules/@aws-sdk/smithy-client/dist-cjs/split-every.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.splitEvery = void 0;
    function splitEvery(value, delimiter, numDelimiters) {
      if (numDelimiters <= 0 || !Number.isInteger(numDelimiters)) {
        throw new Error("Invalid number of delimiters (" + numDelimiters + ") for splitEvery.");
      }
      const segments = value.split(delimiter);
      if (numDelimiters === 1) {
        return segments;
      }
      const compoundSegments = [];
      let currentSegment = "";
      for (let i = 0; i < segments.length; i++) {
        if (currentSegment === "") {
          currentSegment = segments[i];
        } else {
          currentSegment += delimiter + segments[i];
        }
        if ((i + 1) % numDelimiters === 0) {
          compoundSegments.push(currentSegment);
          currentSegment = "";
        }
      }
      if (currentSegment !== "") {
        compoundSegments.push(currentSegment);
      }
      return compoundSegments;
    }
    exports.splitEvery = splitEvery;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+smithy-client@3.272.0/node_modules/@aws-sdk/smithy-client/dist-cjs/index.js
var require_dist_cjs7 = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+smithy-client@3.272.0/node_modules/@aws-sdk/smithy-client/dist-cjs/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    var tslib_1 = (init_tslib_es6(), __toCommonJS(tslib_es6_exports));
    tslib_1.__exportStar(require_NoOpLogger(), exports);
    tslib_1.__exportStar(require_client(), exports);
    tslib_1.__exportStar(require_command(), exports);
    tslib_1.__exportStar(require_constants(), exports);
    tslib_1.__exportStar(require_date_utils(), exports);
    tslib_1.__exportStar(require_default_error_handler(), exports);
    tslib_1.__exportStar(require_defaults_mode(), exports);
    tslib_1.__exportStar(require_emitWarningIfUnsupportedVersion(), exports);
    tslib_1.__exportStar(require_exceptions(), exports);
    tslib_1.__exportStar(require_extended_encode_uri_component(), exports);
    tslib_1.__exportStar(require_get_array_if_single_item(), exports);
    tslib_1.__exportStar(require_get_value_from_text_node(), exports);
    tslib_1.__exportStar(require_lazy_json(), exports);
    tslib_1.__exportStar(require_object_mapping(), exports);
    tslib_1.__exportStar(require_parse_utils(), exports);
    tslib_1.__exportStar(require_resolve_path(), exports);
    tslib_1.__exportStar(require_ser_utils(), exports);
    tslib_1.__exportStar(require_split_every(), exports);
  }
});

// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/models/S3ServiceException.js
var require_S3ServiceException = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/models/S3ServiceException.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.S3ServiceException = void 0;
    var smithy_client_1 = require_dist_cjs7();
    var S3ServiceException = class extends smithy_client_1.ServiceException {
      constructor(options) {
        super(options);
        Object.setPrototypeOf(this, S3ServiceException.prototype);
      }
    };
    exports.S3ServiceException = S3ServiceException;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/models/models_0.js
var require_models_0 = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/models/models_0.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.ChecksumMode = exports.ReplicationStatus = exports.Protocol = exports.BucketVersioningStatus = exports.MFADeleteStatus = exports.Payer = exports.ReplicationRuleStatus = exports.SseKmsEncryptedObjectsStatus = exports.ReplicaModificationsStatus = exports.ReplicationRuleFilter = exports.ExistingObjectReplicationStatus = exports.ReplicationTimeStatus = exports.MetricsStatus = exports.DeleteMarkerReplicationStatus = exports.FilterRuleName = exports.MetricsFilter = exports.BucketLogsPermission = exports.ExpirationStatus = exports.TransitionStorageClass = exports.LifecycleRuleFilter = exports.InventoryFrequency = exports.InventoryOptionalField = exports.InventoryIncludedObjectVersions = exports.InventoryFormat = exports.IntelligentTieringAccessTier = exports.IntelligentTieringStatus = exports.StorageClassAnalysisSchemaVersion = exports.AnalyticsS3ExportFileFormat = exports.AnalyticsFilter = exports.ObjectOwnership = exports.BucketLocationConstraint = exports.BucketCannedACL = exports.BucketAlreadyOwnedByYou = exports.BucketAlreadyExists = exports.ObjectNotInActiveTierError = exports.TaggingDirective = exports.StorageClass = exports.ObjectLockMode = exports.ObjectLockLegalHoldStatus = exports.MetadataDirective = exports.ChecksumAlgorithm = exports.ObjectCannedACL = exports.ServerSideEncryption = exports.OwnerOverride = exports.Permission = exports.Type = exports.BucketAccelerateStatus = exports.NoSuchUpload = exports.RequestPayer = exports.RequestCharged = void 0;
    exports._ErrorFilterSensitiveLog = exports.DeletedObjectFilterSensitiveLog = exports.DeleteObjectRequestFilterSensitiveLog = exports.DeleteObjectOutputFilterSensitiveLog = exports.DeleteBucketWebsiteRequestFilterSensitiveLog = exports.DeleteBucketTaggingRequestFilterSensitiveLog = exports.DeleteBucketReplicationRequestFilterSensitiveLog = exports.DeleteBucketPolicyRequestFilterSensitiveLog = exports.DeleteBucketOwnershipControlsRequestFilterSensitiveLog = exports.DeleteBucketMetricsConfigurationRequestFilterSensitiveLog = exports.DeleteBucketLifecycleRequestFilterSensitiveLog = exports.DeleteBucketInventoryConfigurationRequestFilterSensitiveLog = exports.DeleteBucketIntelligentTieringConfigurationRequestFilterSensitiveLog = exports.DeleteBucketEncryptionRequestFilterSensitiveLog = exports.DeleteBucketCorsRequestFilterSensitiveLog = exports.DeleteBucketAnalyticsConfigurationRequestFilterSensitiveLog = exports.DeleteBucketRequestFilterSensitiveLog = exports.CreateMultipartUploadRequestFilterSensitiveLog = exports.CreateMultipartUploadOutputFilterSensitiveLog = exports.CreateBucketRequestFilterSensitiveLog = exports.CreateBucketConfigurationFilterSensitiveLog = exports.CreateBucketOutputFilterSensitiveLog = exports.CopyObjectRequestFilterSensitiveLog = exports.CopyObjectOutputFilterSensitiveLog = exports.CopyObjectResultFilterSensitiveLog = exports.CompleteMultipartUploadRequestFilterSensitiveLog = exports.CompletedMultipartUploadFilterSensitiveLog = exports.CompletedPartFilterSensitiveLog = exports.CompleteMultipartUploadOutputFilterSensitiveLog = exports.AccessControlTranslationFilterSensitiveLog = exports.AccessControlPolicyFilterSensitiveLog = exports.OwnerFilterSensitiveLog = exports.GrantFilterSensitiveLog = exports.GranteeFilterSensitiveLog = exports.AccelerateConfigurationFilterSensitiveLog = exports.AbortMultipartUploadRequestFilterSensitiveLog = exports.AbortMultipartUploadOutputFilterSensitiveLog = exports.AbortIncompleteMultipartUploadFilterSensitiveLog = exports.MFADelete = exports.ObjectVersionStorageClass = exports.NoSuchBucket = exports.ObjectStorageClass = exports.EncodingType = exports.ArchiveStatus = exports.NotFound = exports.ObjectLockRetentionMode = exports.ObjectLockEnabled = exports.ObjectAttributes = exports.NoSuchKey = exports.InvalidObjectState = void 0;
    exports.NoncurrentVersionTransitionFilterSensitiveLog = exports.NoncurrentVersionExpirationFilterSensitiveLog = exports.LifecycleRuleFilterFilterSensitiveLog = exports.LifecycleRuleAndOperatorFilterSensitiveLog = exports.LifecycleExpirationFilterSensitiveLog = exports.GetBucketInventoryConfigurationRequestFilterSensitiveLog = exports.GetBucketInventoryConfigurationOutputFilterSensitiveLog = exports.InventoryConfigurationFilterSensitiveLog = exports.InventoryScheduleFilterSensitiveLog = exports.InventoryFilterFilterSensitiveLog = exports.InventoryDestinationFilterSensitiveLog = exports.InventoryS3BucketDestinationFilterSensitiveLog = exports.InventoryEncryptionFilterSensitiveLog = exports.SSES3FilterSensitiveLog = exports.SSEKMSFilterSensitiveLog = exports.GetBucketIntelligentTieringConfigurationRequestFilterSensitiveLog = exports.GetBucketIntelligentTieringConfigurationOutputFilterSensitiveLog = exports.IntelligentTieringConfigurationFilterSensitiveLog = exports.TieringFilterSensitiveLog = exports.IntelligentTieringFilterFilterSensitiveLog = exports.IntelligentTieringAndOperatorFilterSensitiveLog = exports.GetBucketEncryptionRequestFilterSensitiveLog = exports.GetBucketEncryptionOutputFilterSensitiveLog = exports.ServerSideEncryptionConfigurationFilterSensitiveLog = exports.ServerSideEncryptionRuleFilterSensitiveLog = exports.ServerSideEncryptionByDefaultFilterSensitiveLog = exports.GetBucketCorsRequestFilterSensitiveLog = exports.GetBucketCorsOutputFilterSensitiveLog = exports.CORSRuleFilterSensitiveLog = exports.GetBucketAnalyticsConfigurationRequestFilterSensitiveLog = exports.GetBucketAnalyticsConfigurationOutputFilterSensitiveLog = exports.AnalyticsConfigurationFilterSensitiveLog = exports.StorageClassAnalysisFilterSensitiveLog = exports.StorageClassAnalysisDataExportFilterSensitiveLog = exports.AnalyticsExportDestinationFilterSensitiveLog = exports.AnalyticsS3BucketDestinationFilterSensitiveLog = exports.AnalyticsFilterFilterSensitiveLog = exports.AnalyticsAndOperatorFilterSensitiveLog = exports.TagFilterSensitiveLog = exports.GetBucketAclRequestFilterSensitiveLog = exports.GetBucketAclOutputFilterSensitiveLog = exports.GetBucketAccelerateConfigurationRequestFilterSensitiveLog = exports.GetBucketAccelerateConfigurationOutputFilterSensitiveLog = exports.DeletePublicAccessBlockRequestFilterSensitiveLog = exports.DeleteObjectTaggingRequestFilterSensitiveLog = exports.DeleteObjectTaggingOutputFilterSensitiveLog = exports.DeleteObjectsRequestFilterSensitiveLog = exports.DeleteFilterSensitiveLog = exports.ObjectIdentifierFilterSensitiveLog = exports.DeleteObjectsOutputFilterSensitiveLog = void 0;
    exports.GetBucketRequestPaymentOutputFilterSensitiveLog = exports.GetBucketReplicationRequestFilterSensitiveLog = exports.GetBucketReplicationOutputFilterSensitiveLog = exports.ReplicationConfigurationFilterSensitiveLog = exports.ReplicationRuleFilterSensitiveLog = exports.SourceSelectionCriteriaFilterSensitiveLog = exports.SseKmsEncryptedObjectsFilterSensitiveLog = exports.ReplicaModificationsFilterSensitiveLog = exports.ReplicationRuleFilterFilterSensitiveLog = exports.ReplicationRuleAndOperatorFilterSensitiveLog = exports.ExistingObjectReplicationFilterSensitiveLog = exports.DestinationFilterSensitiveLog = exports.ReplicationTimeFilterSensitiveLog = exports.MetricsFilterSensitiveLog = exports.ReplicationTimeValueFilterSensitiveLog = exports.EncryptionConfigurationFilterSensitiveLog = exports.DeleteMarkerReplicationFilterSensitiveLog = exports.GetBucketPolicyStatusRequestFilterSensitiveLog = exports.GetBucketPolicyStatusOutputFilterSensitiveLog = exports.PolicyStatusFilterSensitiveLog = exports.GetBucketPolicyRequestFilterSensitiveLog = exports.GetBucketPolicyOutputFilterSensitiveLog = exports.GetBucketOwnershipControlsRequestFilterSensitiveLog = exports.GetBucketOwnershipControlsOutputFilterSensitiveLog = exports.OwnershipControlsFilterSensitiveLog = exports.OwnershipControlsRuleFilterSensitiveLog = exports.NotificationConfigurationFilterSensitiveLog = exports.TopicConfigurationFilterSensitiveLog = exports.QueueConfigurationFilterSensitiveLog = exports.LambdaFunctionConfigurationFilterSensitiveLog = exports.NotificationConfigurationFilterFilterSensitiveLog = exports.S3KeyFilterFilterSensitiveLog = exports.FilterRuleFilterSensitiveLog = exports.EventBridgeConfigurationFilterSensitiveLog = exports.GetBucketNotificationConfigurationRequestFilterSensitiveLog = exports.GetBucketMetricsConfigurationRequestFilterSensitiveLog = exports.GetBucketMetricsConfigurationOutputFilterSensitiveLog = exports.MetricsConfigurationFilterSensitiveLog = exports.MetricsFilterFilterSensitiveLog = exports.MetricsAndOperatorFilterSensitiveLog = exports.GetBucketLoggingRequestFilterSensitiveLog = exports.GetBucketLoggingOutputFilterSensitiveLog = exports.LoggingEnabledFilterSensitiveLog = exports.TargetGrantFilterSensitiveLog = exports.GetBucketLocationRequestFilterSensitiveLog = exports.GetBucketLocationOutputFilterSensitiveLog = exports.GetBucketLifecycleConfigurationRequestFilterSensitiveLog = exports.GetBucketLifecycleConfigurationOutputFilterSensitiveLog = exports.LifecycleRuleFilterSensitiveLog = exports.TransitionFilterSensitiveLog = void 0;
    exports.ListBucketMetricsConfigurationsOutputFilterSensitiveLog = exports.ListBucketInventoryConfigurationsRequestFilterSensitiveLog = exports.ListBucketInventoryConfigurationsOutputFilterSensitiveLog = exports.ListBucketIntelligentTieringConfigurationsRequestFilterSensitiveLog = exports.ListBucketIntelligentTieringConfigurationsOutputFilterSensitiveLog = exports.ListBucketAnalyticsConfigurationsRequestFilterSensitiveLog = exports.ListBucketAnalyticsConfigurationsOutputFilterSensitiveLog = exports.HeadObjectRequestFilterSensitiveLog = exports.HeadObjectOutputFilterSensitiveLog = exports.HeadBucketRequestFilterSensitiveLog = exports.GetPublicAccessBlockRequestFilterSensitiveLog = exports.GetPublicAccessBlockOutputFilterSensitiveLog = exports.PublicAccessBlockConfigurationFilterSensitiveLog = exports.GetObjectTorrentRequestFilterSensitiveLog = exports.GetObjectTorrentOutputFilterSensitiveLog = exports.GetObjectTaggingRequestFilterSensitiveLog = exports.GetObjectTaggingOutputFilterSensitiveLog = exports.GetObjectRetentionRequestFilterSensitiveLog = exports.GetObjectRetentionOutputFilterSensitiveLog = exports.ObjectLockRetentionFilterSensitiveLog = exports.GetObjectLockConfigurationRequestFilterSensitiveLog = exports.GetObjectLockConfigurationOutputFilterSensitiveLog = exports.ObjectLockConfigurationFilterSensitiveLog = exports.ObjectLockRuleFilterSensitiveLog = exports.DefaultRetentionFilterSensitiveLog = exports.GetObjectLegalHoldRequestFilterSensitiveLog = exports.GetObjectLegalHoldOutputFilterSensitiveLog = exports.ObjectLockLegalHoldFilterSensitiveLog = exports.GetObjectAttributesRequestFilterSensitiveLog = exports.GetObjectAttributesOutputFilterSensitiveLog = exports.GetObjectAttributesPartsFilterSensitiveLog = exports.ObjectPartFilterSensitiveLog = exports.ChecksumFilterSensitiveLog = exports.GetObjectAclRequestFilterSensitiveLog = exports.GetObjectAclOutputFilterSensitiveLog = exports.GetObjectRequestFilterSensitiveLog = exports.GetObjectOutputFilterSensitiveLog = exports.GetBucketWebsiteRequestFilterSensitiveLog = exports.GetBucketWebsiteOutputFilterSensitiveLog = exports.RoutingRuleFilterSensitiveLog = exports.RedirectFilterSensitiveLog = exports.ConditionFilterSensitiveLog = exports.RedirectAllRequestsToFilterSensitiveLog = exports.IndexDocumentFilterSensitiveLog = exports.ErrorDocumentFilterSensitiveLog = exports.GetBucketVersioningRequestFilterSensitiveLog = exports.GetBucketVersioningOutputFilterSensitiveLog = exports.GetBucketTaggingRequestFilterSensitiveLog = exports.GetBucketTaggingOutputFilterSensitiveLog = exports.GetBucketRequestPaymentRequestFilterSensitiveLog = void 0;
    exports.PutObjectLegalHoldOutputFilterSensitiveLog = exports.PutObjectAclRequestFilterSensitiveLog = exports.PutObjectAclOutputFilterSensitiveLog = exports.PutObjectRequestFilterSensitiveLog = exports.PutObjectOutputFilterSensitiveLog = exports.PutBucketWebsiteRequestFilterSensitiveLog = exports.WebsiteConfigurationFilterSensitiveLog = exports.PutBucketVersioningRequestFilterSensitiveLog = exports.VersioningConfigurationFilterSensitiveLog = exports.PutBucketTaggingRequestFilterSensitiveLog = exports.TaggingFilterSensitiveLog = exports.PutBucketRequestPaymentRequestFilterSensitiveLog = exports.RequestPaymentConfigurationFilterSensitiveLog = exports.PutBucketReplicationRequestFilterSensitiveLog = exports.PutBucketPolicyRequestFilterSensitiveLog = exports.PutBucketOwnershipControlsRequestFilterSensitiveLog = exports.PutBucketNotificationConfigurationRequestFilterSensitiveLog = exports.PutBucketMetricsConfigurationRequestFilterSensitiveLog = exports.PutBucketLoggingRequestFilterSensitiveLog = exports.BucketLoggingStatusFilterSensitiveLog = exports.PutBucketLifecycleConfigurationRequestFilterSensitiveLog = exports.BucketLifecycleConfigurationFilterSensitiveLog = exports.PutBucketInventoryConfigurationRequestFilterSensitiveLog = exports.PutBucketIntelligentTieringConfigurationRequestFilterSensitiveLog = exports.PutBucketEncryptionRequestFilterSensitiveLog = exports.PutBucketCorsRequestFilterSensitiveLog = exports.CORSConfigurationFilterSensitiveLog = exports.PutBucketAnalyticsConfigurationRequestFilterSensitiveLog = exports.PutBucketAclRequestFilterSensitiveLog = exports.PutBucketAccelerateConfigurationRequestFilterSensitiveLog = exports.ListPartsRequestFilterSensitiveLog = exports.ListPartsOutputFilterSensitiveLog = exports.PartFilterSensitiveLog = exports.ListObjectVersionsRequestFilterSensitiveLog = exports.ListObjectVersionsOutputFilterSensitiveLog = exports.ObjectVersionFilterSensitiveLog = exports.DeleteMarkerEntryFilterSensitiveLog = exports.ListObjectsV2RequestFilterSensitiveLog = exports.ListObjectsV2OutputFilterSensitiveLog = exports.ListObjectsRequestFilterSensitiveLog = exports.ListObjectsOutputFilterSensitiveLog = exports._ObjectFilterSensitiveLog = exports.ListMultipartUploadsRequestFilterSensitiveLog = exports.ListMultipartUploadsOutputFilterSensitiveLog = exports.MultipartUploadFilterSensitiveLog = exports.InitiatorFilterSensitiveLog = exports.CommonPrefixFilterSensitiveLog = exports.ListBucketsOutputFilterSensitiveLog = exports.BucketFilterSensitiveLog = exports.ListBucketMetricsConfigurationsRequestFilterSensitiveLog = void 0;
    exports.PutObjectLockConfigurationRequestFilterSensitiveLog = exports.PutObjectLockConfigurationOutputFilterSensitiveLog = exports.PutObjectLegalHoldRequestFilterSensitiveLog = void 0;
    var smithy_client_1 = require_dist_cjs7();
    var S3ServiceException_1 = require_S3ServiceException();
    var RequestCharged;
    (function(RequestCharged2) {
      RequestCharged2["requester"] = "requester";
    })(RequestCharged = exports.RequestCharged || (exports.RequestCharged = {}));
    var RequestPayer;
    (function(RequestPayer2) {
      RequestPayer2["requester"] = "requester";
    })(RequestPayer = exports.RequestPayer || (exports.RequestPayer = {}));
    var NoSuchUpload = class extends S3ServiceException_1.S3ServiceException {
      constructor(opts) {
        super({
          name: "NoSuchUpload",
          $fault: "client",
          ...opts
        });
        this.name = "NoSuchUpload";
        this.$fault = "client";
        Object.setPrototypeOf(this, NoSuchUpload.prototype);
      }
    };
    exports.NoSuchUpload = NoSuchUpload;
    var BucketAccelerateStatus;
    (function(BucketAccelerateStatus2) {
      BucketAccelerateStatus2["Enabled"] = "Enabled";
      BucketAccelerateStatus2["Suspended"] = "Suspended";
    })(BucketAccelerateStatus = exports.BucketAccelerateStatus || (exports.BucketAccelerateStatus = {}));
    var Type;
    (function(Type2) {
      Type2["AmazonCustomerByEmail"] = "AmazonCustomerByEmail";
      Type2["CanonicalUser"] = "CanonicalUser";
      Type2["Group"] = "Group";
    })(Type = exports.Type || (exports.Type = {}));
    var Permission;
    (function(Permission2) {
      Permission2["FULL_CONTROL"] = "FULL_CONTROL";
      Permission2["READ"] = "READ";
      Permission2["READ_ACP"] = "READ_ACP";
      Permission2["WRITE"] = "WRITE";
      Permission2["WRITE_ACP"] = "WRITE_ACP";
    })(Permission = exports.Permission || (exports.Permission = {}));
    var OwnerOverride;
    (function(OwnerOverride2) {
      OwnerOverride2["Destination"] = "Destination";
    })(OwnerOverride = exports.OwnerOverride || (exports.OwnerOverride = {}));
    var ServerSideEncryption;
    (function(ServerSideEncryption2) {
      ServerSideEncryption2["AES256"] = "AES256";
      ServerSideEncryption2["aws_kms"] = "aws:kms";
    })(ServerSideEncryption = exports.ServerSideEncryption || (exports.ServerSideEncryption = {}));
    var ObjectCannedACL;
    (function(ObjectCannedACL2) {
      ObjectCannedACL2["authenticated_read"] = "authenticated-read";
      ObjectCannedACL2["aws_exec_read"] = "aws-exec-read";
      ObjectCannedACL2["bucket_owner_full_control"] = "bucket-owner-full-control";
      ObjectCannedACL2["bucket_owner_read"] = "bucket-owner-read";
      ObjectCannedACL2["private"] = "private";
      ObjectCannedACL2["public_read"] = "public-read";
      ObjectCannedACL2["public_read_write"] = "public-read-write";
    })(ObjectCannedACL = exports.ObjectCannedACL || (exports.ObjectCannedACL = {}));
    var ChecksumAlgorithm;
    (function(ChecksumAlgorithm2) {
      ChecksumAlgorithm2["CRC32"] = "CRC32";
      ChecksumAlgorithm2["CRC32C"] = "CRC32C";
      ChecksumAlgorithm2["SHA1"] = "SHA1";
      ChecksumAlgorithm2["SHA256"] = "SHA256";
    })(ChecksumAlgorithm = exports.ChecksumAlgorithm || (exports.ChecksumAlgorithm = {}));
    var MetadataDirective;
    (function(MetadataDirective2) {
      MetadataDirective2["COPY"] = "COPY";
      MetadataDirective2["REPLACE"] = "REPLACE";
    })(MetadataDirective = exports.MetadataDirective || (exports.MetadataDirective = {}));
    var ObjectLockLegalHoldStatus;
    (function(ObjectLockLegalHoldStatus2) {
      ObjectLockLegalHoldStatus2["OFF"] = "OFF";
      ObjectLockLegalHoldStatus2["ON"] = "ON";
    })(ObjectLockLegalHoldStatus = exports.ObjectLockLegalHoldStatus || (exports.ObjectLockLegalHoldStatus = {}));
    var ObjectLockMode;
    (function(ObjectLockMode2) {
      ObjectLockMode2["COMPLIANCE"] = "COMPLIANCE";
      ObjectLockMode2["GOVERNANCE"] = "GOVERNANCE";
    })(ObjectLockMode = exports.ObjectLockMode || (exports.ObjectLockMode = {}));
    var StorageClass;
    (function(StorageClass2) {
      StorageClass2["DEEP_ARCHIVE"] = "DEEP_ARCHIVE";
      StorageClass2["GLACIER"] = "GLACIER";
      StorageClass2["GLACIER_IR"] = "GLACIER_IR";
      StorageClass2["INTELLIGENT_TIERING"] = "INTELLIGENT_TIERING";
      StorageClass2["ONEZONE_IA"] = "ONEZONE_IA";
      StorageClass2["OUTPOSTS"] = "OUTPOSTS";
      StorageClass2["REDUCED_REDUNDANCY"] = "REDUCED_REDUNDANCY";
      StorageClass2["STANDARD"] = "STANDARD";
      StorageClass2["STANDARD_IA"] = "STANDARD_IA";
    })(StorageClass = exports.StorageClass || (exports.StorageClass = {}));
    var TaggingDirective;
    (function(TaggingDirective2) {
      TaggingDirective2["COPY"] = "COPY";
      TaggingDirective2["REPLACE"] = "REPLACE";
    })(TaggingDirective = exports.TaggingDirective || (exports.TaggingDirective = {}));
    var ObjectNotInActiveTierError = class extends S3ServiceException_1.S3ServiceException {
      constructor(opts) {
        super({
          name: "ObjectNotInActiveTierError",
          $fault: "client",
          ...opts
        });
        this.name = "ObjectNotInActiveTierError";
        this.$fault = "client";
        Object.setPrototypeOf(this, ObjectNotInActiveTierError.prototype);
      }
    };
    exports.ObjectNotInActiveTierError = ObjectNotInActiveTierError;
    var BucketAlreadyExists = class extends S3ServiceException_1.S3ServiceException {
      constructor(opts) {
        super({
          name: "BucketAlreadyExists",
          $fault: "client",
          ...opts
        });
        this.name = "BucketAlreadyExists";
        this.$fault = "client";
        Object.setPrototypeOf(this, BucketAlreadyExists.prototype);
      }
    };
    exports.BucketAlreadyExists = BucketAlreadyExists;
    var BucketAlreadyOwnedByYou = class extends S3ServiceException_1.S3ServiceException {
      constructor(opts) {
        super({
          name: "BucketAlreadyOwnedByYou",
          $fault: "client",
          ...opts
        });
        this.name = "BucketAlreadyOwnedByYou";
        this.$fault = "client";
        Object.setPrototypeOf(this, BucketAlreadyOwnedByYou.prototype);
      }
    };
    exports.BucketAlreadyOwnedByYou = BucketAlreadyOwnedByYou;
    var BucketCannedACL;
    (function(BucketCannedACL2) {
      BucketCannedACL2["authenticated_read"] = "authenticated-read";
      BucketCannedACL2["private"] = "private";
      BucketCannedACL2["public_read"] = "public-read";
      BucketCannedACL2["public_read_write"] = "public-read-write";
    })(BucketCannedACL = exports.BucketCannedACL || (exports.BucketCannedACL = {}));
    var BucketLocationConstraint;
    (function(BucketLocationConstraint2) {
      BucketLocationConstraint2["EU"] = "EU";
      BucketLocationConstraint2["af_south_1"] = "af-south-1";
      BucketLocationConstraint2["ap_east_1"] = "ap-east-1";
      BucketLocationConstraint2["ap_northeast_1"] = "ap-northeast-1";
      BucketLocationConstraint2["ap_northeast_2"] = "ap-northeast-2";
      BucketLocationConstraint2["ap_northeast_3"] = "ap-northeast-3";
      BucketLocationConstraint2["ap_south_1"] = "ap-south-1";
      BucketLocationConstraint2["ap_southeast_1"] = "ap-southeast-1";
      BucketLocationConstraint2["ap_southeast_2"] = "ap-southeast-2";
      BucketLocationConstraint2["ap_southeast_3"] = "ap-southeast-3";
      BucketLocationConstraint2["ca_central_1"] = "ca-central-1";
      BucketLocationConstraint2["cn_north_1"] = "cn-north-1";
      BucketLocationConstraint2["cn_northwest_1"] = "cn-northwest-1";
      BucketLocationConstraint2["eu_central_1"] = "eu-central-1";
      BucketLocationConstraint2["eu_north_1"] = "eu-north-1";
      BucketLocationConstraint2["eu_south_1"] = "eu-south-1";
      BucketLocationConstraint2["eu_west_1"] = "eu-west-1";
      BucketLocationConstraint2["eu_west_2"] = "eu-west-2";
      BucketLocationConstraint2["eu_west_3"] = "eu-west-3";
      BucketLocationConstraint2["me_south_1"] = "me-south-1";
      BucketLocationConstraint2["sa_east_1"] = "sa-east-1";
      BucketLocationConstraint2["us_east_2"] = "us-east-2";
      BucketLocationConstraint2["us_gov_east_1"] = "us-gov-east-1";
      BucketLocationConstraint2["us_gov_west_1"] = "us-gov-west-1";
      BucketLocationConstraint2["us_west_1"] = "us-west-1";
      BucketLocationConstraint2["us_west_2"] = "us-west-2";
    })(BucketLocationConstraint = exports.BucketLocationConstraint || (exports.BucketLocationConstraint = {}));
    var ObjectOwnership;
    (function(ObjectOwnership2) {
      ObjectOwnership2["BucketOwnerEnforced"] = "BucketOwnerEnforced";
      ObjectOwnership2["BucketOwnerPreferred"] = "BucketOwnerPreferred";
      ObjectOwnership2["ObjectWriter"] = "ObjectWriter";
    })(ObjectOwnership = exports.ObjectOwnership || (exports.ObjectOwnership = {}));
    var AnalyticsFilter;
    (function(AnalyticsFilter2) {
      AnalyticsFilter2.visit = (value, visitor) => {
        if (value.Prefix !== void 0)
          return visitor.Prefix(value.Prefix);
        if (value.Tag !== void 0)
          return visitor.Tag(value.Tag);
        if (value.And !== void 0)
          return visitor.And(value.And);
        return visitor._(value.$unknown[0], value.$unknown[1]);
      };
    })(AnalyticsFilter = exports.AnalyticsFilter || (exports.AnalyticsFilter = {}));
    var AnalyticsS3ExportFileFormat;
    (function(AnalyticsS3ExportFileFormat2) {
      AnalyticsS3ExportFileFormat2["CSV"] = "CSV";
    })(AnalyticsS3ExportFileFormat = exports.AnalyticsS3ExportFileFormat || (exports.AnalyticsS3ExportFileFormat = {}));
    var StorageClassAnalysisSchemaVersion;
    (function(StorageClassAnalysisSchemaVersion2) {
      StorageClassAnalysisSchemaVersion2["V_1"] = "V_1";
    })(StorageClassAnalysisSchemaVersion = exports.StorageClassAnalysisSchemaVersion || (exports.StorageClassAnalysisSchemaVersion = {}));
    var IntelligentTieringStatus;
    (function(IntelligentTieringStatus2) {
      IntelligentTieringStatus2["Disabled"] = "Disabled";
      IntelligentTieringStatus2["Enabled"] = "Enabled";
    })(IntelligentTieringStatus = exports.IntelligentTieringStatus || (exports.IntelligentTieringStatus = {}));
    var IntelligentTieringAccessTier;
    (function(IntelligentTieringAccessTier2) {
      IntelligentTieringAccessTier2["ARCHIVE_ACCESS"] = "ARCHIVE_ACCESS";
      IntelligentTieringAccessTier2["DEEP_ARCHIVE_ACCESS"] = "DEEP_ARCHIVE_ACCESS";
    })(IntelligentTieringAccessTier = exports.IntelligentTieringAccessTier || (exports.IntelligentTieringAccessTier = {}));
    var InventoryFormat;
    (function(InventoryFormat2) {
      InventoryFormat2["CSV"] = "CSV";
      InventoryFormat2["ORC"] = "ORC";
      InventoryFormat2["Parquet"] = "Parquet";
    })(InventoryFormat = exports.InventoryFormat || (exports.InventoryFormat = {}));
    var InventoryIncludedObjectVersions;
    (function(InventoryIncludedObjectVersions2) {
      InventoryIncludedObjectVersions2["All"] = "All";
      InventoryIncludedObjectVersions2["Current"] = "Current";
    })(InventoryIncludedObjectVersions = exports.InventoryIncludedObjectVersions || (exports.InventoryIncludedObjectVersions = {}));
    var InventoryOptionalField;
    (function(InventoryOptionalField2) {
      InventoryOptionalField2["BucketKeyStatus"] = "BucketKeyStatus";
      InventoryOptionalField2["ChecksumAlgorithm"] = "ChecksumAlgorithm";
      InventoryOptionalField2["ETag"] = "ETag";
      InventoryOptionalField2["EncryptionStatus"] = "EncryptionStatus";
      InventoryOptionalField2["IntelligentTieringAccessTier"] = "IntelligentTieringAccessTier";
      InventoryOptionalField2["IsMultipartUploaded"] = "IsMultipartUploaded";
      InventoryOptionalField2["LastModifiedDate"] = "LastModifiedDate";
      InventoryOptionalField2["ObjectLockLegalHoldStatus"] = "ObjectLockLegalHoldStatus";
      InventoryOptionalField2["ObjectLockMode"] = "ObjectLockMode";
      InventoryOptionalField2["ObjectLockRetainUntilDate"] = "ObjectLockRetainUntilDate";
      InventoryOptionalField2["ReplicationStatus"] = "ReplicationStatus";
      InventoryOptionalField2["Size"] = "Size";
      InventoryOptionalField2["StorageClass"] = "StorageClass";
    })(InventoryOptionalField = exports.InventoryOptionalField || (exports.InventoryOptionalField = {}));
    var InventoryFrequency;
    (function(InventoryFrequency2) {
      InventoryFrequency2["Daily"] = "Daily";
      InventoryFrequency2["Weekly"] = "Weekly";
    })(InventoryFrequency = exports.InventoryFrequency || (exports.InventoryFrequency = {}));
    var LifecycleRuleFilter;
    (function(LifecycleRuleFilter2) {
      LifecycleRuleFilter2.visit = (value, visitor) => {
        if (value.Prefix !== void 0)
          return visitor.Prefix(value.Prefix);
        if (value.Tag !== void 0)
          return visitor.Tag(value.Tag);
        if (value.ObjectSizeGreaterThan !== void 0)
          return visitor.ObjectSizeGreaterThan(value.ObjectSizeGreaterThan);
        if (value.ObjectSizeLessThan !== void 0)
          return visitor.ObjectSizeLessThan(value.ObjectSizeLessThan);
        if (value.And !== void 0)
          return visitor.And(value.And);
        return visitor._(value.$unknown[0], value.$unknown[1]);
      };
    })(LifecycleRuleFilter = exports.LifecycleRuleFilter || (exports.LifecycleRuleFilter = {}));
    var TransitionStorageClass;
    (function(TransitionStorageClass2) {
      TransitionStorageClass2["DEEP_ARCHIVE"] = "DEEP_ARCHIVE";
      TransitionStorageClass2["GLACIER"] = "GLACIER";
      TransitionStorageClass2["GLACIER_IR"] = "GLACIER_IR";
      TransitionStorageClass2["INTELLIGENT_TIERING"] = "INTELLIGENT_TIERING";
      TransitionStorageClass2["ONEZONE_IA"] = "ONEZONE_IA";
      TransitionStorageClass2["STANDARD_IA"] = "STANDARD_IA";
    })(TransitionStorageClass = exports.TransitionStorageClass || (exports.TransitionStorageClass = {}));
    var ExpirationStatus;
    (function(ExpirationStatus2) {
      ExpirationStatus2["Disabled"] = "Disabled";
      ExpirationStatus2["Enabled"] = "Enabled";
    })(ExpirationStatus = exports.ExpirationStatus || (exports.ExpirationStatus = {}));
    var BucketLogsPermission;
    (function(BucketLogsPermission2) {
      BucketLogsPermission2["FULL_CONTROL"] = "FULL_CONTROL";
      BucketLogsPermission2["READ"] = "READ";
      BucketLogsPermission2["WRITE"] = "WRITE";
    })(BucketLogsPermission = exports.BucketLogsPermission || (exports.BucketLogsPermission = {}));
    var MetricsFilter;
    (function(MetricsFilter2) {
      MetricsFilter2.visit = (value, visitor) => {
        if (value.Prefix !== void 0)
          return visitor.Prefix(value.Prefix);
        if (value.Tag !== void 0)
          return visitor.Tag(value.Tag);
        if (value.AccessPointArn !== void 0)
          return visitor.AccessPointArn(value.AccessPointArn);
        if (value.And !== void 0)
          return visitor.And(value.And);
        return visitor._(value.$unknown[0], value.$unknown[1]);
      };
    })(MetricsFilter = exports.MetricsFilter || (exports.MetricsFilter = {}));
    var FilterRuleName;
    (function(FilterRuleName2) {
      FilterRuleName2["prefix"] = "prefix";
      FilterRuleName2["suffix"] = "suffix";
    })(FilterRuleName = exports.FilterRuleName || (exports.FilterRuleName = {}));
    var DeleteMarkerReplicationStatus;
    (function(DeleteMarkerReplicationStatus2) {
      DeleteMarkerReplicationStatus2["Disabled"] = "Disabled";
      DeleteMarkerReplicationStatus2["Enabled"] = "Enabled";
    })(DeleteMarkerReplicationStatus = exports.DeleteMarkerReplicationStatus || (exports.DeleteMarkerReplicationStatus = {}));
    var MetricsStatus;
    (function(MetricsStatus2) {
      MetricsStatus2["Disabled"] = "Disabled";
      MetricsStatus2["Enabled"] = "Enabled";
    })(MetricsStatus = exports.MetricsStatus || (exports.MetricsStatus = {}));
    var ReplicationTimeStatus;
    (function(ReplicationTimeStatus2) {
      ReplicationTimeStatus2["Disabled"] = "Disabled";
      ReplicationTimeStatus2["Enabled"] = "Enabled";
    })(ReplicationTimeStatus = exports.ReplicationTimeStatus || (exports.ReplicationTimeStatus = {}));
    var ExistingObjectReplicationStatus;
    (function(ExistingObjectReplicationStatus2) {
      ExistingObjectReplicationStatus2["Disabled"] = "Disabled";
      ExistingObjectReplicationStatus2["Enabled"] = "Enabled";
    })(ExistingObjectReplicationStatus = exports.ExistingObjectReplicationStatus || (exports.ExistingObjectReplicationStatus = {}));
    var ReplicationRuleFilter;
    (function(ReplicationRuleFilter2) {
      ReplicationRuleFilter2.visit = (value, visitor) => {
        if (value.Prefix !== void 0)
          return visitor.Prefix(value.Prefix);
        if (value.Tag !== void 0)
          return visitor.Tag(value.Tag);
        if (value.And !== void 0)
          return visitor.And(value.And);
        return visitor._(value.$unknown[0], value.$unknown[1]);
      };
    })(ReplicationRuleFilter = exports.ReplicationRuleFilter || (exports.ReplicationRuleFilter = {}));
    var ReplicaModificationsStatus;
    (function(ReplicaModificationsStatus2) {
      ReplicaModificationsStatus2["Disabled"] = "Disabled";
      ReplicaModificationsStatus2["Enabled"] = "Enabled";
    })(ReplicaModificationsStatus = exports.ReplicaModificationsStatus || (exports.ReplicaModificationsStatus = {}));
    var SseKmsEncryptedObjectsStatus;
    (function(SseKmsEncryptedObjectsStatus2) {
      SseKmsEncryptedObjectsStatus2["Disabled"] = "Disabled";
      SseKmsEncryptedObjectsStatus2["Enabled"] = "Enabled";
    })(SseKmsEncryptedObjectsStatus = exports.SseKmsEncryptedObjectsStatus || (exports.SseKmsEncryptedObjectsStatus = {}));
    var ReplicationRuleStatus;
    (function(ReplicationRuleStatus2) {
      ReplicationRuleStatus2["Disabled"] = "Disabled";
      ReplicationRuleStatus2["Enabled"] = "Enabled";
    })(ReplicationRuleStatus = exports.ReplicationRuleStatus || (exports.ReplicationRuleStatus = {}));
    var Payer;
    (function(Payer2) {
      Payer2["BucketOwner"] = "BucketOwner";
      Payer2["Requester"] = "Requester";
    })(Payer = exports.Payer || (exports.Payer = {}));
    var MFADeleteStatus;
    (function(MFADeleteStatus2) {
      MFADeleteStatus2["Disabled"] = "Disabled";
      MFADeleteStatus2["Enabled"] = "Enabled";
    })(MFADeleteStatus = exports.MFADeleteStatus || (exports.MFADeleteStatus = {}));
    var BucketVersioningStatus;
    (function(BucketVersioningStatus2) {
      BucketVersioningStatus2["Enabled"] = "Enabled";
      BucketVersioningStatus2["Suspended"] = "Suspended";
    })(BucketVersioningStatus = exports.BucketVersioningStatus || (exports.BucketVersioningStatus = {}));
    var Protocol;
    (function(Protocol2) {
      Protocol2["http"] = "http";
      Protocol2["https"] = "https";
    })(Protocol = exports.Protocol || (exports.Protocol = {}));
    var ReplicationStatus;
    (function(ReplicationStatus2) {
      ReplicationStatus2["COMPLETE"] = "COMPLETE";
      ReplicationStatus2["FAILED"] = "FAILED";
      ReplicationStatus2["PENDING"] = "PENDING";
      ReplicationStatus2["REPLICA"] = "REPLICA";
    })(ReplicationStatus = exports.ReplicationStatus || (exports.ReplicationStatus = {}));
    var ChecksumMode;
    (function(ChecksumMode2) {
      ChecksumMode2["ENABLED"] = "ENABLED";
    })(ChecksumMode = exports.ChecksumMode || (exports.ChecksumMode = {}));
    var InvalidObjectState = class extends S3ServiceException_1.S3ServiceException {
      constructor(opts) {
        super({
          name: "InvalidObjectState",
          $fault: "client",
          ...opts
        });
        this.name = "InvalidObjectState";
        this.$fault = "client";
        Object.setPrototypeOf(this, InvalidObjectState.prototype);
        this.StorageClass = opts.StorageClass;
        this.AccessTier = opts.AccessTier;
      }
    };
    exports.InvalidObjectState = InvalidObjectState;
    var NoSuchKey = class extends S3ServiceException_1.S3ServiceException {
      constructor(opts) {
        super({
          name: "NoSuchKey",
          $fault: "client",
          ...opts
        });
        this.name = "NoSuchKey";
        this.$fault = "client";
        Object.setPrototypeOf(this, NoSuchKey.prototype);
      }
    };
    exports.NoSuchKey = NoSuchKey;
    var ObjectAttributes;
    (function(ObjectAttributes2) {
      ObjectAttributes2["CHECKSUM"] = "Checksum";
      ObjectAttributes2["ETAG"] = "ETag";
      ObjectAttributes2["OBJECT_PARTS"] = "ObjectParts";
      ObjectAttributes2["OBJECT_SIZE"] = "ObjectSize";
      ObjectAttributes2["STORAGE_CLASS"] = "StorageClass";
    })(ObjectAttributes = exports.ObjectAttributes || (exports.ObjectAttributes = {}));
    var ObjectLockEnabled;
    (function(ObjectLockEnabled2) {
      ObjectLockEnabled2["Enabled"] = "Enabled";
    })(ObjectLockEnabled = exports.ObjectLockEnabled || (exports.ObjectLockEnabled = {}));
    var ObjectLockRetentionMode;
    (function(ObjectLockRetentionMode2) {
      ObjectLockRetentionMode2["COMPLIANCE"] = "COMPLIANCE";
      ObjectLockRetentionMode2["GOVERNANCE"] = "GOVERNANCE";
    })(ObjectLockRetentionMode = exports.ObjectLockRetentionMode || (exports.ObjectLockRetentionMode = {}));
    var NotFound = class extends S3ServiceException_1.S3ServiceException {
      constructor(opts) {
        super({
          name: "NotFound",
          $fault: "client",
          ...opts
        });
        this.name = "NotFound";
        this.$fault = "client";
        Object.setPrototypeOf(this, NotFound.prototype);
      }
    };
    exports.NotFound = NotFound;
    var ArchiveStatus;
    (function(ArchiveStatus2) {
      ArchiveStatus2["ARCHIVE_ACCESS"] = "ARCHIVE_ACCESS";
      ArchiveStatus2["DEEP_ARCHIVE_ACCESS"] = "DEEP_ARCHIVE_ACCESS";
    })(ArchiveStatus = exports.ArchiveStatus || (exports.ArchiveStatus = {}));
    var EncodingType;
    (function(EncodingType2) {
      EncodingType2["url"] = "url";
    })(EncodingType = exports.EncodingType || (exports.EncodingType = {}));
    var ObjectStorageClass;
    (function(ObjectStorageClass2) {
      ObjectStorageClass2["DEEP_ARCHIVE"] = "DEEP_ARCHIVE";
      ObjectStorageClass2["GLACIER"] = "GLACIER";
      ObjectStorageClass2["GLACIER_IR"] = "GLACIER_IR";
      ObjectStorageClass2["INTELLIGENT_TIERING"] = "INTELLIGENT_TIERING";
      ObjectStorageClass2["ONEZONE_IA"] = "ONEZONE_IA";
      ObjectStorageClass2["OUTPOSTS"] = "OUTPOSTS";
      ObjectStorageClass2["REDUCED_REDUNDANCY"] = "REDUCED_REDUNDANCY";
      ObjectStorageClass2["STANDARD"] = "STANDARD";
      ObjectStorageClass2["STANDARD_IA"] = "STANDARD_IA";
    })(ObjectStorageClass = exports.ObjectStorageClass || (exports.ObjectStorageClass = {}));
    var NoSuchBucket = class extends S3ServiceException_1.S3ServiceException {
      constructor(opts) {
        super({
          name: "NoSuchBucket",
          $fault: "client",
          ...opts
        });
        this.name = "NoSuchBucket";
        this.$fault = "client";
        Object.setPrototypeOf(this, NoSuchBucket.prototype);
      }
    };
    exports.NoSuchBucket = NoSuchBucket;
    var ObjectVersionStorageClass;
    (function(ObjectVersionStorageClass2) {
      ObjectVersionStorageClass2["STANDARD"] = "STANDARD";
    })(ObjectVersionStorageClass = exports.ObjectVersionStorageClass || (exports.ObjectVersionStorageClass = {}));
    var MFADelete;
    (function(MFADelete2) {
      MFADelete2["Disabled"] = "Disabled";
      MFADelete2["Enabled"] = "Enabled";
    })(MFADelete = exports.MFADelete || (exports.MFADelete = {}));
    var AbortIncompleteMultipartUploadFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.AbortIncompleteMultipartUploadFilterSensitiveLog = AbortIncompleteMultipartUploadFilterSensitiveLog;
    var AbortMultipartUploadOutputFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.AbortMultipartUploadOutputFilterSensitiveLog = AbortMultipartUploadOutputFilterSensitiveLog;
    var AbortMultipartUploadRequestFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.AbortMultipartUploadRequestFilterSensitiveLog = AbortMultipartUploadRequestFilterSensitiveLog;
    var AccelerateConfigurationFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.AccelerateConfigurationFilterSensitiveLog = AccelerateConfigurationFilterSensitiveLog;
    var GranteeFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.GranteeFilterSensitiveLog = GranteeFilterSensitiveLog;
    var GrantFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.GrantFilterSensitiveLog = GrantFilterSensitiveLog;
    var OwnerFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.OwnerFilterSensitiveLog = OwnerFilterSensitiveLog;
    var AccessControlPolicyFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.AccessControlPolicyFilterSensitiveLog = AccessControlPolicyFilterSensitiveLog;
    var AccessControlTranslationFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.AccessControlTranslationFilterSensitiveLog = AccessControlTranslationFilterSensitiveLog;
    var CompleteMultipartUploadOutputFilterSensitiveLog = (obj) => ({
      ...obj,
      ...obj.SSEKMSKeyId && { SSEKMSKeyId: smithy_client_1.SENSITIVE_STRING }
    });
    exports.CompleteMultipartUploadOutputFilterSensitiveLog = CompleteMultipartUploadOutputFilterSensitiveLog;
    var CompletedPartFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.CompletedPartFilterSensitiveLog = CompletedPartFilterSensitiveLog;
    var CompletedMultipartUploadFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.CompletedMultipartUploadFilterSensitiveLog = CompletedMultipartUploadFilterSensitiveLog;
    var CompleteMultipartUploadRequestFilterSensitiveLog = (obj) => ({
      ...obj,
      ...obj.SSECustomerKey && { SSECustomerKey: smithy_client_1.SENSITIVE_STRING }
    });
    exports.CompleteMultipartUploadRequestFilterSensitiveLog = CompleteMultipartUploadRequestFilterSensitiveLog;
    var CopyObjectResultFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.CopyObjectResultFilterSensitiveLog = CopyObjectResultFilterSensitiveLog;
    var CopyObjectOutputFilterSensitiveLog = (obj) => ({
      ...obj,
      ...obj.SSEKMSKeyId && { SSEKMSKeyId: smithy_client_1.SENSITIVE_STRING },
      ...obj.SSEKMSEncryptionContext && { SSEKMSEncryptionContext: smithy_client_1.SENSITIVE_STRING }
    });
    exports.CopyObjectOutputFilterSensitiveLog = CopyObjectOutputFilterSensitiveLog;
    var CopyObjectRequestFilterSensitiveLog = (obj) => ({
      ...obj,
      ...obj.SSECustomerKey && { SSECustomerKey: smithy_client_1.SENSITIVE_STRING },
      ...obj.SSEKMSKeyId && { SSEKMSKeyId: smithy_client_1.SENSITIVE_STRING },
      ...obj.SSEKMSEncryptionContext && { SSEKMSEncryptionContext: smithy_client_1.SENSITIVE_STRING },
      ...obj.CopySourceSSECustomerKey && { CopySourceSSECustomerKey: smithy_client_1.SENSITIVE_STRING }
    });
    exports.CopyObjectRequestFilterSensitiveLog = CopyObjectRequestFilterSensitiveLog;
    var CreateBucketOutputFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.CreateBucketOutputFilterSensitiveLog = CreateBucketOutputFilterSensitiveLog;
    var CreateBucketConfigurationFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.CreateBucketConfigurationFilterSensitiveLog = CreateBucketConfigurationFilterSensitiveLog;
    var CreateBucketRequestFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.CreateBucketRequestFilterSensitiveLog = CreateBucketRequestFilterSensitiveLog;
    var CreateMultipartUploadOutputFilterSensitiveLog = (obj) => ({
      ...obj,
      ...obj.SSEKMSKeyId && { SSEKMSKeyId: smithy_client_1.SENSITIVE_STRING },
      ...obj.SSEKMSEncryptionContext && { SSEKMSEncryptionContext: smithy_client_1.SENSITIVE_STRING }
    });
    exports.CreateMultipartUploadOutputFilterSensitiveLog = CreateMultipartUploadOutputFilterSensitiveLog;
    var CreateMultipartUploadRequestFilterSensitiveLog = (obj) => ({
      ...obj,
      ...obj.SSECustomerKey && { SSECustomerKey: smithy_client_1.SENSITIVE_STRING },
      ...obj.SSEKMSKeyId && { SSEKMSKeyId: smithy_client_1.SENSITIVE_STRING },
      ...obj.SSEKMSEncryptionContext && { SSEKMSEncryptionContext: smithy_client_1.SENSITIVE_STRING }
    });
    exports.CreateMultipartUploadRequestFilterSensitiveLog = CreateMultipartUploadRequestFilterSensitiveLog;
    var DeleteBucketRequestFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.DeleteBucketRequestFilterSensitiveLog = DeleteBucketRequestFilterSensitiveLog;
    var DeleteBucketAnalyticsConfigurationRequestFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.DeleteBucketAnalyticsConfigurationRequestFilterSensitiveLog = DeleteBucketAnalyticsConfigurationRequestFilterSensitiveLog;
    var DeleteBucketCorsRequestFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.DeleteBucketCorsRequestFilterSensitiveLog = DeleteBucketCorsRequestFilterSensitiveLog;
    var DeleteBucketEncryptionRequestFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.DeleteBucketEncryptionRequestFilterSensitiveLog = DeleteBucketEncryptionRequestFilterSensitiveLog;
    var DeleteBucketIntelligentTieringConfigurationRequestFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.DeleteBucketIntelligentTieringConfigurationRequestFilterSensitiveLog = DeleteBucketIntelligentTieringConfigurationRequestFilterSensitiveLog;
    var DeleteBucketInventoryConfigurationRequestFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.DeleteBucketInventoryConfigurationRequestFilterSensitiveLog = DeleteBucketInventoryConfigurationRequestFilterSensitiveLog;
    var DeleteBucketLifecycleRequestFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.DeleteBucketLifecycleRequestFilterSensitiveLog = DeleteBucketLifecycleRequestFilterSensitiveLog;
    var DeleteBucketMetricsConfigurationRequestFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.DeleteBucketMetricsConfigurationRequestFilterSensitiveLog = DeleteBucketMetricsConfigurationRequestFilterSensitiveLog;
    var DeleteBucketOwnershipControlsRequestFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.DeleteBucketOwnershipControlsRequestFilterSensitiveLog = DeleteBucketOwnershipControlsRequestFilterSensitiveLog;
    var DeleteBucketPolicyRequestFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.DeleteBucketPolicyRequestFilterSensitiveLog = DeleteBucketPolicyRequestFilterSensitiveLog;
    var DeleteBucketReplicationRequestFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.DeleteBucketReplicationRequestFilterSensitiveLog = DeleteBucketReplicationRequestFilterSensitiveLog;
    var DeleteBucketTaggingRequestFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.DeleteBucketTaggingRequestFilterSensitiveLog = DeleteBucketTaggingRequestFilterSensitiveLog;
    var DeleteBucketWebsiteRequestFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.DeleteBucketWebsiteRequestFilterSensitiveLog = DeleteBucketWebsiteRequestFilterSensitiveLog;
    var DeleteObjectOutputFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.DeleteObjectOutputFilterSensitiveLog = DeleteObjectOutputFilterSensitiveLog;
    var DeleteObjectRequestFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.DeleteObjectRequestFilterSensitiveLog = DeleteObjectRequestFilterSensitiveLog;
    var DeletedObjectFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.DeletedObjectFilterSensitiveLog = DeletedObjectFilterSensitiveLog;
    var _ErrorFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports._ErrorFilterSensitiveLog = _ErrorFilterSensitiveLog;
    var DeleteObjectsOutputFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.DeleteObjectsOutputFilterSensitiveLog = DeleteObjectsOutputFilterSensitiveLog;
    var ObjectIdentifierFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.ObjectIdentifierFilterSensitiveLog = ObjectIdentifierFilterSensitiveLog;
    var DeleteFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.DeleteFilterSensitiveLog = DeleteFilterSensitiveLog;
    var DeleteObjectsRequestFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.DeleteObjectsRequestFilterSensitiveLog = DeleteObjectsRequestFilterSensitiveLog;
    var DeleteObjectTaggingOutputFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.DeleteObjectTaggingOutputFilterSensitiveLog = DeleteObjectTaggingOutputFilterSensitiveLog;
    var DeleteObjectTaggingRequestFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.DeleteObjectTaggingRequestFilterSensitiveLog = DeleteObjectTaggingRequestFilterSensitiveLog;
    var DeletePublicAccessBlockRequestFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.DeletePublicAccessBlockRequestFilterSensitiveLog = DeletePublicAccessBlockRequestFilterSensitiveLog;
    var GetBucketAccelerateConfigurationOutputFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.GetBucketAccelerateConfigurationOutputFilterSensitiveLog = GetBucketAccelerateConfigurationOutputFilterSensitiveLog;
    var GetBucketAccelerateConfigurationRequestFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.GetBucketAccelerateConfigurationRequestFilterSensitiveLog = GetBucketAccelerateConfigurationRequestFilterSensitiveLog;
    var GetBucketAclOutputFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.GetBucketAclOutputFilterSensitiveLog = GetBucketAclOutputFilterSensitiveLog;
    var GetBucketAclRequestFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.GetBucketAclRequestFilterSensitiveLog = GetBucketAclRequestFilterSensitiveLog;
    var TagFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.TagFilterSensitiveLog = TagFilterSensitiveLog;
    var AnalyticsAndOperatorFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.AnalyticsAndOperatorFilterSensitiveLog = AnalyticsAndOperatorFilterSensitiveLog;
    var AnalyticsFilterFilterSensitiveLog = (obj) => {
      if (obj.Prefix !== void 0)
        return { Prefix: obj.Prefix };
      if (obj.Tag !== void 0)
        return { Tag: (0, exports.TagFilterSensitiveLog)(obj.Tag) };
      if (obj.And !== void 0)
        return { And: (0, exports.AnalyticsAndOperatorFilterSensitiveLog)(obj.And) };
      if (obj.$unknown !== void 0)
        return { [obj.$unknown[0]]: "UNKNOWN" };
    };
    exports.AnalyticsFilterFilterSensitiveLog = AnalyticsFilterFilterSensitiveLog;
    var AnalyticsS3BucketDestinationFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.AnalyticsS3BucketDestinationFilterSensitiveLog = AnalyticsS3BucketDestinationFilterSensitiveLog;
    var AnalyticsExportDestinationFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.AnalyticsExportDestinationFilterSensitiveLog = AnalyticsExportDestinationFilterSensitiveLog;
    var StorageClassAnalysisDataExportFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.StorageClassAnalysisDataExportFilterSensitiveLog = StorageClassAnalysisDataExportFilterSensitiveLog;
    var StorageClassAnalysisFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.StorageClassAnalysisFilterSensitiveLog = StorageClassAnalysisFilterSensitiveLog;
    var AnalyticsConfigurationFilterSensitiveLog = (obj) => ({
      ...obj,
      ...obj.Filter && { Filter: (0, exports.AnalyticsFilterFilterSensitiveLog)(obj.Filter) }
    });
    exports.AnalyticsConfigurationFilterSensitiveLog = AnalyticsConfigurationFilterSensitiveLog;
    var GetBucketAnalyticsConfigurationOutputFilterSensitiveLog = (obj) => ({
      ...obj,
      ...obj.AnalyticsConfiguration && {
        AnalyticsConfiguration: (0, exports.AnalyticsConfigurationFilterSensitiveLog)(obj.AnalyticsConfiguration)
      }
    });
    exports.GetBucketAnalyticsConfigurationOutputFilterSensitiveLog = GetBucketAnalyticsConfigurationOutputFilterSensitiveLog;
    var GetBucketAnalyticsConfigurationRequestFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.GetBucketAnalyticsConfigurationRequestFilterSensitiveLog = GetBucketAnalyticsConfigurationRequestFilterSensitiveLog;
    var CORSRuleFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.CORSRuleFilterSensitiveLog = CORSRuleFilterSensitiveLog;
    var GetBucketCorsOutputFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.GetBucketCorsOutputFilterSensitiveLog = GetBucketCorsOutputFilterSensitiveLog;
    var GetBucketCorsRequestFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.GetBucketCorsRequestFilterSensitiveLog = GetBucketCorsRequestFilterSensitiveLog;
    var ServerSideEncryptionByDefaultFilterSensitiveLog = (obj) => ({
      ...obj,
      ...obj.KMSMasterKeyID && { KMSMasterKeyID: smithy_client_1.SENSITIVE_STRING }
    });
    exports.ServerSideEncryptionByDefaultFilterSensitiveLog = ServerSideEncryptionByDefaultFilterSensitiveLog;
    var ServerSideEncryptionRuleFilterSensitiveLog = (obj) => ({
      ...obj,
      ...obj.ApplyServerSideEncryptionByDefault && {
        ApplyServerSideEncryptionByDefault: (0, exports.ServerSideEncryptionByDefaultFilterSensitiveLog)(obj.ApplyServerSideEncryptionByDefault)
      }
    });
    exports.ServerSideEncryptionRuleFilterSensitiveLog = ServerSideEncryptionRuleFilterSensitiveLog;
    var ServerSideEncryptionConfigurationFilterSensitiveLog = (obj) => ({
      ...obj,
      ...obj.Rules && { Rules: obj.Rules.map((item) => (0, exports.ServerSideEncryptionRuleFilterSensitiveLog)(item)) }
    });
    exports.ServerSideEncryptionConfigurationFilterSensitiveLog = ServerSideEncryptionConfigurationFilterSensitiveLog;
    var GetBucketEncryptionOutputFilterSensitiveLog = (obj) => ({
      ...obj,
      ...obj.ServerSideEncryptionConfiguration && {
        ServerSideEncryptionConfiguration: (0, exports.ServerSideEncryptionConfigurationFilterSensitiveLog)(obj.ServerSideEncryptionConfiguration)
      }
    });
    exports.GetBucketEncryptionOutputFilterSensitiveLog = GetBucketEncryptionOutputFilterSensitiveLog;
    var GetBucketEncryptionRequestFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.GetBucketEncryptionRequestFilterSensitiveLog = GetBucketEncryptionRequestFilterSensitiveLog;
    var IntelligentTieringAndOperatorFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.IntelligentTieringAndOperatorFilterSensitiveLog = IntelligentTieringAndOperatorFilterSensitiveLog;
    var IntelligentTieringFilterFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.IntelligentTieringFilterFilterSensitiveLog = IntelligentTieringFilterFilterSensitiveLog;
    var TieringFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.TieringFilterSensitiveLog = TieringFilterSensitiveLog;
    var IntelligentTieringConfigurationFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.IntelligentTieringConfigurationFilterSensitiveLog = IntelligentTieringConfigurationFilterSensitiveLog;
    var GetBucketIntelligentTieringConfigurationOutputFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.GetBucketIntelligentTieringConfigurationOutputFilterSensitiveLog = GetBucketIntelligentTieringConfigurationOutputFilterSensitiveLog;
    var GetBucketIntelligentTieringConfigurationRequestFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.GetBucketIntelligentTieringConfigurationRequestFilterSensitiveLog = GetBucketIntelligentTieringConfigurationRequestFilterSensitiveLog;
    var SSEKMSFilterSensitiveLog = (obj) => ({
      ...obj,
      ...obj.KeyId && { KeyId: smithy_client_1.SENSITIVE_STRING }
    });
    exports.SSEKMSFilterSensitiveLog = SSEKMSFilterSensitiveLog;
    var SSES3FilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.SSES3FilterSensitiveLog = SSES3FilterSensitiveLog;
    var InventoryEncryptionFilterSensitiveLog = (obj) => ({
      ...obj,
      ...obj.SSEKMS && { SSEKMS: (0, exports.SSEKMSFilterSensitiveLog)(obj.SSEKMS) }
    });
    exports.InventoryEncryptionFilterSensitiveLog = InventoryEncryptionFilterSensitiveLog;
    var InventoryS3BucketDestinationFilterSensitiveLog = (obj) => ({
      ...obj,
      ...obj.Encryption && { Encryption: (0, exports.InventoryEncryptionFilterSensitiveLog)(obj.Encryption) }
    });
    exports.InventoryS3BucketDestinationFilterSensitiveLog = InventoryS3BucketDestinationFilterSensitiveLog;
    var InventoryDestinationFilterSensitiveLog = (obj) => ({
      ...obj,
      ...obj.S3BucketDestination && {
        S3BucketDestination: (0, exports.InventoryS3BucketDestinationFilterSensitiveLog)(obj.S3BucketDestination)
      }
    });
    exports.InventoryDestinationFilterSensitiveLog = InventoryDestinationFilterSensitiveLog;
    var InventoryFilterFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.InventoryFilterFilterSensitiveLog = InventoryFilterFilterSensitiveLog;
    var InventoryScheduleFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.InventoryScheduleFilterSensitiveLog = InventoryScheduleFilterSensitiveLog;
    var InventoryConfigurationFilterSensitiveLog = (obj) => ({
      ...obj,
      ...obj.Destination && { Destination: (0, exports.InventoryDestinationFilterSensitiveLog)(obj.Destination) }
    });
    exports.InventoryConfigurationFilterSensitiveLog = InventoryConfigurationFilterSensitiveLog;
    var GetBucketInventoryConfigurationOutputFilterSensitiveLog = (obj) => ({
      ...obj,
      ...obj.InventoryConfiguration && {
        InventoryConfiguration: (0, exports.InventoryConfigurationFilterSensitiveLog)(obj.InventoryConfiguration)
      }
    });
    exports.GetBucketInventoryConfigurationOutputFilterSensitiveLog = GetBucketInventoryConfigurationOutputFilterSensitiveLog;
    var GetBucketInventoryConfigurationRequestFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.GetBucketInventoryConfigurationRequestFilterSensitiveLog = GetBucketInventoryConfigurationRequestFilterSensitiveLog;
    var LifecycleExpirationFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.LifecycleExpirationFilterSensitiveLog = LifecycleExpirationFilterSensitiveLog;
    var LifecycleRuleAndOperatorFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.LifecycleRuleAndOperatorFilterSensitiveLog = LifecycleRuleAndOperatorFilterSensitiveLog;
    var LifecycleRuleFilterFilterSensitiveLog = (obj) => {
      if (obj.Prefix !== void 0)
        return { Prefix: obj.Prefix };
      if (obj.Tag !== void 0)
        return { Tag: (0, exports.TagFilterSensitiveLog)(obj.Tag) };
      if (obj.ObjectSizeGreaterThan !== void 0)
        return { ObjectSizeGreaterThan: obj.ObjectSizeGreaterThan };
      if (obj.ObjectSizeLessThan !== void 0)
        return { ObjectSizeLessThan: obj.ObjectSizeLessThan };
      if (obj.And !== void 0)
        return { And: (0, exports.LifecycleRuleAndOperatorFilterSensitiveLog)(obj.And) };
      if (obj.$unknown !== void 0)
        return { [obj.$unknown[0]]: "UNKNOWN" };
    };
    exports.LifecycleRuleFilterFilterSensitiveLog = LifecycleRuleFilterFilterSensitiveLog;
    var NoncurrentVersionExpirationFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.NoncurrentVersionExpirationFilterSensitiveLog = NoncurrentVersionExpirationFilterSensitiveLog;
    var NoncurrentVersionTransitionFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.NoncurrentVersionTransitionFilterSensitiveLog = NoncurrentVersionTransitionFilterSensitiveLog;
    var TransitionFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.TransitionFilterSensitiveLog = TransitionFilterSensitiveLog;
    var LifecycleRuleFilterSensitiveLog = (obj) => ({
      ...obj,
      ...obj.Filter && { Filter: (0, exports.LifecycleRuleFilterFilterSensitiveLog)(obj.Filter) }
    });
    exports.LifecycleRuleFilterSensitiveLog = LifecycleRuleFilterSensitiveLog;
    var GetBucketLifecycleConfigurationOutputFilterSensitiveLog = (obj) => ({
      ...obj,
      ...obj.Rules && { Rules: obj.Rules.map((item) => (0, exports.LifecycleRuleFilterSensitiveLog)(item)) }
    });
    exports.GetBucketLifecycleConfigurationOutputFilterSensitiveLog = GetBucketLifecycleConfigurationOutputFilterSensitiveLog;
    var GetBucketLifecycleConfigurationRequestFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.GetBucketLifecycleConfigurationRequestFilterSensitiveLog = GetBucketLifecycleConfigurationRequestFilterSensitiveLog;
    var GetBucketLocationOutputFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.GetBucketLocationOutputFilterSensitiveLog = GetBucketLocationOutputFilterSensitiveLog;
    var GetBucketLocationRequestFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.GetBucketLocationRequestFilterSensitiveLog = GetBucketLocationRequestFilterSensitiveLog;
    var TargetGrantFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.TargetGrantFilterSensitiveLog = TargetGrantFilterSensitiveLog;
    var LoggingEnabledFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.LoggingEnabledFilterSensitiveLog = LoggingEnabledFilterSensitiveLog;
    var GetBucketLoggingOutputFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.GetBucketLoggingOutputFilterSensitiveLog = GetBucketLoggingOutputFilterSensitiveLog;
    var GetBucketLoggingRequestFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.GetBucketLoggingRequestFilterSensitiveLog = GetBucketLoggingRequestFilterSensitiveLog;
    var MetricsAndOperatorFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.MetricsAndOperatorFilterSensitiveLog = MetricsAndOperatorFilterSensitiveLog;
    var MetricsFilterFilterSensitiveLog = (obj) => {
      if (obj.Prefix !== void 0)
        return { Prefix: obj.Prefix };
      if (obj.Tag !== void 0)
        return { Tag: (0, exports.TagFilterSensitiveLog)(obj.Tag) };
      if (obj.AccessPointArn !== void 0)
        return { AccessPointArn: obj.AccessPointArn };
      if (obj.And !== void 0)
        return { And: (0, exports.MetricsAndOperatorFilterSensitiveLog)(obj.And) };
      if (obj.$unknown !== void 0)
        return { [obj.$unknown[0]]: "UNKNOWN" };
    };
    exports.MetricsFilterFilterSensitiveLog = MetricsFilterFilterSensitiveLog;
    var MetricsConfigurationFilterSensitiveLog = (obj) => ({
      ...obj,
      ...obj.Filter && { Filter: (0, exports.MetricsFilterFilterSensitiveLog)(obj.Filter) }
    });
    exports.MetricsConfigurationFilterSensitiveLog = MetricsConfigurationFilterSensitiveLog;
    var GetBucketMetricsConfigurationOutputFilterSensitiveLog = (obj) => ({
      ...obj,
      ...obj.MetricsConfiguration && {
        MetricsConfiguration: (0, exports.MetricsConfigurationFilterSensitiveLog)(obj.MetricsConfiguration)
      }
    });
    exports.GetBucketMetricsConfigurationOutputFilterSensitiveLog = GetBucketMetricsConfigurationOutputFilterSensitiveLog;
    var GetBucketMetricsConfigurationRequestFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.GetBucketMetricsConfigurationRequestFilterSensitiveLog = GetBucketMetricsConfigurationRequestFilterSensitiveLog;
    var GetBucketNotificationConfigurationRequestFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.GetBucketNotificationConfigurationRequestFilterSensitiveLog = GetBucketNotificationConfigurationRequestFilterSensitiveLog;
    var EventBridgeConfigurationFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.EventBridgeConfigurationFilterSensitiveLog = EventBridgeConfigurationFilterSensitiveLog;
    var FilterRuleFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.FilterRuleFilterSensitiveLog = FilterRuleFilterSensitiveLog;
    var S3KeyFilterFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.S3KeyFilterFilterSensitiveLog = S3KeyFilterFilterSensitiveLog;
    var NotificationConfigurationFilterFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.NotificationConfigurationFilterFilterSensitiveLog = NotificationConfigurationFilterFilterSensitiveLog;
    var LambdaFunctionConfigurationFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.LambdaFunctionConfigurationFilterSensitiveLog = LambdaFunctionConfigurationFilterSensitiveLog;
    var QueueConfigurationFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.QueueConfigurationFilterSensitiveLog = QueueConfigurationFilterSensitiveLog;
    var TopicConfigurationFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.TopicConfigurationFilterSensitiveLog = TopicConfigurationFilterSensitiveLog;
    var NotificationConfigurationFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.NotificationConfigurationFilterSensitiveLog = NotificationConfigurationFilterSensitiveLog;
    var OwnershipControlsRuleFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.OwnershipControlsRuleFilterSensitiveLog = OwnershipControlsRuleFilterSensitiveLog;
    var OwnershipControlsFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.OwnershipControlsFilterSensitiveLog = OwnershipControlsFilterSensitiveLog;
    var GetBucketOwnershipControlsOutputFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.GetBucketOwnershipControlsOutputFilterSensitiveLog = GetBucketOwnershipControlsOutputFilterSensitiveLog;
    var GetBucketOwnershipControlsRequestFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.GetBucketOwnershipControlsRequestFilterSensitiveLog = GetBucketOwnershipControlsRequestFilterSensitiveLog;
    var GetBucketPolicyOutputFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.GetBucketPolicyOutputFilterSensitiveLog = GetBucketPolicyOutputFilterSensitiveLog;
    var GetBucketPolicyRequestFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.GetBucketPolicyRequestFilterSensitiveLog = GetBucketPolicyRequestFilterSensitiveLog;
    var PolicyStatusFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.PolicyStatusFilterSensitiveLog = PolicyStatusFilterSensitiveLog;
    var GetBucketPolicyStatusOutputFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.GetBucketPolicyStatusOutputFilterSensitiveLog = GetBucketPolicyStatusOutputFilterSensitiveLog;
    var GetBucketPolicyStatusRequestFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.GetBucketPolicyStatusRequestFilterSensitiveLog = GetBucketPolicyStatusRequestFilterSensitiveLog;
    var DeleteMarkerReplicationFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.DeleteMarkerReplicationFilterSensitiveLog = DeleteMarkerReplicationFilterSensitiveLog;
    var EncryptionConfigurationFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.EncryptionConfigurationFilterSensitiveLog = EncryptionConfigurationFilterSensitiveLog;
    var ReplicationTimeValueFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.ReplicationTimeValueFilterSensitiveLog = ReplicationTimeValueFilterSensitiveLog;
    var MetricsFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.MetricsFilterSensitiveLog = MetricsFilterSensitiveLog;
    var ReplicationTimeFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.ReplicationTimeFilterSensitiveLog = ReplicationTimeFilterSensitiveLog;
    var DestinationFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.DestinationFilterSensitiveLog = DestinationFilterSensitiveLog;
    var ExistingObjectReplicationFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.ExistingObjectReplicationFilterSensitiveLog = ExistingObjectReplicationFilterSensitiveLog;
    var ReplicationRuleAndOperatorFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.ReplicationRuleAndOperatorFilterSensitiveLog = ReplicationRuleAndOperatorFilterSensitiveLog;
    var ReplicationRuleFilterFilterSensitiveLog = (obj) => {
      if (obj.Prefix !== void 0)
        return { Prefix: obj.Prefix };
      if (obj.Tag !== void 0)
        return { Tag: (0, exports.TagFilterSensitiveLog)(obj.Tag) };
      if (obj.And !== void 0)
        return { And: (0, exports.ReplicationRuleAndOperatorFilterSensitiveLog)(obj.And) };
      if (obj.$unknown !== void 0)
        return { [obj.$unknown[0]]: "UNKNOWN" };
    };
    exports.ReplicationRuleFilterFilterSensitiveLog = ReplicationRuleFilterFilterSensitiveLog;
    var ReplicaModificationsFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.ReplicaModificationsFilterSensitiveLog = ReplicaModificationsFilterSensitiveLog;
    var SseKmsEncryptedObjectsFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.SseKmsEncryptedObjectsFilterSensitiveLog = SseKmsEncryptedObjectsFilterSensitiveLog;
    var SourceSelectionCriteriaFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.SourceSelectionCriteriaFilterSensitiveLog = SourceSelectionCriteriaFilterSensitiveLog;
    var ReplicationRuleFilterSensitiveLog = (obj) => ({
      ...obj,
      ...obj.Filter && { Filter: (0, exports.ReplicationRuleFilterFilterSensitiveLog)(obj.Filter) }
    });
    exports.ReplicationRuleFilterSensitiveLog = ReplicationRuleFilterSensitiveLog;
    var ReplicationConfigurationFilterSensitiveLog = (obj) => ({
      ...obj,
      ...obj.Rules && { Rules: obj.Rules.map((item) => (0, exports.ReplicationRuleFilterSensitiveLog)(item)) }
    });
    exports.ReplicationConfigurationFilterSensitiveLog = ReplicationConfigurationFilterSensitiveLog;
    var GetBucketReplicationOutputFilterSensitiveLog = (obj) => ({
      ...obj,
      ...obj.ReplicationConfiguration && {
        ReplicationConfiguration: (0, exports.ReplicationConfigurationFilterSensitiveLog)(obj.ReplicationConfiguration)
      }
    });
    exports.GetBucketReplicationOutputFilterSensitiveLog = GetBucketReplicationOutputFilterSensitiveLog;
    var GetBucketReplicationRequestFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.GetBucketReplicationRequestFilterSensitiveLog = GetBucketReplicationRequestFilterSensitiveLog;
    var GetBucketRequestPaymentOutputFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.GetBucketRequestPaymentOutputFilterSensitiveLog = GetBucketRequestPaymentOutputFilterSensitiveLog;
    var GetBucketRequestPaymentRequestFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.GetBucketRequestPaymentRequestFilterSensitiveLog = GetBucketRequestPaymentRequestFilterSensitiveLog;
    var GetBucketTaggingOutputFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.GetBucketTaggingOutputFilterSensitiveLog = GetBucketTaggingOutputFilterSensitiveLog;
    var GetBucketTaggingRequestFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.GetBucketTaggingRequestFilterSensitiveLog = GetBucketTaggingRequestFilterSensitiveLog;
    var GetBucketVersioningOutputFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.GetBucketVersioningOutputFilterSensitiveLog = GetBucketVersioningOutputFilterSensitiveLog;
    var GetBucketVersioningRequestFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.GetBucketVersioningRequestFilterSensitiveLog = GetBucketVersioningRequestFilterSensitiveLog;
    var ErrorDocumentFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.ErrorDocumentFilterSensitiveLog = ErrorDocumentFilterSensitiveLog;
    var IndexDocumentFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.IndexDocumentFilterSensitiveLog = IndexDocumentFilterSensitiveLog;
    var RedirectAllRequestsToFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.RedirectAllRequestsToFilterSensitiveLog = RedirectAllRequestsToFilterSensitiveLog;
    var ConditionFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.ConditionFilterSensitiveLog = ConditionFilterSensitiveLog;
    var RedirectFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.RedirectFilterSensitiveLog = RedirectFilterSensitiveLog;
    var RoutingRuleFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.RoutingRuleFilterSensitiveLog = RoutingRuleFilterSensitiveLog;
    var GetBucketWebsiteOutputFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.GetBucketWebsiteOutputFilterSensitiveLog = GetBucketWebsiteOutputFilterSensitiveLog;
    var GetBucketWebsiteRequestFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.GetBucketWebsiteRequestFilterSensitiveLog = GetBucketWebsiteRequestFilterSensitiveLog;
    var GetObjectOutputFilterSensitiveLog = (obj) => ({
      ...obj,
      ...obj.SSEKMSKeyId && { SSEKMSKeyId: smithy_client_1.SENSITIVE_STRING }
    });
    exports.GetObjectOutputFilterSensitiveLog = GetObjectOutputFilterSensitiveLog;
    var GetObjectRequestFilterSensitiveLog = (obj) => ({
      ...obj,
      ...obj.SSECustomerKey && { SSECustomerKey: smithy_client_1.SENSITIVE_STRING }
    });
    exports.GetObjectRequestFilterSensitiveLog = GetObjectRequestFilterSensitiveLog;
    var GetObjectAclOutputFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.GetObjectAclOutputFilterSensitiveLog = GetObjectAclOutputFilterSensitiveLog;
    var GetObjectAclRequestFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.GetObjectAclRequestFilterSensitiveLog = GetObjectAclRequestFilterSensitiveLog;
    var ChecksumFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.ChecksumFilterSensitiveLog = ChecksumFilterSensitiveLog;
    var ObjectPartFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.ObjectPartFilterSensitiveLog = ObjectPartFilterSensitiveLog;
    var GetObjectAttributesPartsFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.GetObjectAttributesPartsFilterSensitiveLog = GetObjectAttributesPartsFilterSensitiveLog;
    var GetObjectAttributesOutputFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.GetObjectAttributesOutputFilterSensitiveLog = GetObjectAttributesOutputFilterSensitiveLog;
    var GetObjectAttributesRequestFilterSensitiveLog = (obj) => ({
      ...obj,
      ...obj.SSECustomerKey && { SSECustomerKey: smithy_client_1.SENSITIVE_STRING }
    });
    exports.GetObjectAttributesRequestFilterSensitiveLog = GetObjectAttributesRequestFilterSensitiveLog;
    var ObjectLockLegalHoldFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.ObjectLockLegalHoldFilterSensitiveLog = ObjectLockLegalHoldFilterSensitiveLog;
    var GetObjectLegalHoldOutputFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.GetObjectLegalHoldOutputFilterSensitiveLog = GetObjectLegalHoldOutputFilterSensitiveLog;
    var GetObjectLegalHoldRequestFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.GetObjectLegalHoldRequestFilterSensitiveLog = GetObjectLegalHoldRequestFilterSensitiveLog;
    var DefaultRetentionFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.DefaultRetentionFilterSensitiveLog = DefaultRetentionFilterSensitiveLog;
    var ObjectLockRuleFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.ObjectLockRuleFilterSensitiveLog = ObjectLockRuleFilterSensitiveLog;
    var ObjectLockConfigurationFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.ObjectLockConfigurationFilterSensitiveLog = ObjectLockConfigurationFilterSensitiveLog;
    var GetObjectLockConfigurationOutputFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.GetObjectLockConfigurationOutputFilterSensitiveLog = GetObjectLockConfigurationOutputFilterSensitiveLog;
    var GetObjectLockConfigurationRequestFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.GetObjectLockConfigurationRequestFilterSensitiveLog = GetObjectLockConfigurationRequestFilterSensitiveLog;
    var ObjectLockRetentionFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.ObjectLockRetentionFilterSensitiveLog = ObjectLockRetentionFilterSensitiveLog;
    var GetObjectRetentionOutputFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.GetObjectRetentionOutputFilterSensitiveLog = GetObjectRetentionOutputFilterSensitiveLog;
    var GetObjectRetentionRequestFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.GetObjectRetentionRequestFilterSensitiveLog = GetObjectRetentionRequestFilterSensitiveLog;
    var GetObjectTaggingOutputFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.GetObjectTaggingOutputFilterSensitiveLog = GetObjectTaggingOutputFilterSensitiveLog;
    var GetObjectTaggingRequestFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.GetObjectTaggingRequestFilterSensitiveLog = GetObjectTaggingRequestFilterSensitiveLog;
    var GetObjectTorrentOutputFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.GetObjectTorrentOutputFilterSensitiveLog = GetObjectTorrentOutputFilterSensitiveLog;
    var GetObjectTorrentRequestFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.GetObjectTorrentRequestFilterSensitiveLog = GetObjectTorrentRequestFilterSensitiveLog;
    var PublicAccessBlockConfigurationFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.PublicAccessBlockConfigurationFilterSensitiveLog = PublicAccessBlockConfigurationFilterSensitiveLog;
    var GetPublicAccessBlockOutputFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.GetPublicAccessBlockOutputFilterSensitiveLog = GetPublicAccessBlockOutputFilterSensitiveLog;
    var GetPublicAccessBlockRequestFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.GetPublicAccessBlockRequestFilterSensitiveLog = GetPublicAccessBlockRequestFilterSensitiveLog;
    var HeadBucketRequestFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.HeadBucketRequestFilterSensitiveLog = HeadBucketRequestFilterSensitiveLog;
    var HeadObjectOutputFilterSensitiveLog = (obj) => ({
      ...obj,
      ...obj.SSEKMSKeyId && { SSEKMSKeyId: smithy_client_1.SENSITIVE_STRING }
    });
    exports.HeadObjectOutputFilterSensitiveLog = HeadObjectOutputFilterSensitiveLog;
    var HeadObjectRequestFilterSensitiveLog = (obj) => ({
      ...obj,
      ...obj.SSECustomerKey && { SSECustomerKey: smithy_client_1.SENSITIVE_STRING }
    });
    exports.HeadObjectRequestFilterSensitiveLog = HeadObjectRequestFilterSensitiveLog;
    var ListBucketAnalyticsConfigurationsOutputFilterSensitiveLog = (obj) => ({
      ...obj,
      ...obj.AnalyticsConfigurationList && {
        AnalyticsConfigurationList: obj.AnalyticsConfigurationList.map((item) => (0, exports.AnalyticsConfigurationFilterSensitiveLog)(item))
      }
    });
    exports.ListBucketAnalyticsConfigurationsOutputFilterSensitiveLog = ListBucketAnalyticsConfigurationsOutputFilterSensitiveLog;
    var ListBucketAnalyticsConfigurationsRequestFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.ListBucketAnalyticsConfigurationsRequestFilterSensitiveLog = ListBucketAnalyticsConfigurationsRequestFilterSensitiveLog;
    var ListBucketIntelligentTieringConfigurationsOutputFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.ListBucketIntelligentTieringConfigurationsOutputFilterSensitiveLog = ListBucketIntelligentTieringConfigurationsOutputFilterSensitiveLog;
    var ListBucketIntelligentTieringConfigurationsRequestFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.ListBucketIntelligentTieringConfigurationsRequestFilterSensitiveLog = ListBucketIntelligentTieringConfigurationsRequestFilterSensitiveLog;
    var ListBucketInventoryConfigurationsOutputFilterSensitiveLog = (obj) => ({
      ...obj,
      ...obj.InventoryConfigurationList && {
        InventoryConfigurationList: obj.InventoryConfigurationList.map((item) => (0, exports.InventoryConfigurationFilterSensitiveLog)(item))
      }
    });
    exports.ListBucketInventoryConfigurationsOutputFilterSensitiveLog = ListBucketInventoryConfigurationsOutputFilterSensitiveLog;
    var ListBucketInventoryConfigurationsRequestFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.ListBucketInventoryConfigurationsRequestFilterSensitiveLog = ListBucketInventoryConfigurationsRequestFilterSensitiveLog;
    var ListBucketMetricsConfigurationsOutputFilterSensitiveLog = (obj) => ({
      ...obj,
      ...obj.MetricsConfigurationList && {
        MetricsConfigurationList: obj.MetricsConfigurationList.map((item) => (0, exports.MetricsConfigurationFilterSensitiveLog)(item))
      }
    });
    exports.ListBucketMetricsConfigurationsOutputFilterSensitiveLog = ListBucketMetricsConfigurationsOutputFilterSensitiveLog;
    var ListBucketMetricsConfigurationsRequestFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.ListBucketMetricsConfigurationsRequestFilterSensitiveLog = ListBucketMetricsConfigurationsRequestFilterSensitiveLog;
    var BucketFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.BucketFilterSensitiveLog = BucketFilterSensitiveLog;
    var ListBucketsOutputFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.ListBucketsOutputFilterSensitiveLog = ListBucketsOutputFilterSensitiveLog;
    var CommonPrefixFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.CommonPrefixFilterSensitiveLog = CommonPrefixFilterSensitiveLog;
    var InitiatorFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.InitiatorFilterSensitiveLog = InitiatorFilterSensitiveLog;
    var MultipartUploadFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.MultipartUploadFilterSensitiveLog = MultipartUploadFilterSensitiveLog;
    var ListMultipartUploadsOutputFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.ListMultipartUploadsOutputFilterSensitiveLog = ListMultipartUploadsOutputFilterSensitiveLog;
    var ListMultipartUploadsRequestFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.ListMultipartUploadsRequestFilterSensitiveLog = ListMultipartUploadsRequestFilterSensitiveLog;
    var _ObjectFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports._ObjectFilterSensitiveLog = _ObjectFilterSensitiveLog;
    var ListObjectsOutputFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.ListObjectsOutputFilterSensitiveLog = ListObjectsOutputFilterSensitiveLog;
    var ListObjectsRequestFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.ListObjectsRequestFilterSensitiveLog = ListObjectsRequestFilterSensitiveLog;
    var ListObjectsV2OutputFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.ListObjectsV2OutputFilterSensitiveLog = ListObjectsV2OutputFilterSensitiveLog;
    var ListObjectsV2RequestFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.ListObjectsV2RequestFilterSensitiveLog = ListObjectsV2RequestFilterSensitiveLog;
    var DeleteMarkerEntryFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.DeleteMarkerEntryFilterSensitiveLog = DeleteMarkerEntryFilterSensitiveLog;
    var ObjectVersionFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.ObjectVersionFilterSensitiveLog = ObjectVersionFilterSensitiveLog;
    var ListObjectVersionsOutputFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.ListObjectVersionsOutputFilterSensitiveLog = ListObjectVersionsOutputFilterSensitiveLog;
    var ListObjectVersionsRequestFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.ListObjectVersionsRequestFilterSensitiveLog = ListObjectVersionsRequestFilterSensitiveLog;
    var PartFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.PartFilterSensitiveLog = PartFilterSensitiveLog;
    var ListPartsOutputFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.ListPartsOutputFilterSensitiveLog = ListPartsOutputFilterSensitiveLog;
    var ListPartsRequestFilterSensitiveLog = (obj) => ({
      ...obj,
      ...obj.SSECustomerKey && { SSECustomerKey: smithy_client_1.SENSITIVE_STRING }
    });
    exports.ListPartsRequestFilterSensitiveLog = ListPartsRequestFilterSensitiveLog;
    var PutBucketAccelerateConfigurationRequestFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.PutBucketAccelerateConfigurationRequestFilterSensitiveLog = PutBucketAccelerateConfigurationRequestFilterSensitiveLog;
    var PutBucketAclRequestFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.PutBucketAclRequestFilterSensitiveLog = PutBucketAclRequestFilterSensitiveLog;
    var PutBucketAnalyticsConfigurationRequestFilterSensitiveLog = (obj) => ({
      ...obj,
      ...obj.AnalyticsConfiguration && {
        AnalyticsConfiguration: (0, exports.AnalyticsConfigurationFilterSensitiveLog)(obj.AnalyticsConfiguration)
      }
    });
    exports.PutBucketAnalyticsConfigurationRequestFilterSensitiveLog = PutBucketAnalyticsConfigurationRequestFilterSensitiveLog;
    var CORSConfigurationFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.CORSConfigurationFilterSensitiveLog = CORSConfigurationFilterSensitiveLog;
    var PutBucketCorsRequestFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.PutBucketCorsRequestFilterSensitiveLog = PutBucketCorsRequestFilterSensitiveLog;
    var PutBucketEncryptionRequestFilterSensitiveLog = (obj) => ({
      ...obj,
      ...obj.ServerSideEncryptionConfiguration && {
        ServerSideEncryptionConfiguration: (0, exports.ServerSideEncryptionConfigurationFilterSensitiveLog)(obj.ServerSideEncryptionConfiguration)
      }
    });
    exports.PutBucketEncryptionRequestFilterSensitiveLog = PutBucketEncryptionRequestFilterSensitiveLog;
    var PutBucketIntelligentTieringConfigurationRequestFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.PutBucketIntelligentTieringConfigurationRequestFilterSensitiveLog = PutBucketIntelligentTieringConfigurationRequestFilterSensitiveLog;
    var PutBucketInventoryConfigurationRequestFilterSensitiveLog = (obj) => ({
      ...obj,
      ...obj.InventoryConfiguration && {
        InventoryConfiguration: (0, exports.InventoryConfigurationFilterSensitiveLog)(obj.InventoryConfiguration)
      }
    });
    exports.PutBucketInventoryConfigurationRequestFilterSensitiveLog = PutBucketInventoryConfigurationRequestFilterSensitiveLog;
    var BucketLifecycleConfigurationFilterSensitiveLog = (obj) => ({
      ...obj,
      ...obj.Rules && { Rules: obj.Rules.map((item) => (0, exports.LifecycleRuleFilterSensitiveLog)(item)) }
    });
    exports.BucketLifecycleConfigurationFilterSensitiveLog = BucketLifecycleConfigurationFilterSensitiveLog;
    var PutBucketLifecycleConfigurationRequestFilterSensitiveLog = (obj) => ({
      ...obj,
      ...obj.LifecycleConfiguration && {
        LifecycleConfiguration: (0, exports.BucketLifecycleConfigurationFilterSensitiveLog)(obj.LifecycleConfiguration)
      }
    });
    exports.PutBucketLifecycleConfigurationRequestFilterSensitiveLog = PutBucketLifecycleConfigurationRequestFilterSensitiveLog;
    var BucketLoggingStatusFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.BucketLoggingStatusFilterSensitiveLog = BucketLoggingStatusFilterSensitiveLog;
    var PutBucketLoggingRequestFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.PutBucketLoggingRequestFilterSensitiveLog = PutBucketLoggingRequestFilterSensitiveLog;
    var PutBucketMetricsConfigurationRequestFilterSensitiveLog = (obj) => ({
      ...obj,
      ...obj.MetricsConfiguration && {
        MetricsConfiguration: (0, exports.MetricsConfigurationFilterSensitiveLog)(obj.MetricsConfiguration)
      }
    });
    exports.PutBucketMetricsConfigurationRequestFilterSensitiveLog = PutBucketMetricsConfigurationRequestFilterSensitiveLog;
    var PutBucketNotificationConfigurationRequestFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.PutBucketNotificationConfigurationRequestFilterSensitiveLog = PutBucketNotificationConfigurationRequestFilterSensitiveLog;
    var PutBucketOwnershipControlsRequestFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.PutBucketOwnershipControlsRequestFilterSensitiveLog = PutBucketOwnershipControlsRequestFilterSensitiveLog;
    var PutBucketPolicyRequestFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.PutBucketPolicyRequestFilterSensitiveLog = PutBucketPolicyRequestFilterSensitiveLog;
    var PutBucketReplicationRequestFilterSensitiveLog = (obj) => ({
      ...obj,
      ...obj.ReplicationConfiguration && {
        ReplicationConfiguration: (0, exports.ReplicationConfigurationFilterSensitiveLog)(obj.ReplicationConfiguration)
      }
    });
    exports.PutBucketReplicationRequestFilterSensitiveLog = PutBucketReplicationRequestFilterSensitiveLog;
    var RequestPaymentConfigurationFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.RequestPaymentConfigurationFilterSensitiveLog = RequestPaymentConfigurationFilterSensitiveLog;
    var PutBucketRequestPaymentRequestFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.PutBucketRequestPaymentRequestFilterSensitiveLog = PutBucketRequestPaymentRequestFilterSensitiveLog;
    var TaggingFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.TaggingFilterSensitiveLog = TaggingFilterSensitiveLog;
    var PutBucketTaggingRequestFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.PutBucketTaggingRequestFilterSensitiveLog = PutBucketTaggingRequestFilterSensitiveLog;
    var VersioningConfigurationFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.VersioningConfigurationFilterSensitiveLog = VersioningConfigurationFilterSensitiveLog;
    var PutBucketVersioningRequestFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.PutBucketVersioningRequestFilterSensitiveLog = PutBucketVersioningRequestFilterSensitiveLog;
    var WebsiteConfigurationFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.WebsiteConfigurationFilterSensitiveLog = WebsiteConfigurationFilterSensitiveLog;
    var PutBucketWebsiteRequestFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.PutBucketWebsiteRequestFilterSensitiveLog = PutBucketWebsiteRequestFilterSensitiveLog;
    var PutObjectOutputFilterSensitiveLog = (obj) => ({
      ...obj,
      ...obj.SSEKMSKeyId && { SSEKMSKeyId: smithy_client_1.SENSITIVE_STRING },
      ...obj.SSEKMSEncryptionContext && { SSEKMSEncryptionContext: smithy_client_1.SENSITIVE_STRING }
    });
    exports.PutObjectOutputFilterSensitiveLog = PutObjectOutputFilterSensitiveLog;
    var PutObjectRequestFilterSensitiveLog = (obj) => ({
      ...obj,
      ...obj.SSECustomerKey && { SSECustomerKey: smithy_client_1.SENSITIVE_STRING },
      ...obj.SSEKMSKeyId && { SSEKMSKeyId: smithy_client_1.SENSITIVE_STRING },
      ...obj.SSEKMSEncryptionContext && { SSEKMSEncryptionContext: smithy_client_1.SENSITIVE_STRING }
    });
    exports.PutObjectRequestFilterSensitiveLog = PutObjectRequestFilterSensitiveLog;
    var PutObjectAclOutputFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.PutObjectAclOutputFilterSensitiveLog = PutObjectAclOutputFilterSensitiveLog;
    var PutObjectAclRequestFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.PutObjectAclRequestFilterSensitiveLog = PutObjectAclRequestFilterSensitiveLog;
    var PutObjectLegalHoldOutputFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.PutObjectLegalHoldOutputFilterSensitiveLog = PutObjectLegalHoldOutputFilterSensitiveLog;
    var PutObjectLegalHoldRequestFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.PutObjectLegalHoldRequestFilterSensitiveLog = PutObjectLegalHoldRequestFilterSensitiveLog;
    var PutObjectLockConfigurationOutputFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.PutObjectLockConfigurationOutputFilterSensitiveLog = PutObjectLockConfigurationOutputFilterSensitiveLog;
    var PutObjectLockConfigurationRequestFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.PutObjectLockConfigurationRequestFilterSensitiveLog = PutObjectLockConfigurationRequestFilterSensitiveLog;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+protocol-http@3.272.0/node_modules/@aws-sdk/protocol-http/dist-cjs/FieldPosition.js
var require_FieldPosition = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+protocol-http@3.272.0/node_modules/@aws-sdk/protocol-http/dist-cjs/FieldPosition.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.FieldPosition = void 0;
    var FieldPosition;
    (function(FieldPosition2) {
      FieldPosition2[FieldPosition2["HEADER"] = 0] = "HEADER";
      FieldPosition2[FieldPosition2["TRAILER"] = 1] = "TRAILER";
    })(FieldPosition = exports.FieldPosition || (exports.FieldPosition = {}));
  }
});

// ../../node_modules/.pnpm/@aws-sdk+protocol-http@3.272.0/node_modules/@aws-sdk/protocol-http/dist-cjs/Field.js
var require_Field = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+protocol-http@3.272.0/node_modules/@aws-sdk/protocol-http/dist-cjs/Field.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.Field = void 0;
    var FieldPosition_1 = require_FieldPosition();
    var Field = class {
      constructor({ name, kind = FieldPosition_1.FieldPosition.HEADER, values = [] }) {
        this.name = name;
        this.kind = kind;
        this.values = values;
      }
      add(value) {
        this.values.push(value);
      }
      set(values) {
        this.values = values;
      }
      remove(value) {
        this.values = this.values.filter((v) => v !== value);
      }
      toString() {
        return this.values.map((v) => v.includes(",") || v.includes(" ") ? `"${v}"` : v).join(", ");
      }
      get() {
        return this.values;
      }
    };
    exports.Field = Field;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+protocol-http@3.272.0/node_modules/@aws-sdk/protocol-http/dist-cjs/Fields.js
var require_Fields = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+protocol-http@3.272.0/node_modules/@aws-sdk/protocol-http/dist-cjs/Fields.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.Fields = void 0;
    var Fields = class {
      constructor({ fields = [], encoding = "utf-8" }) {
        this.entries = {};
        fields.forEach(this.setField.bind(this));
        this.encoding = encoding;
      }
      setField(field) {
        this.entries[field.name] = field;
      }
      getField(name) {
        return this.entries[name];
      }
      removeField(name) {
        delete this.entries[name];
      }
      getByType(kind) {
        return Object.values(this.entries).filter((field) => field.kind === kind);
      }
    };
    exports.Fields = Fields;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+protocol-http@3.272.0/node_modules/@aws-sdk/protocol-http/dist-cjs/httpHandler.js
var require_httpHandler = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+protocol-http@3.272.0/node_modules/@aws-sdk/protocol-http/dist-cjs/httpHandler.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
  }
});

// ../../node_modules/.pnpm/@aws-sdk+protocol-http@3.272.0/node_modules/@aws-sdk/protocol-http/dist-cjs/httpRequest.js
var require_httpRequest = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+protocol-http@3.272.0/node_modules/@aws-sdk/protocol-http/dist-cjs/httpRequest.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.HttpRequest = void 0;
    var HttpRequest = class {
      constructor(options) {
        this.method = options.method || "GET";
        this.hostname = options.hostname || "localhost";
        this.port = options.port;
        this.query = options.query || {};
        this.headers = options.headers || {};
        this.body = options.body;
        this.protocol = options.protocol ? options.protocol.slice(-1) !== ":" ? `${options.protocol}:` : options.protocol : "https:";
        this.path = options.path ? options.path.charAt(0) !== "/" ? `/${options.path}` : options.path : "/";
      }
      static isInstance(request) {
        if (!request)
          return false;
        const req = request;
        return "method" in req && "protocol" in req && "hostname" in req && "path" in req && typeof req["query"] === "object" && typeof req["headers"] === "object";
      }
      clone() {
        const cloned = new HttpRequest({
          ...this,
          headers: { ...this.headers }
        });
        if (cloned.query)
          cloned.query = cloneQuery(cloned.query);
        return cloned;
      }
    };
    exports.HttpRequest = HttpRequest;
    function cloneQuery(query) {
      return Object.keys(query).reduce((carry, paramName) => {
        const param = query[paramName];
        return {
          ...carry,
          [paramName]: Array.isArray(param) ? [...param] : param
        };
      }, {});
    }
  }
});

// ../../node_modules/.pnpm/@aws-sdk+protocol-http@3.272.0/node_modules/@aws-sdk/protocol-http/dist-cjs/httpResponse.js
var require_httpResponse = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+protocol-http@3.272.0/node_modules/@aws-sdk/protocol-http/dist-cjs/httpResponse.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.HttpResponse = void 0;
    var HttpResponse = class {
      constructor(options) {
        this.statusCode = options.statusCode;
        this.headers = options.headers || {};
        this.body = options.body;
      }
      static isInstance(response) {
        if (!response)
          return false;
        const resp = response;
        return typeof resp.statusCode === "number" && typeof resp.headers === "object";
      }
    };
    exports.HttpResponse = HttpResponse;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+protocol-http@3.272.0/node_modules/@aws-sdk/protocol-http/dist-cjs/isValidHostname.js
var require_isValidHostname = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+protocol-http@3.272.0/node_modules/@aws-sdk/protocol-http/dist-cjs/isValidHostname.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.isValidHostname = void 0;
    function isValidHostname(hostname) {
      const hostPattern = /^[a-z0-9][a-z0-9\.\-]*[a-z0-9]$/;
      return hostPattern.test(hostname);
    }
    exports.isValidHostname = isValidHostname;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+protocol-http@3.272.0/node_modules/@aws-sdk/protocol-http/dist-cjs/index.js
var require_dist_cjs8 = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+protocol-http@3.272.0/node_modules/@aws-sdk/protocol-http/dist-cjs/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    var tslib_1 = (init_tslib_es6(), __toCommonJS(tslib_es6_exports));
    tslib_1.__exportStar(require_Field(), exports);
    tslib_1.__exportStar(require_FieldPosition(), exports);
    tslib_1.__exportStar(require_Fields(), exports);
    tslib_1.__exportStar(require_httpHandler(), exports);
    tslib_1.__exportStar(require_httpRequest(), exports);
    tslib_1.__exportStar(require_httpResponse(), exports);
    tslib_1.__exportStar(require_isValidHostname(), exports);
  }
});

// ../../node_modules/.pnpm/@aws-sdk+xml-builder@3.201.0/node_modules/@aws-sdk/xml-builder/dist-cjs/escape-attribute.js
var require_escape_attribute = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+xml-builder@3.201.0/node_modules/@aws-sdk/xml-builder/dist-cjs/escape-attribute.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.escapeAttribute = void 0;
    function escapeAttribute(value) {
      return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
    }
    exports.escapeAttribute = escapeAttribute;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+xml-builder@3.201.0/node_modules/@aws-sdk/xml-builder/dist-cjs/escape-element.js
var require_escape_element = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+xml-builder@3.201.0/node_modules/@aws-sdk/xml-builder/dist-cjs/escape-element.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.escapeElement = void 0;
    function escapeElement(value) {
      return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/'/g, "&apos;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/\r/g, "&#x0D;").replace(/\n/g, "&#x0A;").replace(/\u0085/g, "&#x85;").replace(/\u2028/, "&#x2028;");
    }
    exports.escapeElement = escapeElement;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+xml-builder@3.201.0/node_modules/@aws-sdk/xml-builder/dist-cjs/XmlText.js
var require_XmlText = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+xml-builder@3.201.0/node_modules/@aws-sdk/xml-builder/dist-cjs/XmlText.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.XmlText = void 0;
    var escape_element_1 = require_escape_element();
    var XmlText = class {
      constructor(value) {
        this.value = value;
      }
      toString() {
        return (0, escape_element_1.escapeElement)("" + this.value);
      }
    };
    exports.XmlText = XmlText;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+xml-builder@3.201.0/node_modules/@aws-sdk/xml-builder/dist-cjs/XmlNode.js
var require_XmlNode = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+xml-builder@3.201.0/node_modules/@aws-sdk/xml-builder/dist-cjs/XmlNode.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.XmlNode = void 0;
    var escape_attribute_1 = require_escape_attribute();
    var XmlText_1 = require_XmlText();
    var XmlNode = class {
      constructor(name, children = []) {
        this.name = name;
        this.children = children;
        this.attributes = {};
      }
      static of(name, childText, withName) {
        const node = new XmlNode(name);
        if (childText !== void 0) {
          node.addChildNode(new XmlText_1.XmlText(childText));
        }
        if (withName !== void 0) {
          node.withName(withName);
        }
        return node;
      }
      withName(name) {
        this.name = name;
        return this;
      }
      addAttribute(name, value) {
        this.attributes[name] = value;
        return this;
      }
      addChildNode(child) {
        this.children.push(child);
        return this;
      }
      removeAttribute(name) {
        delete this.attributes[name];
        return this;
      }
      toString() {
        const hasChildren = Boolean(this.children.length);
        let xmlText = `<${this.name}`;
        const attributes = this.attributes;
        for (const attributeName of Object.keys(attributes)) {
          const attribute = attributes[attributeName];
          if (typeof attribute !== "undefined" && attribute !== null) {
            xmlText += ` ${attributeName}="${(0, escape_attribute_1.escapeAttribute)("" + attribute)}"`;
          }
        }
        return xmlText += !hasChildren ? "/>" : `>${this.children.map((c) => c.toString()).join("")}</${this.name}>`;
      }
    };
    exports.XmlNode = XmlNode;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+xml-builder@3.201.0/node_modules/@aws-sdk/xml-builder/dist-cjs/index.js
var require_dist_cjs9 = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+xml-builder@3.201.0/node_modules/@aws-sdk/xml-builder/dist-cjs/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    var tslib_1 = (init_tslib_es6(), __toCommonJS(tslib_es6_exports));
    tslib_1.__exportStar(require_XmlNode(), exports);
    tslib_1.__exportStar(require_XmlText(), exports);
  }
});

// ../../node_modules/.pnpm/fast-xml-parser@4.0.11/node_modules/fast-xml-parser/src/util.js
var require_util = __commonJS({
  "../../node_modules/.pnpm/fast-xml-parser@4.0.11/node_modules/fast-xml-parser/src/util.js"(exports) {
    "use strict";
    var nameStartChar = ":A-Za-z_\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD";
    var nameChar = nameStartChar + "\\-.\\d\\u00B7\\u0300-\\u036F\\u203F-\\u2040";
    var nameRegexp = "[" + nameStartChar + "][" + nameChar + "]*";
    var regexName = new RegExp("^" + nameRegexp + "$");
    var getAllMatches = function(string, regex) {
      const matches = [];
      let match = regex.exec(string);
      while (match) {
        const allmatches = [];
        allmatches.startIndex = regex.lastIndex - match[0].length;
        const len = match.length;
        for (let index = 0; index < len; index++) {
          allmatches.push(match[index]);
        }
        matches.push(allmatches);
        match = regex.exec(string);
      }
      return matches;
    };
    var isName = function(string) {
      const match = regexName.exec(string);
      return !(match === null || typeof match === "undefined");
    };
    exports.isExist = function(v) {
      return typeof v !== "undefined";
    };
    exports.isEmptyObject = function(obj) {
      return Object.keys(obj).length === 0;
    };
    exports.merge = function(target, a, arrayMode) {
      if (a) {
        const keys = Object.keys(a);
        const len = keys.length;
        for (let i = 0; i < len; i++) {
          if (arrayMode === "strict") {
            target[keys[i]] = [a[keys[i]]];
          } else {
            target[keys[i]] = a[keys[i]];
          }
        }
      }
    };
    exports.getValue = function(v) {
      if (exports.isExist(v)) {
        return v;
      } else {
        return "";
      }
    };
    exports.isName = isName;
    exports.getAllMatches = getAllMatches;
    exports.nameRegexp = nameRegexp;
  }
});

// ../../node_modules/.pnpm/fast-xml-parser@4.0.11/node_modules/fast-xml-parser/src/validator.js
var require_validator = __commonJS({
  "../../node_modules/.pnpm/fast-xml-parser@4.0.11/node_modules/fast-xml-parser/src/validator.js"(exports) {
    "use strict";
    var util3 = require_util();
    var defaultOptions = {
      allowBooleanAttributes: false,
      //A tag can have attributes without any value
      unpairedTags: []
    };
    exports.validate = function(xmlData, options) {
      options = Object.assign({}, defaultOptions, options);
      const tags = [];
      let tagFound = false;
      let reachedRoot = false;
      if (xmlData[0] === "\uFEFF") {
        xmlData = xmlData.substr(1);
      }
      for (let i = 0; i < xmlData.length; i++) {
        if (xmlData[i] === "<" && xmlData[i + 1] === "?") {
          i += 2;
          i = readPI(xmlData, i);
          if (i.err)
            return i;
        } else if (xmlData[i] === "<") {
          let tagStartPos = i;
          i++;
          if (xmlData[i] === "!") {
            i = readCommentAndCDATA(xmlData, i);
            continue;
          } else {
            let closingTag = false;
            if (xmlData[i] === "/") {
              closingTag = true;
              i++;
            }
            let tagName = "";
            for (; i < xmlData.length && xmlData[i] !== ">" && xmlData[i] !== " " && xmlData[i] !== "	" && xmlData[i] !== "\n" && xmlData[i] !== "\r"; i++) {
              tagName += xmlData[i];
            }
            tagName = tagName.trim();
            if (tagName[tagName.length - 1] === "/") {
              tagName = tagName.substring(0, tagName.length - 1);
              i--;
            }
            if (!validateTagName(tagName)) {
              let msg;
              if (tagName.trim().length === 0) {
                msg = "Invalid space after '<'.";
              } else {
                msg = "Tag '" + tagName + "' is an invalid name.";
              }
              return getErrorObject("InvalidTag", msg, getLineNumberForPosition(xmlData, i));
            }
            const result = readAttributeStr(xmlData, i);
            if (result === false) {
              return getErrorObject("InvalidAttr", "Attributes for '" + tagName + "' have open quote.", getLineNumberForPosition(xmlData, i));
            }
            let attrStr = result.value;
            i = result.index;
            if (attrStr[attrStr.length - 1] === "/") {
              const attrStrStart = i - attrStr.length;
              attrStr = attrStr.substring(0, attrStr.length - 1);
              const isValid = validateAttributeString(attrStr, options);
              if (isValid === true) {
                tagFound = true;
              } else {
                return getErrorObject(isValid.err.code, isValid.err.msg, getLineNumberForPosition(xmlData, attrStrStart + isValid.err.line));
              }
            } else if (closingTag) {
              if (!result.tagClosed) {
                return getErrorObject("InvalidTag", "Closing tag '" + tagName + "' doesn't have proper closing.", getLineNumberForPosition(xmlData, i));
              } else if (attrStr.trim().length > 0) {
                return getErrorObject("InvalidTag", "Closing tag '" + tagName + "' can't have attributes or invalid starting.", getLineNumberForPosition(xmlData, tagStartPos));
              } else {
                const otg = tags.pop();
                if (tagName !== otg.tagName) {
                  let openPos = getLineNumberForPosition(xmlData, otg.tagStartPos);
                  return getErrorObject(
                    "InvalidTag",
                    "Expected closing tag '" + otg.tagName + "' (opened in line " + openPos.line + ", col " + openPos.col + ") instead of closing tag '" + tagName + "'.",
                    getLineNumberForPosition(xmlData, tagStartPos)
                  );
                }
                if (tags.length == 0) {
                  reachedRoot = true;
                }
              }
            } else {
              const isValid = validateAttributeString(attrStr, options);
              if (isValid !== true) {
                return getErrorObject(isValid.err.code, isValid.err.msg, getLineNumberForPosition(xmlData, i - attrStr.length + isValid.err.line));
              }
              if (reachedRoot === true) {
                return getErrorObject("InvalidXml", "Multiple possible root nodes found.", getLineNumberForPosition(xmlData, i));
              } else if (options.unpairedTags.indexOf(tagName) !== -1) {
              } else {
                tags.push({ tagName, tagStartPos });
              }
              tagFound = true;
            }
            for (i++; i < xmlData.length; i++) {
              if (xmlData[i] === "<") {
                if (xmlData[i + 1] === "!") {
                  i++;
                  i = readCommentAndCDATA(xmlData, i);
                  continue;
                } else if (xmlData[i + 1] === "?") {
                  i = readPI(xmlData, ++i);
                  if (i.err)
                    return i;
                } else {
                  break;
                }
              } else if (xmlData[i] === "&") {
                const afterAmp = validateAmpersand(xmlData, i);
                if (afterAmp == -1)
                  return getErrorObject("InvalidChar", "char '&' is not expected.", getLineNumberForPosition(xmlData, i));
                i = afterAmp;
              } else {
                if (reachedRoot === true && !isWhiteSpace(xmlData[i])) {
                  return getErrorObject("InvalidXml", "Extra text at the end", getLineNumberForPosition(xmlData, i));
                }
              }
            }
            if (xmlData[i] === "<") {
              i--;
            }
          }
        } else {
          if (isWhiteSpace(xmlData[i])) {
            continue;
          }
          return getErrorObject("InvalidChar", "char '" + xmlData[i] + "' is not expected.", getLineNumberForPosition(xmlData, i));
        }
      }
      if (!tagFound) {
        return getErrorObject("InvalidXml", "Start tag expected.", 1);
      } else if (tags.length == 1) {
        return getErrorObject("InvalidTag", "Unclosed tag '" + tags[0].tagName + "'.", getLineNumberForPosition(xmlData, tags[0].tagStartPos));
      } else if (tags.length > 0) {
        return getErrorObject("InvalidXml", "Invalid '" + JSON.stringify(tags.map((t) => t.tagName), null, 4).replace(/\r?\n/g, "") + "' found.", { line: 1, col: 1 });
      }
      return true;
    };
    function isWhiteSpace(char) {
      return char === " " || char === "	" || char === "\n" || char === "\r";
    }
    function readPI(xmlData, i) {
      const start = i;
      for (; i < xmlData.length; i++) {
        if (xmlData[i] == "?" || xmlData[i] == " ") {
          const tagname = xmlData.substr(start, i - start);
          if (i > 5 && tagname === "xml") {
            return getErrorObject("InvalidXml", "XML declaration allowed only at the start of the document.", getLineNumberForPosition(xmlData, i));
          } else if (xmlData[i] == "?" && xmlData[i + 1] == ">") {
            i++;
            break;
          } else {
            continue;
          }
        }
      }
      return i;
    }
    function readCommentAndCDATA(xmlData, i) {
      if (xmlData.length > i + 5 && xmlData[i + 1] === "-" && xmlData[i + 2] === "-") {
        for (i += 3; i < xmlData.length; i++) {
          if (xmlData[i] === "-" && xmlData[i + 1] === "-" && xmlData[i + 2] === ">") {
            i += 2;
            break;
          }
        }
      } else if (xmlData.length > i + 8 && xmlData[i + 1] === "D" && xmlData[i + 2] === "O" && xmlData[i + 3] === "C" && xmlData[i + 4] === "T" && xmlData[i + 5] === "Y" && xmlData[i + 6] === "P" && xmlData[i + 7] === "E") {
        let angleBracketsCount = 1;
        for (i += 8; i < xmlData.length; i++) {
          if (xmlData[i] === "<") {
            angleBracketsCount++;
          } else if (xmlData[i] === ">") {
            angleBracketsCount--;
            if (angleBracketsCount === 0) {
              break;
            }
          }
        }
      } else if (xmlData.length > i + 9 && xmlData[i + 1] === "[" && xmlData[i + 2] === "C" && xmlData[i + 3] === "D" && xmlData[i + 4] === "A" && xmlData[i + 5] === "T" && xmlData[i + 6] === "A" && xmlData[i + 7] === "[") {
        for (i += 8; i < xmlData.length; i++) {
          if (xmlData[i] === "]" && xmlData[i + 1] === "]" && xmlData[i + 2] === ">") {
            i += 2;
            break;
          }
        }
      }
      return i;
    }
    var doubleQuote = '"';
    var singleQuote = "'";
    function readAttributeStr(xmlData, i) {
      let attrStr = "";
      let startChar = "";
      let tagClosed = false;
      for (; i < xmlData.length; i++) {
        if (xmlData[i] === doubleQuote || xmlData[i] === singleQuote) {
          if (startChar === "") {
            startChar = xmlData[i];
          } else if (startChar !== xmlData[i]) {
          } else {
            startChar = "";
          }
        } else if (xmlData[i] === ">") {
          if (startChar === "") {
            tagClosed = true;
            break;
          }
        }
        attrStr += xmlData[i];
      }
      if (startChar !== "") {
        return false;
      }
      return {
        value: attrStr,
        index: i,
        tagClosed
      };
    }
    var validAttrStrRegxp = new RegExp(`(\\s*)([^\\s=]+)(\\s*=)?(\\s*(['"])(([\\s\\S])*?)\\5)?`, "g");
    function validateAttributeString(attrStr, options) {
      const matches = util3.getAllMatches(attrStr, validAttrStrRegxp);
      const attrNames = {};
      for (let i = 0; i < matches.length; i++) {
        if (matches[i][1].length === 0) {
          return getErrorObject("InvalidAttr", "Attribute '" + matches[i][2] + "' has no space in starting.", getPositionFromMatch(matches[i]));
        } else if (matches[i][3] !== void 0 && matches[i][4] === void 0) {
          return getErrorObject("InvalidAttr", "Attribute '" + matches[i][2] + "' is without value.", getPositionFromMatch(matches[i]));
        } else if (matches[i][3] === void 0 && !options.allowBooleanAttributes) {
          return getErrorObject("InvalidAttr", "boolean attribute '" + matches[i][2] + "' is not allowed.", getPositionFromMatch(matches[i]));
        }
        const attrName = matches[i][2];
        if (!validateAttrName(attrName)) {
          return getErrorObject("InvalidAttr", "Attribute '" + attrName + "' is an invalid name.", getPositionFromMatch(matches[i]));
        }
        if (!attrNames.hasOwnProperty(attrName)) {
          attrNames[attrName] = 1;
        } else {
          return getErrorObject("InvalidAttr", "Attribute '" + attrName + "' is repeated.", getPositionFromMatch(matches[i]));
        }
      }
      return true;
    }
    function validateNumberAmpersand(xmlData, i) {
      let re = /\d/;
      if (xmlData[i] === "x") {
        i++;
        re = /[\da-fA-F]/;
      }
      for (; i < xmlData.length; i++) {
        if (xmlData[i] === ";")
          return i;
        if (!xmlData[i].match(re))
          break;
      }
      return -1;
    }
    function validateAmpersand(xmlData, i) {
      i++;
      if (xmlData[i] === ";")
        return -1;
      if (xmlData[i] === "#") {
        i++;
        return validateNumberAmpersand(xmlData, i);
      }
      let count = 0;
      for (; i < xmlData.length; i++, count++) {
        if (xmlData[i].match(/\w/) && count < 20)
          continue;
        if (xmlData[i] === ";")
          break;
        return -1;
      }
      return i;
    }
    function getErrorObject(code, message, lineNumber) {
      return {
        err: {
          code,
          msg: message,
          line: lineNumber.line || lineNumber,
          col: lineNumber.col
        }
      };
    }
    function validateAttrName(attrName) {
      return util3.isName(attrName);
    }
    function validateTagName(tagname) {
      return util3.isName(tagname);
    }
    function getLineNumberForPosition(xmlData, index) {
      const lines = xmlData.substring(0, index).split(/\r?\n/);
      return {
        line: lines.length,
        // column number is last line's length + 1, because column numbering starts at 1:
        col: lines[lines.length - 1].length + 1
      };
    }
    function getPositionFromMatch(match) {
      return match.startIndex + match[1].length;
    }
  }
});

// ../../node_modules/.pnpm/fast-xml-parser@4.0.11/node_modules/fast-xml-parser/src/xmlparser/OptionsBuilder.js
var require_OptionsBuilder = __commonJS({
  "../../node_modules/.pnpm/fast-xml-parser@4.0.11/node_modules/fast-xml-parser/src/xmlparser/OptionsBuilder.js"(exports) {
    var defaultOptions = {
      preserveOrder: false,
      attributeNamePrefix: "@_",
      attributesGroupName: false,
      textNodeName: "#text",
      ignoreAttributes: true,
      removeNSPrefix: false,
      // remove NS from tag name or attribute name if true
      allowBooleanAttributes: false,
      //a tag can have attributes without any value
      //ignoreRootElement : false,
      parseTagValue: true,
      parseAttributeValue: false,
      trimValues: true,
      //Trim string values of tag and attributes
      cdataPropName: false,
      numberParseOptions: {
        hex: true,
        leadingZeros: true
      },
      tagValueProcessor: function(tagName, val) {
        return val;
      },
      attributeValueProcessor: function(attrName, val) {
        return val;
      },
      stopNodes: [],
      //nested tags will not be parsed even for errors
      alwaysCreateTextNode: false,
      isArray: () => false,
      commentPropName: false,
      unpairedTags: [],
      processEntities: true,
      htmlEntities: false,
      ignoreDeclaration: false,
      ignorePiTags: false,
      transformTagName: false
    };
    var buildOptions = function(options) {
      return Object.assign({}, defaultOptions, options);
    };
    exports.buildOptions = buildOptions;
    exports.defaultOptions = defaultOptions;
  }
});

// ../../node_modules/.pnpm/fast-xml-parser@4.0.11/node_modules/fast-xml-parser/src/xmlparser/xmlNode.js
var require_xmlNode = __commonJS({
  "../../node_modules/.pnpm/fast-xml-parser@4.0.11/node_modules/fast-xml-parser/src/xmlparser/xmlNode.js"(exports, module2) {
    "use strict";
    var XmlNode = class {
      constructor(tagname) {
        this.tagname = tagname;
        this.child = [];
        this[":@"] = {};
      }
      add(key, val) {
        this.child.push({ [key]: val });
      }
      addChild(node) {
        if (node[":@"] && Object.keys(node[":@"]).length > 0) {
          this.child.push({ [node.tagname]: node.child, [":@"]: node[":@"] });
        } else {
          this.child.push({ [node.tagname]: node.child });
        }
      }
    };
    module2.exports = XmlNode;
  }
});

// ../../node_modules/.pnpm/fast-xml-parser@4.0.11/node_modules/fast-xml-parser/src/xmlparser/DocTypeReader.js
var require_DocTypeReader = __commonJS({
  "../../node_modules/.pnpm/fast-xml-parser@4.0.11/node_modules/fast-xml-parser/src/xmlparser/DocTypeReader.js"(exports, module2) {
    function readDocType(xmlData, i) {
      const entities = {};
      if (xmlData[i + 3] === "O" && xmlData[i + 4] === "C" && xmlData[i + 5] === "T" && xmlData[i + 6] === "Y" && xmlData[i + 7] === "P" && xmlData[i + 8] === "E") {
        i = i + 9;
        let angleBracketsCount = 1;
        let hasBody = false, entity = false, comment = false;
        let exp = "";
        for (; i < xmlData.length; i++) {
          if (xmlData[i] === "<") {
            if (hasBody && xmlData[i + 1] === "!" && xmlData[i + 2] === "E" && xmlData[i + 3] === "N" && xmlData[i + 4] === "T" && xmlData[i + 5] === "I" && xmlData[i + 6] === "T" && xmlData[i + 7] === "Y") {
              i += 7;
              entity = true;
            } else if (hasBody && xmlData[i + 1] === "!" && xmlData[i + 2] === "E" && xmlData[i + 3] === "L" && xmlData[i + 4] === "E" && xmlData[i + 5] === "M" && xmlData[i + 6] === "E" && xmlData[i + 7] === "N" && xmlData[i + 8] === "T") {
              i += 8;
            } else if (hasBody && xmlData[i + 1] === "!" && xmlData[i + 2] === "A" && xmlData[i + 3] === "T" && xmlData[i + 4] === "T" && xmlData[i + 5] === "L" && xmlData[i + 6] === "I" && xmlData[i + 7] === "S" && xmlData[i + 8] === "T") {
              i += 8;
            } else if (hasBody && xmlData[i + 1] === "!" && xmlData[i + 2] === "N" && xmlData[i + 3] === "O" && xmlData[i + 4] === "T" && xmlData[i + 5] === "A" && xmlData[i + 6] === "T" && xmlData[i + 7] === "I" && xmlData[i + 8] === "O" && xmlData[i + 9] === "N") {
              i += 9;
            } else if (
              //comment
              xmlData[i + 1] === "!" && xmlData[i + 2] === "-" && xmlData[i + 3] === "-"
            ) {
              comment = true;
            } else {
              throw new Error("Invalid DOCTYPE");
            }
            angleBracketsCount++;
            exp = "";
          } else if (xmlData[i] === ">") {
            if (comment) {
              if (xmlData[i - 1] === "-" && xmlData[i - 2] === "-") {
                comment = false;
              } else {
                throw new Error(`Invalid XML comment in DOCTYPE`);
              }
            } else if (entity) {
              parseEntityExp(exp, entities);
              entity = false;
            }
            angleBracketsCount--;
            if (angleBracketsCount === 0) {
              break;
            }
          } else if (xmlData[i] === "[") {
            hasBody = true;
          } else {
            exp += xmlData[i];
          }
        }
        if (angleBracketsCount !== 0) {
          throw new Error(`Unclosed DOCTYPE`);
        }
      } else {
        throw new Error(`Invalid Tag instead of DOCTYPE`);
      }
      return { entities, i };
    }
    var entityRegex = RegExp(`^\\s([a-zA-z0-0]+)[ 	](['"])([^&]+)\\2`);
    function parseEntityExp(exp, entities) {
      const match = entityRegex.exec(exp);
      if (match) {
        entities[match[1]] = {
          regx: RegExp(`&${match[1]};`, "g"),
          val: match[3]
        };
      }
    }
    module2.exports = readDocType;
  }
});

// ../../node_modules/.pnpm/strnum@1.0.5/node_modules/strnum/strnum.js
var require_strnum = __commonJS({
  "../../node_modules/.pnpm/strnum@1.0.5/node_modules/strnum/strnum.js"(exports, module2) {
    var hexRegex = /^[-+]?0x[a-fA-F0-9]+$/;
    var numRegex = /^([\-\+])?(0*)(\.[0-9]+([eE]\-?[0-9]+)?|[0-9]+(\.[0-9]+([eE]\-?[0-9]+)?)?)$/;
    if (!Number.parseInt && window.parseInt) {
      Number.parseInt = window.parseInt;
    }
    if (!Number.parseFloat && window.parseFloat) {
      Number.parseFloat = window.parseFloat;
    }
    var consider = {
      hex: true,
      leadingZeros: true,
      decimalPoint: ".",
      eNotation: true
      //skipLike: /regex/
    };
    function toNumber(str, options = {}) {
      options = Object.assign({}, consider, options);
      if (!str || typeof str !== "string")
        return str;
      let trimmedStr = str.trim();
      if (options.skipLike !== void 0 && options.skipLike.test(trimmedStr))
        return str;
      else if (options.hex && hexRegex.test(trimmedStr)) {
        return Number.parseInt(trimmedStr, 16);
      } else {
        const match = numRegex.exec(trimmedStr);
        if (match) {
          const sign = match[1];
          const leadingZeros = match[2];
          let numTrimmedByZeros = trimZeros(match[3]);
          const eNotation = match[4] || match[6];
          if (!options.leadingZeros && leadingZeros.length > 0 && sign && trimmedStr[2] !== ".")
            return str;
          else if (!options.leadingZeros && leadingZeros.length > 0 && !sign && trimmedStr[1] !== ".")
            return str;
          else {
            const num = Number(trimmedStr);
            const numStr = "" + num;
            if (numStr.search(/[eE]/) !== -1) {
              if (options.eNotation)
                return num;
              else
                return str;
            } else if (eNotation) {
              if (options.eNotation)
                return num;
              else
                return str;
            } else if (trimmedStr.indexOf(".") !== -1) {
              if (numStr === "0" && numTrimmedByZeros === "")
                return num;
              else if (numStr === numTrimmedByZeros)
                return num;
              else if (sign && numStr === "-" + numTrimmedByZeros)
                return num;
              else
                return str;
            }
            if (leadingZeros) {
              if (numTrimmedByZeros === numStr)
                return num;
              else if (sign + numTrimmedByZeros === numStr)
                return num;
              else
                return str;
            }
            if (trimmedStr === numStr)
              return num;
            else if (trimmedStr === sign + numStr)
              return num;
            return str;
          }
        } else {
          return str;
        }
      }
    }
    function trimZeros(numStr) {
      if (numStr && numStr.indexOf(".") !== -1) {
        numStr = numStr.replace(/0+$/, "");
        if (numStr === ".")
          numStr = "0";
        else if (numStr[0] === ".")
          numStr = "0" + numStr;
        else if (numStr[numStr.length - 1] === ".")
          numStr = numStr.substr(0, numStr.length - 1);
        return numStr;
      }
      return numStr;
    }
    module2.exports = toNumber;
  }
});

// ../../node_modules/.pnpm/fast-xml-parser@4.0.11/node_modules/fast-xml-parser/src/xmlparser/OrderedObjParser.js
var require_OrderedObjParser = __commonJS({
  "../../node_modules/.pnpm/fast-xml-parser@4.0.11/node_modules/fast-xml-parser/src/xmlparser/OrderedObjParser.js"(exports, module2) {
    "use strict";
    var util3 = require_util();
    var xmlNode = require_xmlNode();
    var readDocType = require_DocTypeReader();
    var toNumber = require_strnum();
    var regx = "<((!\\[CDATA\\[([\\s\\S]*?)(]]>))|((NAME:)?(NAME))([^>]*)>|((\\/)(NAME)\\s*>))([^<]*)".replace(/NAME/g, util3.nameRegexp);
    var OrderedObjParser = class {
      constructor(options) {
        this.options = options;
        this.currentNode = null;
        this.tagsNodeStack = [];
        this.docTypeEntities = {};
        this.lastEntities = {
          "apos": { regex: /&(apos|#39|#x27);/g, val: "'" },
          "gt": { regex: /&(gt|#62|#x3E);/g, val: ">" },
          "lt": { regex: /&(lt|#60|#x3C);/g, val: "<" },
          "quot": { regex: /&(quot|#34|#x22);/g, val: '"' }
        };
        this.ampEntity = { regex: /&(amp|#38|#x26);/g, val: "&" };
        this.htmlEntities = {
          "space": { regex: /&(nbsp|#160);/g, val: " " },
          // "lt" : { regex: /&(lt|#60);/g, val: "<" },
          // "gt" : { regex: /&(gt|#62);/g, val: ">" },
          // "amp" : { regex: /&(amp|#38);/g, val: "&" },
          // "quot" : { regex: /&(quot|#34);/g, val: "\"" },
          // "apos" : { regex: /&(apos|#39);/g, val: "'" },
          "cent": { regex: /&(cent|#162);/g, val: "\xA2" },
          "pound": { regex: /&(pound|#163);/g, val: "\xA3" },
          "yen": { regex: /&(yen|#165);/g, val: "\xA5" },
          "euro": { regex: /&(euro|#8364);/g, val: "\u20AC" },
          "copyright": { regex: /&(copy|#169);/g, val: "\xA9" },
          "reg": { regex: /&(reg|#174);/g, val: "\xAE" },
          "inr": { regex: /&(inr|#8377);/g, val: "\u20B9" }
        };
        this.addExternalEntities = addExternalEntities;
        this.parseXml = parseXml;
        this.parseTextData = parseTextData;
        this.resolveNameSpace = resolveNameSpace;
        this.buildAttributesMap = buildAttributesMap;
        this.isItStopNode = isItStopNode;
        this.replaceEntitiesValue = replaceEntitiesValue;
        this.readStopNodeData = readStopNodeData;
        this.saveTextToParentTag = saveTextToParentTag;
      }
    };
    function addExternalEntities(externalEntities) {
      const entKeys = Object.keys(externalEntities);
      for (let i = 0; i < entKeys.length; i++) {
        const ent = entKeys[i];
        this.lastEntities[ent] = {
          regex: new RegExp("&" + ent + ";", "g"),
          val: externalEntities[ent]
        };
      }
    }
    function parseTextData(val, tagName, jPath, dontTrim, hasAttributes, isLeafNode, escapeEntities) {
      if (val !== void 0) {
        if (this.options.trimValues && !dontTrim) {
          val = val.trim();
        }
        if (val.length > 0) {
          if (!escapeEntities)
            val = this.replaceEntitiesValue(val);
          const newval = this.options.tagValueProcessor(tagName, val, jPath, hasAttributes, isLeafNode);
          if (newval === null || newval === void 0) {
            return val;
          } else if (typeof newval !== typeof val || newval !== val) {
            return newval;
          } else if (this.options.trimValues) {
            return parseValue(val, this.options.parseTagValue, this.options.numberParseOptions);
          } else {
            const trimmedVal = val.trim();
            if (trimmedVal === val) {
              return parseValue(val, this.options.parseTagValue, this.options.numberParseOptions);
            } else {
              return val;
            }
          }
        }
      }
    }
    function resolveNameSpace(tagname) {
      if (this.options.removeNSPrefix) {
        const tags = tagname.split(":");
        const prefix = tagname.charAt(0) === "/" ? "/" : "";
        if (tags[0] === "xmlns") {
          return "";
        }
        if (tags.length === 2) {
          tagname = prefix + tags[1];
        }
      }
      return tagname;
    }
    var attrsRegx = new RegExp(`([^\\s=]+)\\s*(=\\s*(['"])([\\s\\S]*?)\\3)?`, "gm");
    function buildAttributesMap(attrStr, jPath) {
      if (!this.options.ignoreAttributes && typeof attrStr === "string") {
        const matches = util3.getAllMatches(attrStr, attrsRegx);
        const len = matches.length;
        const attrs = {};
        for (let i = 0; i < len; i++) {
          const attrName = this.resolveNameSpace(matches[i][1]);
          let oldVal = matches[i][4];
          const aName = this.options.attributeNamePrefix + attrName;
          if (attrName.length) {
            if (oldVal !== void 0) {
              if (this.options.trimValues) {
                oldVal = oldVal.trim();
              }
              oldVal = this.replaceEntitiesValue(oldVal);
              const newVal = this.options.attributeValueProcessor(attrName, oldVal, jPath);
              if (newVal === null || newVal === void 0) {
                attrs[aName] = oldVal;
              } else if (typeof newVal !== typeof oldVal || newVal !== oldVal) {
                attrs[aName] = newVal;
              } else {
                attrs[aName] = parseValue(
                  oldVal,
                  this.options.parseAttributeValue,
                  this.options.numberParseOptions
                );
              }
            } else if (this.options.allowBooleanAttributes) {
              attrs[aName] = true;
            }
          }
        }
        if (!Object.keys(attrs).length) {
          return;
        }
        if (this.options.attributesGroupName) {
          const attrCollection = {};
          attrCollection[this.options.attributesGroupName] = attrs;
          return attrCollection;
        }
        return attrs;
      }
    }
    var parseXml = function(xmlData) {
      xmlData = xmlData.replace(/\r\n?/g, "\n");
      const xmlObj = new xmlNode("!xml");
      let currentNode = xmlObj;
      let textData = "";
      let jPath = "";
      for (let i = 0; i < xmlData.length; i++) {
        const ch = xmlData[i];
        if (ch === "<") {
          if (xmlData[i + 1] === "/") {
            const closeIndex = findClosingIndex(xmlData, ">", i, "Closing Tag is not closed.");
            let tagName = xmlData.substring(i + 2, closeIndex).trim();
            if (this.options.removeNSPrefix) {
              const colonIndex = tagName.indexOf(":");
              if (colonIndex !== -1) {
                tagName = tagName.substr(colonIndex + 1);
              }
            }
            if (this.options.transformTagName) {
              tagName = this.options.transformTagName(tagName);
            }
            if (currentNode) {
              textData = this.saveTextToParentTag(textData, currentNode, jPath);
            }
            jPath = jPath.substr(0, jPath.lastIndexOf("."));
            currentNode = this.tagsNodeStack.pop();
            textData = "";
            i = closeIndex;
          } else if (xmlData[i + 1] === "?") {
            let tagData = readTagExp(xmlData, i, false, "?>");
            if (!tagData)
              throw new Error("Pi Tag is not closed.");
            textData = this.saveTextToParentTag(textData, currentNode, jPath);
            if (this.options.ignoreDeclaration && tagData.tagName === "?xml" || this.options.ignorePiTags) {
            } else {
              const childNode = new xmlNode(tagData.tagName);
              childNode.add(this.options.textNodeName, "");
              if (tagData.tagName !== tagData.tagExp && tagData.attrExpPresent) {
                childNode[":@"] = this.buildAttributesMap(tagData.tagExp, jPath);
              }
              currentNode.addChild(childNode);
            }
            i = tagData.closeIndex + 1;
          } else if (xmlData.substr(i + 1, 3) === "!--") {
            const endIndex = findClosingIndex(xmlData, "-->", i + 4, "Comment is not closed.");
            if (this.options.commentPropName) {
              const comment = xmlData.substring(i + 4, endIndex - 2);
              textData = this.saveTextToParentTag(textData, currentNode, jPath);
              currentNode.add(this.options.commentPropName, [{ [this.options.textNodeName]: comment }]);
            }
            i = endIndex;
          } else if (xmlData.substr(i + 1, 2) === "!D") {
            const result = readDocType(xmlData, i);
            this.docTypeEntities = result.entities;
            i = result.i;
          } else if (xmlData.substr(i + 1, 2) === "![") {
            const closeIndex = findClosingIndex(xmlData, "]]>", i, "CDATA is not closed.") - 2;
            const tagExp = xmlData.substring(i + 9, closeIndex);
            textData = this.saveTextToParentTag(textData, currentNode, jPath);
            if (this.options.cdataPropName) {
              currentNode.add(this.options.cdataPropName, [{ [this.options.textNodeName]: tagExp }]);
            } else {
              let val = this.parseTextData(tagExp, currentNode.tagname, jPath, true, false, true);
              if (val == void 0)
                val = "";
              currentNode.add(this.options.textNodeName, val);
            }
            i = closeIndex + 2;
          } else {
            let result = readTagExp(xmlData, i, this.options.removeNSPrefix);
            let tagName = result.tagName;
            let tagExp = result.tagExp;
            let attrExpPresent = result.attrExpPresent;
            let closeIndex = result.closeIndex;
            if (this.options.transformTagName) {
              tagName = this.options.transformTagName(tagName);
            }
            if (currentNode && textData) {
              if (currentNode.tagname !== "!xml") {
                textData = this.saveTextToParentTag(textData, currentNode, jPath, false);
              }
            }
            if (tagName !== xmlObj.tagname) {
              jPath += jPath ? "." + tagName : tagName;
            }
            const lastTag = currentNode;
            if (lastTag && this.options.unpairedTags.indexOf(lastTag.tagname) !== -1) {
              currentNode = this.tagsNodeStack.pop();
            }
            if (this.isItStopNode(this.options.stopNodes, jPath, tagName)) {
              let tagContent = "";
              if (tagExp.length > 0 && tagExp.lastIndexOf("/") === tagExp.length - 1) {
                i = result.closeIndex;
              } else if (this.options.unpairedTags.indexOf(tagName) !== -1) {
                i = result.closeIndex;
              } else {
                const result2 = this.readStopNodeData(xmlData, tagName, closeIndex + 1);
                if (!result2)
                  throw new Error(`Unexpected end of ${tagName}`);
                i = result2.i;
                tagContent = result2.tagContent;
              }
              const childNode = new xmlNode(tagName);
              if (tagName !== tagExp && attrExpPresent) {
                childNode[":@"] = this.buildAttributesMap(tagExp, jPath);
              }
              if (tagContent) {
                tagContent = this.parseTextData(tagContent, tagName, jPath, true, attrExpPresent, true, true);
              }
              jPath = jPath.substr(0, jPath.lastIndexOf("."));
              childNode.add(this.options.textNodeName, tagContent);
              currentNode.addChild(childNode);
            } else {
              if (tagExp.length > 0 && tagExp.lastIndexOf("/") === tagExp.length - 1) {
                if (tagName[tagName.length - 1] === "/") {
                  tagName = tagName.substr(0, tagName.length - 1);
                  tagExp = tagName;
                } else {
                  tagExp = tagExp.substr(0, tagExp.length - 1);
                }
                if (this.options.transformTagName) {
                  tagName = this.options.transformTagName(tagName);
                }
                const childNode = new xmlNode(tagName);
                if (tagName !== tagExp && attrExpPresent) {
                  childNode[":@"] = this.buildAttributesMap(tagExp, jPath);
                }
                jPath = jPath.substr(0, jPath.lastIndexOf("."));
                currentNode.addChild(childNode);
              } else {
                const childNode = new xmlNode(tagName);
                this.tagsNodeStack.push(currentNode);
                if (tagName !== tagExp && attrExpPresent) {
                  childNode[":@"] = this.buildAttributesMap(tagExp, jPath);
                }
                currentNode.addChild(childNode);
                currentNode = childNode;
              }
              textData = "";
              i = closeIndex;
            }
          }
        } else {
          textData += xmlData[i];
        }
      }
      return xmlObj.child;
    };
    var replaceEntitiesValue = function(val) {
      if (this.options.processEntities) {
        for (let entityName in this.docTypeEntities) {
          const entity = this.docTypeEntities[entityName];
          val = val.replace(entity.regx, entity.val);
        }
        for (let entityName in this.lastEntities) {
          const entity = this.lastEntities[entityName];
          val = val.replace(entity.regex, entity.val);
        }
        if (this.options.htmlEntities) {
          for (let entityName in this.htmlEntities) {
            const entity = this.htmlEntities[entityName];
            val = val.replace(entity.regex, entity.val);
          }
        }
        val = val.replace(this.ampEntity.regex, this.ampEntity.val);
      }
      return val;
    };
    function saveTextToParentTag(textData, currentNode, jPath, isLeafNode) {
      if (textData) {
        if (isLeafNode === void 0)
          isLeafNode = Object.keys(currentNode.child).length === 0;
        textData = this.parseTextData(
          textData,
          currentNode.tagname,
          jPath,
          false,
          currentNode[":@"] ? Object.keys(currentNode[":@"]).length !== 0 : false,
          isLeafNode
        );
        if (textData !== void 0 && textData !== "")
          currentNode.add(this.options.textNodeName, textData);
        textData = "";
      }
      return textData;
    }
    function isItStopNode(stopNodes, jPath, currentTagName) {
      const allNodesExp = "*." + currentTagName;
      for (const stopNodePath in stopNodes) {
        const stopNodeExp = stopNodes[stopNodePath];
        if (allNodesExp === stopNodeExp || jPath === stopNodeExp)
          return true;
      }
      return false;
    }
    function tagExpWithClosingIndex(xmlData, i, closingChar = ">") {
      let attrBoundary;
      let tagExp = "";
      for (let index = i; index < xmlData.length; index++) {
        let ch = xmlData[index];
        if (attrBoundary) {
          if (ch === attrBoundary)
            attrBoundary = "";
        } else if (ch === '"' || ch === "'") {
          attrBoundary = ch;
        } else if (ch === closingChar[0]) {
          if (closingChar[1]) {
            if (xmlData[index + 1] === closingChar[1]) {
              return {
                data: tagExp,
                index
              };
            }
          } else {
            return {
              data: tagExp,
              index
            };
          }
        } else if (ch === "	") {
          ch = " ";
        }
        tagExp += ch;
      }
    }
    function findClosingIndex(xmlData, str, i, errMsg) {
      const closingIndex = xmlData.indexOf(str, i);
      if (closingIndex === -1) {
        throw new Error(errMsg);
      } else {
        return closingIndex + str.length - 1;
      }
    }
    function readTagExp(xmlData, i, removeNSPrefix, closingChar = ">") {
      const result = tagExpWithClosingIndex(xmlData, i + 1, closingChar);
      if (!result)
        return;
      let tagExp = result.data;
      const closeIndex = result.index;
      const separatorIndex = tagExp.search(/\s/);
      let tagName = tagExp;
      let attrExpPresent = true;
      if (separatorIndex !== -1) {
        tagName = tagExp.substr(0, separatorIndex).replace(/\s\s*$/, "");
        tagExp = tagExp.substr(separatorIndex + 1);
      }
      if (removeNSPrefix) {
        const colonIndex = tagName.indexOf(":");
        if (colonIndex !== -1) {
          tagName = tagName.substr(colonIndex + 1);
          attrExpPresent = tagName !== result.data.substr(colonIndex + 1);
        }
      }
      return {
        tagName,
        tagExp,
        closeIndex,
        attrExpPresent
      };
    }
    function readStopNodeData(xmlData, tagName, i) {
      const startIndex = i;
      let openTagCount = 1;
      for (; i < xmlData.length; i++) {
        if (xmlData[i] === "<") {
          if (xmlData[i + 1] === "/") {
            const closeIndex = findClosingIndex(xmlData, ">", i, `${tagName} is not closed`);
            let closeTagName = xmlData.substring(i + 2, closeIndex).trim();
            if (closeTagName === tagName) {
              openTagCount--;
              if (openTagCount === 0) {
                return {
                  tagContent: xmlData.substring(startIndex, i),
                  i: closeIndex
                };
              }
            }
            i = closeIndex;
          } else if (xmlData[i + 1] === "?") {
            const closeIndex = findClosingIndex(xmlData, "?>", i + 1, "StopNode is not closed.");
            i = closeIndex;
          } else if (xmlData.substr(i + 1, 3) === "!--") {
            const closeIndex = findClosingIndex(xmlData, "-->", i + 3, "StopNode is not closed.");
            i = closeIndex;
          } else if (xmlData.substr(i + 1, 2) === "![") {
            const closeIndex = findClosingIndex(xmlData, "]]>", i, "StopNode is not closed.") - 2;
            i = closeIndex;
          } else {
            const tagData = readTagExp(xmlData, i, ">");
            if (tagData) {
              const openTagName = tagData && tagData.tagName;
              if (openTagName === tagName && tagData.tagExp[tagData.tagExp.length - 1] !== "/") {
                openTagCount++;
              }
              i = tagData.closeIndex;
            }
          }
        }
      }
    }
    function parseValue(val, shouldParse, options) {
      if (shouldParse && typeof val === "string") {
        const newval = val.trim();
        if (newval === "true")
          return true;
        else if (newval === "false")
          return false;
        else
          return toNumber(val, options);
      } else {
        if (util3.isExist(val)) {
          return val;
        } else {
          return "";
        }
      }
    }
    module2.exports = OrderedObjParser;
  }
});

// ../../node_modules/.pnpm/fast-xml-parser@4.0.11/node_modules/fast-xml-parser/src/xmlparser/node2json.js
var require_node2json = __commonJS({
  "../../node_modules/.pnpm/fast-xml-parser@4.0.11/node_modules/fast-xml-parser/src/xmlparser/node2json.js"(exports) {
    "use strict";
    function prettify(node, options) {
      return compress(node, options);
    }
    function compress(arr, options, jPath) {
      let text;
      const compressedObj = {};
      for (let i = 0; i < arr.length; i++) {
        const tagObj = arr[i];
        const property = propName(tagObj);
        let newJpath = "";
        if (jPath === void 0)
          newJpath = property;
        else
          newJpath = jPath + "." + property;
        if (property === options.textNodeName) {
          if (text === void 0)
            text = tagObj[property];
          else
            text += "" + tagObj[property];
        } else if (property === void 0) {
          continue;
        } else if (tagObj[property]) {
          let val = compress(tagObj[property], options, newJpath);
          const isLeaf = isLeafTag(val, options);
          if (tagObj[":@"]) {
            assignAttributes(val, tagObj[":@"], newJpath, options);
          } else if (Object.keys(val).length === 1 && val[options.textNodeName] !== void 0 && !options.alwaysCreateTextNode) {
            val = val[options.textNodeName];
          } else if (Object.keys(val).length === 0) {
            if (options.alwaysCreateTextNode)
              val[options.textNodeName] = "";
            else
              val = "";
          }
          if (compressedObj[property] !== void 0 && compressedObj.hasOwnProperty(property)) {
            if (!Array.isArray(compressedObj[property])) {
              compressedObj[property] = [compressedObj[property]];
            }
            compressedObj[property].push(val);
          } else {
            if (options.isArray(property, newJpath, isLeaf)) {
              compressedObj[property] = [val];
            } else {
              compressedObj[property] = val;
            }
          }
        }
      }
      if (typeof text === "string") {
        if (text.length > 0)
          compressedObj[options.textNodeName] = text;
      } else if (text !== void 0)
        compressedObj[options.textNodeName] = text;
      return compressedObj;
    }
    function propName(obj) {
      const keys = Object.keys(obj);
      for (let i = 0; i < keys.length; i++) {
        const key = keys[i];
        if (key !== ":@")
          return key;
      }
    }
    function assignAttributes(obj, attrMap, jpath, options) {
      if (attrMap) {
        const keys = Object.keys(attrMap);
        const len = keys.length;
        for (let i = 0; i < len; i++) {
          const atrrName = keys[i];
          if (options.isArray(atrrName, jpath + "." + atrrName, true, true)) {
            obj[atrrName] = [attrMap[atrrName]];
          } else {
            obj[atrrName] = attrMap[atrrName];
          }
        }
      }
    }
    function isLeafTag(obj, options) {
      const propCount = Object.keys(obj).length;
      if (propCount === 0 || propCount === 1 && obj[options.textNodeName])
        return true;
      return false;
    }
    exports.prettify = prettify;
  }
});

// ../../node_modules/.pnpm/fast-xml-parser@4.0.11/node_modules/fast-xml-parser/src/xmlparser/XMLParser.js
var require_XMLParser = __commonJS({
  "../../node_modules/.pnpm/fast-xml-parser@4.0.11/node_modules/fast-xml-parser/src/xmlparser/XMLParser.js"(exports, module2) {
    var { buildOptions } = require_OptionsBuilder();
    var OrderedObjParser = require_OrderedObjParser();
    var { prettify } = require_node2json();
    var validator = require_validator();
    var XMLParser = class {
      constructor(options) {
        this.externalEntities = {};
        this.options = buildOptions(options);
      }
      /**
       * Parse XML dats to JS object 
       * @param {string|Buffer} xmlData 
       * @param {boolean|Object} validationOption 
       */
      parse(xmlData, validationOption) {
        if (typeof xmlData === "string") {
        } else if (xmlData.toString) {
          xmlData = xmlData.toString();
        } else {
          throw new Error("XML data is accepted in String or Bytes[] form.");
        }
        if (validationOption) {
          if (validationOption === true)
            validationOption = {};
          const result = validator.validate(xmlData, validationOption);
          if (result !== true) {
            throw Error(`${result.err.msg}:${result.err.line}:${result.err.col}`);
          }
        }
        const orderedObjParser = new OrderedObjParser(this.options);
        orderedObjParser.addExternalEntities(this.externalEntities);
        const orderedResult = orderedObjParser.parseXml(xmlData);
        if (this.options.preserveOrder || orderedResult === void 0)
          return orderedResult;
        else
          return prettify(orderedResult, this.options);
      }
      /**
       * Add Entity which is not by default supported by this library
       * @param {string} key 
       * @param {string} value 
       */
      addEntity(key, value) {
        if (value.indexOf("&") !== -1) {
          throw new Error("Entity value can't have '&'");
        } else if (key.indexOf("&") !== -1 || key.indexOf(";") !== -1) {
          throw new Error("An entity must be set without '&' and ';'. Eg. use '#xD' for '&#xD;'");
        } else if (value === "&") {
          throw new Error("An entity with value '&' is not permitted");
        } else {
          this.externalEntities[key] = value;
        }
      }
    };
    module2.exports = XMLParser;
  }
});

// ../../node_modules/.pnpm/fast-xml-parser@4.0.11/node_modules/fast-xml-parser/src/xmlbuilder/orderedJs2Xml.js
var require_orderedJs2Xml = __commonJS({
  "../../node_modules/.pnpm/fast-xml-parser@4.0.11/node_modules/fast-xml-parser/src/xmlbuilder/orderedJs2Xml.js"(exports, module2) {
    var EOL = "\n";
    function toXml(jArray, options) {
      return arrToStr(jArray, options, "", 0);
    }
    function arrToStr(arr, options, jPath, level) {
      let xmlStr = "";
      let indentation = "";
      if (options.format && options.indentBy.length > 0) {
        indentation = EOL + "" + options.indentBy.repeat(level);
      }
      for (let i = 0; i < arr.length; i++) {
        const tagObj = arr[i];
        const tagName = propName(tagObj);
        let newJPath = "";
        if (jPath.length === 0)
          newJPath = tagName;
        else
          newJPath = `${jPath}.${tagName}`;
        if (tagName === options.textNodeName) {
          let tagText = tagObj[tagName];
          if (!isStopNode(newJPath, options)) {
            tagText = options.tagValueProcessor(tagName, tagText);
            tagText = replaceEntitiesValue(tagText, options);
          }
          xmlStr += indentation + tagText;
          continue;
        } else if (tagName === options.cdataPropName) {
          xmlStr += indentation + `<![CDATA[${tagObj[tagName][0][options.textNodeName]}]]>`;
          continue;
        } else if (tagName === options.commentPropName) {
          xmlStr += indentation + `<!--${tagObj[tagName][0][options.textNodeName]}-->`;
          continue;
        } else if (tagName[0] === "?") {
          const attStr2 = attr_to_str(tagObj[":@"], options);
          const tempInd = tagName === "?xml" ? "" : indentation;
          let piTextNodeName = tagObj[tagName][0][options.textNodeName];
          piTextNodeName = piTextNodeName.length !== 0 ? " " + piTextNodeName : "";
          xmlStr += tempInd + `<${tagName}${piTextNodeName}${attStr2}?>`;
          continue;
        }
        const attStr = attr_to_str(tagObj[":@"], options);
        let tagStart = indentation + `<${tagName}${attStr}`;
        let tagValue = arrToStr(tagObj[tagName], options, newJPath, level + 1);
        if (options.unpairedTags.indexOf(tagName) !== -1) {
          if (options.suppressUnpairedNode)
            xmlStr += tagStart + ">";
          else
            xmlStr += tagStart + "/>";
        } else if ((!tagValue || tagValue.length === 0) && options.suppressEmptyNode) {
          xmlStr += tagStart + "/>";
        } else {
          xmlStr += tagStart + `>${tagValue}${indentation}</${tagName}>`;
        }
      }
      return xmlStr;
    }
    function propName(obj) {
      const keys = Object.keys(obj);
      for (let i = 0; i < keys.length; i++) {
        const key = keys[i];
        if (key !== ":@")
          return key;
      }
    }
    function attr_to_str(attrMap, options) {
      let attrStr = "";
      if (attrMap && !options.ignoreAttributes) {
        for (let attr in attrMap) {
          let attrVal = options.attributeValueProcessor(attr, attrMap[attr]);
          attrVal = replaceEntitiesValue(attrVal, options);
          if (attrVal === true && options.suppressBooleanAttributes) {
            attrStr += ` ${attr.substr(options.attributeNamePrefix.length)}`;
          } else {
            attrStr += ` ${attr.substr(options.attributeNamePrefix.length)}="${attrVal}"`;
          }
        }
      }
      return attrStr;
    }
    function isStopNode(jPath, options) {
      jPath = jPath.substr(0, jPath.length - options.textNodeName.length - 1);
      let tagName = jPath.substr(jPath.lastIndexOf(".") + 1);
      for (let index in options.stopNodes) {
        if (options.stopNodes[index] === jPath || options.stopNodes[index] === "*." + tagName)
          return true;
      }
      return false;
    }
    function replaceEntitiesValue(textValue, options) {
      if (textValue && textValue.length > 0 && options.processEntities) {
        for (let i = 0; i < options.entities.length; i++) {
          const entity = options.entities[i];
          textValue = textValue.replace(entity.regex, entity.val);
        }
      }
      return textValue;
    }
    module2.exports = toXml;
  }
});

// ../../node_modules/.pnpm/fast-xml-parser@4.0.11/node_modules/fast-xml-parser/src/xmlbuilder/json2xml.js
var require_json2xml = __commonJS({
  "../../node_modules/.pnpm/fast-xml-parser@4.0.11/node_modules/fast-xml-parser/src/xmlbuilder/json2xml.js"(exports, module2) {
    "use strict";
    var buildFromOrderedJs = require_orderedJs2Xml();
    var defaultOptions = {
      attributeNamePrefix: "@_",
      attributesGroupName: false,
      textNodeName: "#text",
      ignoreAttributes: true,
      cdataPropName: false,
      format: false,
      indentBy: "  ",
      suppressEmptyNode: false,
      suppressUnpairedNode: true,
      suppressBooleanAttributes: true,
      tagValueProcessor: function(key, a) {
        return a;
      },
      attributeValueProcessor: function(attrName, a) {
        return a;
      },
      preserveOrder: false,
      commentPropName: false,
      unpairedTags: [],
      entities: [
        { regex: new RegExp("&", "g"), val: "&amp;" },
        //it must be on top
        { regex: new RegExp(">", "g"), val: "&gt;" },
        { regex: new RegExp("<", "g"), val: "&lt;" },
        { regex: new RegExp("'", "g"), val: "&apos;" },
        { regex: new RegExp('"', "g"), val: "&quot;" }
      ],
      processEntities: true,
      stopNodes: [],
      transformTagName: false
    };
    function Builder(options) {
      this.options = Object.assign({}, defaultOptions, options);
      if (this.options.ignoreAttributes || this.options.attributesGroupName) {
        this.isAttribute = function() {
          return false;
        };
      } else {
        this.attrPrefixLen = this.options.attributeNamePrefix.length;
        this.isAttribute = isAttribute;
      }
      this.processTextOrObjNode = processTextOrObjNode;
      if (this.options.format) {
        this.indentate = indentate;
        this.tagEndChar = ">\n";
        this.newLine = "\n";
      } else {
        this.indentate = function() {
          return "";
        };
        this.tagEndChar = ">";
        this.newLine = "";
      }
      if (this.options.suppressEmptyNode) {
        this.buildTextNode = buildEmptyTextNode;
        this.buildObjNode = buildEmptyObjNode;
      } else {
        this.buildTextNode = buildTextValNode;
        this.buildObjNode = buildObjectNode;
      }
      this.buildTextValNode = buildTextValNode;
      this.buildObjectNode = buildObjectNode;
      this.replaceEntitiesValue = replaceEntitiesValue;
      this.buildAttrPairStr = buildAttrPairStr;
    }
    Builder.prototype.build = function(jObj) {
      if (this.options.preserveOrder) {
        return buildFromOrderedJs(jObj, this.options);
      } else {
        if (Array.isArray(jObj) && this.options.arrayNodeName && this.options.arrayNodeName.length > 1) {
          jObj = {
            [this.options.arrayNodeName]: jObj
          };
        }
        return this.j2x(jObj, 0).val;
      }
    };
    Builder.prototype.j2x = function(jObj, level) {
      let attrStr = "";
      let val = "";
      for (let key in jObj) {
        if (typeof jObj[key] === "undefined") {
        } else if (jObj[key] === null) {
          if (key[0] === "?")
            val += this.indentate(level) + "<" + key + "?" + this.tagEndChar;
          else
            val += this.indentate(level) + "<" + key + "/" + this.tagEndChar;
        } else if (jObj[key] instanceof Date) {
          val += this.buildTextNode(jObj[key], key, "", level);
        } else if (typeof jObj[key] !== "object") {
          const attr = this.isAttribute(key);
          if (attr) {
            attrStr += this.buildAttrPairStr(attr, "" + jObj[key]);
          } else {
            if (key === this.options.textNodeName) {
              let newval = this.options.tagValueProcessor(key, "" + jObj[key]);
              val += this.replaceEntitiesValue(newval);
            } else {
              val += this.buildTextNode(jObj[key], key, "", level);
            }
          }
        } else if (Array.isArray(jObj[key])) {
          const arrLen = jObj[key].length;
          for (let j = 0; j < arrLen; j++) {
            const item = jObj[key][j];
            if (typeof item === "undefined") {
            } else if (item === null) {
              if (key[0] === "?")
                val += this.indentate(level) + "<" + key + "?" + this.tagEndChar;
              else
                val += this.indentate(level) + "<" + key + "/" + this.tagEndChar;
            } else if (typeof item === "object") {
              val += this.processTextOrObjNode(item, key, level);
            } else {
              val += this.buildTextNode(item, key, "", level);
            }
          }
        } else {
          if (this.options.attributesGroupName && key === this.options.attributesGroupName) {
            const Ks = Object.keys(jObj[key]);
            const L = Ks.length;
            for (let j = 0; j < L; j++) {
              attrStr += this.buildAttrPairStr(Ks[j], "" + jObj[key][Ks[j]]);
            }
          } else {
            val += this.processTextOrObjNode(jObj[key], key, level);
          }
        }
      }
      return { attrStr, val };
    };
    function buildAttrPairStr(attrName, val) {
      val = this.options.attributeValueProcessor(attrName, "" + val);
      val = this.replaceEntitiesValue(val);
      if (this.options.suppressBooleanAttributes && val === "true") {
        return " " + attrName;
      } else
        return " " + attrName + '="' + val + '"';
    }
    function processTextOrObjNode(object, key, level) {
      const result = this.j2x(object, level + 1);
      if (object[this.options.textNodeName] !== void 0 && Object.keys(object).length === 1) {
        return this.buildTextNode(object[this.options.textNodeName], key, result.attrStr, level);
      } else {
        return this.buildObjNode(result.val, key, result.attrStr, level);
      }
    }
    function buildObjectNode(val, key, attrStr, level) {
      let tagEndExp = "</" + key + this.tagEndChar;
      let piClosingChar = "";
      if (key[0] === "?") {
        piClosingChar = "?";
        tagEndExp = "";
      }
      if (attrStr && val.indexOf("<") === -1) {
        return this.indentate(level) + "<" + key + attrStr + piClosingChar + ">" + val + tagEndExp;
      } else if (this.options.commentPropName !== false && key === this.options.commentPropName && piClosingChar.length === 0) {
        return this.indentate(level) + `<!--${val}-->` + this.newLine;
      } else {
        return this.indentate(level) + "<" + key + attrStr + piClosingChar + this.tagEndChar + val + this.indentate(level) + tagEndExp;
      }
    }
    function buildEmptyObjNode(val, key, attrStr, level) {
      if (val !== "") {
        return this.buildObjectNode(val, key, attrStr, level);
      } else {
        if (key[0] === "?")
          return this.indentate(level) + "<" + key + attrStr + "?" + this.tagEndChar;
        else
          return this.indentate(level) + "<" + key + attrStr + "/" + this.tagEndChar;
      }
    }
    function buildTextValNode(val, key, attrStr, level) {
      if (this.options.cdataPropName !== false && key === this.options.cdataPropName) {
        return this.indentate(level) + `<![CDATA[${val}]]>` + this.newLine;
      } else if (this.options.commentPropName !== false && key === this.options.commentPropName) {
        return this.indentate(level) + `<!--${val}-->` + this.newLine;
      } else {
        let textValue = this.options.tagValueProcessor(key, val);
        textValue = this.replaceEntitiesValue(textValue);
        if (textValue === "" && this.options.unpairedTags.indexOf(key) !== -1) {
          if (this.options.suppressUnpairedNode) {
            return this.indentate(level) + "<" + key + this.tagEndChar;
          } else {
            return this.indentate(level) + "<" + key + "/" + this.tagEndChar;
          }
        } else {
          return this.indentate(level) + "<" + key + attrStr + ">" + textValue + "</" + key + this.tagEndChar;
        }
      }
    }
    function replaceEntitiesValue(textValue) {
      if (textValue && textValue.length > 0 && this.options.processEntities) {
        for (let i = 0; i < this.options.entities.length; i++) {
          const entity = this.options.entities[i];
          textValue = textValue.replace(entity.regex, entity.val);
        }
      }
      return textValue;
    }
    function buildEmptyTextNode(val, key, attrStr, level) {
      if (val === "" && this.options.unpairedTags.indexOf(key) !== -1) {
        if (this.options.suppressUnpairedNode) {
          return this.indentate(level) + "<" + key + this.tagEndChar;
        } else {
          return this.indentate(level) + "<" + key + "/" + this.tagEndChar;
        }
      } else if (val !== "") {
        return this.buildTextValNode(val, key, attrStr, level);
      } else {
        if (key[0] === "?")
          return this.indentate(level) + "<" + key + attrStr + "?" + this.tagEndChar;
        else
          return this.indentate(level) + "<" + key + attrStr + "/" + this.tagEndChar;
      }
    }
    function indentate(level) {
      return this.options.indentBy.repeat(level);
    }
    function isAttribute(name) {
      if (name.startsWith(this.options.attributeNamePrefix)) {
        return name.substr(this.attrPrefixLen);
      } else {
        return false;
      }
    }
    module2.exports = Builder;
  }
});

// ../../node_modules/.pnpm/fast-xml-parser@4.0.11/node_modules/fast-xml-parser/src/fxp.js
var require_fxp = __commonJS({
  "../../node_modules/.pnpm/fast-xml-parser@4.0.11/node_modules/fast-xml-parser/src/fxp.js"(exports, module2) {
    "use strict";
    var validator = require_validator();
    var XMLParser = require_XMLParser();
    var XMLBuilder = require_json2xml();
    module2.exports = {
      XMLParser,
      XMLValidator: validator,
      XMLBuilder
    };
  }
});

// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/models/models_1.js
var require_models_1 = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/models/models_1.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.WriteGetObjectResponseRequestFilterSensitiveLog = exports.UploadPartCopyRequestFilterSensitiveLog = exports.UploadPartCopyOutputFilterSensitiveLog = exports.CopyPartResultFilterSensitiveLog = exports.UploadPartRequestFilterSensitiveLog = exports.UploadPartOutputFilterSensitiveLog = exports.SelectObjectContentRequestFilterSensitiveLog = exports.ScanRangeFilterSensitiveLog = exports.RequestProgressFilterSensitiveLog = exports.SelectObjectContentOutputFilterSensitiveLog = exports.SelectObjectContentEventStreamFilterSensitiveLog = exports.StatsEventFilterSensitiveLog = exports.StatsFilterSensitiveLog = exports.RecordsEventFilterSensitiveLog = exports.ProgressEventFilterSensitiveLog = exports.ProgressFilterSensitiveLog = exports.EndEventFilterSensitiveLog = exports.ContinuationEventFilterSensitiveLog = exports.RestoreObjectRequestFilterSensitiveLog = exports.RestoreRequestFilterSensitiveLog = exports.SelectParametersFilterSensitiveLog = exports.OutputSerializationFilterSensitiveLog = exports.JSONOutputFilterSensitiveLog = exports.CSVOutputFilterSensitiveLog = exports.InputSerializationFilterSensitiveLog = exports.ParquetInputFilterSensitiveLog = exports.JSONInputFilterSensitiveLog = exports.CSVInputFilterSensitiveLog = exports.OutputLocationFilterSensitiveLog = exports.S3LocationFilterSensitiveLog = exports.MetadataEntryFilterSensitiveLog = exports.EncryptionFilterSensitiveLog = exports.GlacierJobParametersFilterSensitiveLog = exports.RestoreObjectOutputFilterSensitiveLog = exports.PutPublicAccessBlockRequestFilterSensitiveLog = exports.PutObjectTaggingRequestFilterSensitiveLog = exports.PutObjectTaggingOutputFilterSensitiveLog = exports.PutObjectRetentionRequestFilterSensitiveLog = exports.PutObjectRetentionOutputFilterSensitiveLog = exports.SelectObjectContentEventStream = exports.RestoreRequestType = exports.QuoteFields = exports.JSONType = exports.FileHeaderInfo = exports.CompressionType = exports.ExpressionType = exports.Tier = exports.ObjectAlreadyInActiveTierError = void 0;
    var smithy_client_1 = require_dist_cjs7();
    var S3ServiceException_1 = require_S3ServiceException();
    var ObjectAlreadyInActiveTierError = class extends S3ServiceException_1.S3ServiceException {
      constructor(opts) {
        super({
          name: "ObjectAlreadyInActiveTierError",
          $fault: "client",
          ...opts
        });
        this.name = "ObjectAlreadyInActiveTierError";
        this.$fault = "client";
        Object.setPrototypeOf(this, ObjectAlreadyInActiveTierError.prototype);
      }
    };
    exports.ObjectAlreadyInActiveTierError = ObjectAlreadyInActiveTierError;
    var Tier;
    (function(Tier2) {
      Tier2["Bulk"] = "Bulk";
      Tier2["Expedited"] = "Expedited";
      Tier2["Standard"] = "Standard";
    })(Tier = exports.Tier || (exports.Tier = {}));
    var ExpressionType;
    (function(ExpressionType2) {
      ExpressionType2["SQL"] = "SQL";
    })(ExpressionType = exports.ExpressionType || (exports.ExpressionType = {}));
    var CompressionType;
    (function(CompressionType2) {
      CompressionType2["BZIP2"] = "BZIP2";
      CompressionType2["GZIP"] = "GZIP";
      CompressionType2["NONE"] = "NONE";
    })(CompressionType = exports.CompressionType || (exports.CompressionType = {}));
    var FileHeaderInfo;
    (function(FileHeaderInfo2) {
      FileHeaderInfo2["IGNORE"] = "IGNORE";
      FileHeaderInfo2["NONE"] = "NONE";
      FileHeaderInfo2["USE"] = "USE";
    })(FileHeaderInfo = exports.FileHeaderInfo || (exports.FileHeaderInfo = {}));
    var JSONType;
    (function(JSONType2) {
      JSONType2["DOCUMENT"] = "DOCUMENT";
      JSONType2["LINES"] = "LINES";
    })(JSONType = exports.JSONType || (exports.JSONType = {}));
    var QuoteFields;
    (function(QuoteFields2) {
      QuoteFields2["ALWAYS"] = "ALWAYS";
      QuoteFields2["ASNEEDED"] = "ASNEEDED";
    })(QuoteFields = exports.QuoteFields || (exports.QuoteFields = {}));
    var RestoreRequestType;
    (function(RestoreRequestType2) {
      RestoreRequestType2["SELECT"] = "SELECT";
    })(RestoreRequestType = exports.RestoreRequestType || (exports.RestoreRequestType = {}));
    var SelectObjectContentEventStream;
    (function(SelectObjectContentEventStream2) {
      SelectObjectContentEventStream2.visit = (value, visitor) => {
        if (value.Records !== void 0)
          return visitor.Records(value.Records);
        if (value.Stats !== void 0)
          return visitor.Stats(value.Stats);
        if (value.Progress !== void 0)
          return visitor.Progress(value.Progress);
        if (value.Cont !== void 0)
          return visitor.Cont(value.Cont);
        if (value.End !== void 0)
          return visitor.End(value.End);
        return visitor._(value.$unknown[0], value.$unknown[1]);
      };
    })(SelectObjectContentEventStream = exports.SelectObjectContentEventStream || (exports.SelectObjectContentEventStream = {}));
    var PutObjectRetentionOutputFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.PutObjectRetentionOutputFilterSensitiveLog = PutObjectRetentionOutputFilterSensitiveLog;
    var PutObjectRetentionRequestFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.PutObjectRetentionRequestFilterSensitiveLog = PutObjectRetentionRequestFilterSensitiveLog;
    var PutObjectTaggingOutputFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.PutObjectTaggingOutputFilterSensitiveLog = PutObjectTaggingOutputFilterSensitiveLog;
    var PutObjectTaggingRequestFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.PutObjectTaggingRequestFilterSensitiveLog = PutObjectTaggingRequestFilterSensitiveLog;
    var PutPublicAccessBlockRequestFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.PutPublicAccessBlockRequestFilterSensitiveLog = PutPublicAccessBlockRequestFilterSensitiveLog;
    var RestoreObjectOutputFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.RestoreObjectOutputFilterSensitiveLog = RestoreObjectOutputFilterSensitiveLog;
    var GlacierJobParametersFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.GlacierJobParametersFilterSensitiveLog = GlacierJobParametersFilterSensitiveLog;
    var EncryptionFilterSensitiveLog = (obj) => ({
      ...obj,
      ...obj.KMSKeyId && { KMSKeyId: smithy_client_1.SENSITIVE_STRING }
    });
    exports.EncryptionFilterSensitiveLog = EncryptionFilterSensitiveLog;
    var MetadataEntryFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.MetadataEntryFilterSensitiveLog = MetadataEntryFilterSensitiveLog;
    var S3LocationFilterSensitiveLog = (obj) => ({
      ...obj,
      ...obj.Encryption && { Encryption: (0, exports.EncryptionFilterSensitiveLog)(obj.Encryption) }
    });
    exports.S3LocationFilterSensitiveLog = S3LocationFilterSensitiveLog;
    var OutputLocationFilterSensitiveLog = (obj) => ({
      ...obj,
      ...obj.S3 && { S3: (0, exports.S3LocationFilterSensitiveLog)(obj.S3) }
    });
    exports.OutputLocationFilterSensitiveLog = OutputLocationFilterSensitiveLog;
    var CSVInputFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.CSVInputFilterSensitiveLog = CSVInputFilterSensitiveLog;
    var JSONInputFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.JSONInputFilterSensitiveLog = JSONInputFilterSensitiveLog;
    var ParquetInputFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.ParquetInputFilterSensitiveLog = ParquetInputFilterSensitiveLog;
    var InputSerializationFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.InputSerializationFilterSensitiveLog = InputSerializationFilterSensitiveLog;
    var CSVOutputFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.CSVOutputFilterSensitiveLog = CSVOutputFilterSensitiveLog;
    var JSONOutputFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.JSONOutputFilterSensitiveLog = JSONOutputFilterSensitiveLog;
    var OutputSerializationFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.OutputSerializationFilterSensitiveLog = OutputSerializationFilterSensitiveLog;
    var SelectParametersFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.SelectParametersFilterSensitiveLog = SelectParametersFilterSensitiveLog;
    var RestoreRequestFilterSensitiveLog = (obj) => ({
      ...obj,
      ...obj.OutputLocation && { OutputLocation: (0, exports.OutputLocationFilterSensitiveLog)(obj.OutputLocation) }
    });
    exports.RestoreRequestFilterSensitiveLog = RestoreRequestFilterSensitiveLog;
    var RestoreObjectRequestFilterSensitiveLog = (obj) => ({
      ...obj,
      ...obj.RestoreRequest && { RestoreRequest: (0, exports.RestoreRequestFilterSensitiveLog)(obj.RestoreRequest) }
    });
    exports.RestoreObjectRequestFilterSensitiveLog = RestoreObjectRequestFilterSensitiveLog;
    var ContinuationEventFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.ContinuationEventFilterSensitiveLog = ContinuationEventFilterSensitiveLog;
    var EndEventFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.EndEventFilterSensitiveLog = EndEventFilterSensitiveLog;
    var ProgressFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.ProgressFilterSensitiveLog = ProgressFilterSensitiveLog;
    var ProgressEventFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.ProgressEventFilterSensitiveLog = ProgressEventFilterSensitiveLog;
    var RecordsEventFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.RecordsEventFilterSensitiveLog = RecordsEventFilterSensitiveLog;
    var StatsFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.StatsFilterSensitiveLog = StatsFilterSensitiveLog;
    var StatsEventFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.StatsEventFilterSensitiveLog = StatsEventFilterSensitiveLog;
    var SelectObjectContentEventStreamFilterSensitiveLog = (obj) => {
      if (obj.Records !== void 0)
        return { Records: (0, exports.RecordsEventFilterSensitiveLog)(obj.Records) };
      if (obj.Stats !== void 0)
        return { Stats: (0, exports.StatsEventFilterSensitiveLog)(obj.Stats) };
      if (obj.Progress !== void 0)
        return { Progress: (0, exports.ProgressEventFilterSensitiveLog)(obj.Progress) };
      if (obj.Cont !== void 0)
        return { Cont: (0, exports.ContinuationEventFilterSensitiveLog)(obj.Cont) };
      if (obj.End !== void 0)
        return { End: (0, exports.EndEventFilterSensitiveLog)(obj.End) };
      if (obj.$unknown !== void 0)
        return { [obj.$unknown[0]]: "UNKNOWN" };
    };
    exports.SelectObjectContentEventStreamFilterSensitiveLog = SelectObjectContentEventStreamFilterSensitiveLog;
    var SelectObjectContentOutputFilterSensitiveLog = (obj) => ({
      ...obj,
      ...obj.Payload && { Payload: "STREAMING_CONTENT" }
    });
    exports.SelectObjectContentOutputFilterSensitiveLog = SelectObjectContentOutputFilterSensitiveLog;
    var RequestProgressFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.RequestProgressFilterSensitiveLog = RequestProgressFilterSensitiveLog;
    var ScanRangeFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.ScanRangeFilterSensitiveLog = ScanRangeFilterSensitiveLog;
    var SelectObjectContentRequestFilterSensitiveLog = (obj) => ({
      ...obj,
      ...obj.SSECustomerKey && { SSECustomerKey: smithy_client_1.SENSITIVE_STRING }
    });
    exports.SelectObjectContentRequestFilterSensitiveLog = SelectObjectContentRequestFilterSensitiveLog;
    var UploadPartOutputFilterSensitiveLog = (obj) => ({
      ...obj,
      ...obj.SSEKMSKeyId && { SSEKMSKeyId: smithy_client_1.SENSITIVE_STRING }
    });
    exports.UploadPartOutputFilterSensitiveLog = UploadPartOutputFilterSensitiveLog;
    var UploadPartRequestFilterSensitiveLog = (obj) => ({
      ...obj,
      ...obj.SSECustomerKey && { SSECustomerKey: smithy_client_1.SENSITIVE_STRING }
    });
    exports.UploadPartRequestFilterSensitiveLog = UploadPartRequestFilterSensitiveLog;
    var CopyPartResultFilterSensitiveLog = (obj) => ({
      ...obj
    });
    exports.CopyPartResultFilterSensitiveLog = CopyPartResultFilterSensitiveLog;
    var UploadPartCopyOutputFilterSensitiveLog = (obj) => ({
      ...obj,
      ...obj.SSEKMSKeyId && { SSEKMSKeyId: smithy_client_1.SENSITIVE_STRING }
    });
    exports.UploadPartCopyOutputFilterSensitiveLog = UploadPartCopyOutputFilterSensitiveLog;
    var UploadPartCopyRequestFilterSensitiveLog = (obj) => ({
      ...obj,
      ...obj.SSECustomerKey && { SSECustomerKey: smithy_client_1.SENSITIVE_STRING },
      ...obj.CopySourceSSECustomerKey && { CopySourceSSECustomerKey: smithy_client_1.SENSITIVE_STRING }
    });
    exports.UploadPartCopyRequestFilterSensitiveLog = UploadPartCopyRequestFilterSensitiveLog;
    var WriteGetObjectResponseRequestFilterSensitiveLog = (obj) => ({
      ...obj,
      ...obj.SSEKMSKeyId && { SSEKMSKeyId: smithy_client_1.SENSITIVE_STRING }
    });
    exports.WriteGetObjectResponseRequestFilterSensitiveLog = WriteGetObjectResponseRequestFilterSensitiveLog;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/protocols/Aws_restXml.js
var require_Aws_restXml = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/protocols/Aws_restXml.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.serializeAws_restXmlGetObjectTorrentCommand = exports.serializeAws_restXmlGetObjectTaggingCommand = exports.serializeAws_restXmlGetObjectRetentionCommand = exports.serializeAws_restXmlGetObjectLockConfigurationCommand = exports.serializeAws_restXmlGetObjectLegalHoldCommand = exports.serializeAws_restXmlGetObjectAttributesCommand = exports.serializeAws_restXmlGetObjectAclCommand = exports.serializeAws_restXmlGetObjectCommand = exports.serializeAws_restXmlGetBucketWebsiteCommand = exports.serializeAws_restXmlGetBucketVersioningCommand = exports.serializeAws_restXmlGetBucketTaggingCommand = exports.serializeAws_restXmlGetBucketRequestPaymentCommand = exports.serializeAws_restXmlGetBucketReplicationCommand = exports.serializeAws_restXmlGetBucketPolicyStatusCommand = exports.serializeAws_restXmlGetBucketPolicyCommand = exports.serializeAws_restXmlGetBucketOwnershipControlsCommand = exports.serializeAws_restXmlGetBucketNotificationConfigurationCommand = exports.serializeAws_restXmlGetBucketMetricsConfigurationCommand = exports.serializeAws_restXmlGetBucketLoggingCommand = exports.serializeAws_restXmlGetBucketLocationCommand = exports.serializeAws_restXmlGetBucketLifecycleConfigurationCommand = exports.serializeAws_restXmlGetBucketInventoryConfigurationCommand = exports.serializeAws_restXmlGetBucketIntelligentTieringConfigurationCommand = exports.serializeAws_restXmlGetBucketEncryptionCommand = exports.serializeAws_restXmlGetBucketCorsCommand = exports.serializeAws_restXmlGetBucketAnalyticsConfigurationCommand = exports.serializeAws_restXmlGetBucketAclCommand = exports.serializeAws_restXmlGetBucketAccelerateConfigurationCommand = exports.serializeAws_restXmlDeletePublicAccessBlockCommand = exports.serializeAws_restXmlDeleteObjectTaggingCommand = exports.serializeAws_restXmlDeleteObjectsCommand = exports.serializeAws_restXmlDeleteObjectCommand = exports.serializeAws_restXmlDeleteBucketWebsiteCommand = exports.serializeAws_restXmlDeleteBucketTaggingCommand = exports.serializeAws_restXmlDeleteBucketReplicationCommand = exports.serializeAws_restXmlDeleteBucketPolicyCommand = exports.serializeAws_restXmlDeleteBucketOwnershipControlsCommand = exports.serializeAws_restXmlDeleteBucketMetricsConfigurationCommand = exports.serializeAws_restXmlDeleteBucketLifecycleCommand = exports.serializeAws_restXmlDeleteBucketInventoryConfigurationCommand = exports.serializeAws_restXmlDeleteBucketIntelligentTieringConfigurationCommand = exports.serializeAws_restXmlDeleteBucketEncryptionCommand = exports.serializeAws_restXmlDeleteBucketCorsCommand = exports.serializeAws_restXmlDeleteBucketAnalyticsConfigurationCommand = exports.serializeAws_restXmlDeleteBucketCommand = exports.serializeAws_restXmlCreateMultipartUploadCommand = exports.serializeAws_restXmlCreateBucketCommand = exports.serializeAws_restXmlCopyObjectCommand = exports.serializeAws_restXmlCompleteMultipartUploadCommand = exports.serializeAws_restXmlAbortMultipartUploadCommand = void 0;
    exports.deserializeAws_restXmlDeleteBucketAnalyticsConfigurationCommand = exports.deserializeAws_restXmlDeleteBucketCommand = exports.deserializeAws_restXmlCreateMultipartUploadCommand = exports.deserializeAws_restXmlCreateBucketCommand = exports.deserializeAws_restXmlCopyObjectCommand = exports.deserializeAws_restXmlCompleteMultipartUploadCommand = exports.deserializeAws_restXmlAbortMultipartUploadCommand = exports.serializeAws_restXmlWriteGetObjectResponseCommand = exports.serializeAws_restXmlUploadPartCopyCommand = exports.serializeAws_restXmlUploadPartCommand = exports.serializeAws_restXmlSelectObjectContentCommand = exports.serializeAws_restXmlRestoreObjectCommand = exports.serializeAws_restXmlPutPublicAccessBlockCommand = exports.serializeAws_restXmlPutObjectTaggingCommand = exports.serializeAws_restXmlPutObjectRetentionCommand = exports.serializeAws_restXmlPutObjectLockConfigurationCommand = exports.serializeAws_restXmlPutObjectLegalHoldCommand = exports.serializeAws_restXmlPutObjectAclCommand = exports.serializeAws_restXmlPutObjectCommand = exports.serializeAws_restXmlPutBucketWebsiteCommand = exports.serializeAws_restXmlPutBucketVersioningCommand = exports.serializeAws_restXmlPutBucketTaggingCommand = exports.serializeAws_restXmlPutBucketRequestPaymentCommand = exports.serializeAws_restXmlPutBucketReplicationCommand = exports.serializeAws_restXmlPutBucketPolicyCommand = exports.serializeAws_restXmlPutBucketOwnershipControlsCommand = exports.serializeAws_restXmlPutBucketNotificationConfigurationCommand = exports.serializeAws_restXmlPutBucketMetricsConfigurationCommand = exports.serializeAws_restXmlPutBucketLoggingCommand = exports.serializeAws_restXmlPutBucketLifecycleConfigurationCommand = exports.serializeAws_restXmlPutBucketInventoryConfigurationCommand = exports.serializeAws_restXmlPutBucketIntelligentTieringConfigurationCommand = exports.serializeAws_restXmlPutBucketEncryptionCommand = exports.serializeAws_restXmlPutBucketCorsCommand = exports.serializeAws_restXmlPutBucketAnalyticsConfigurationCommand = exports.serializeAws_restXmlPutBucketAclCommand = exports.serializeAws_restXmlPutBucketAccelerateConfigurationCommand = exports.serializeAws_restXmlListPartsCommand = exports.serializeAws_restXmlListObjectVersionsCommand = exports.serializeAws_restXmlListObjectsV2Command = exports.serializeAws_restXmlListObjectsCommand = exports.serializeAws_restXmlListMultipartUploadsCommand = exports.serializeAws_restXmlListBucketsCommand = exports.serializeAws_restXmlListBucketMetricsConfigurationsCommand = exports.serializeAws_restXmlListBucketInventoryConfigurationsCommand = exports.serializeAws_restXmlListBucketIntelligentTieringConfigurationsCommand = exports.serializeAws_restXmlListBucketAnalyticsConfigurationsCommand = exports.serializeAws_restXmlHeadObjectCommand = exports.serializeAws_restXmlHeadBucketCommand = exports.serializeAws_restXmlGetPublicAccessBlockCommand = void 0;
    exports.deserializeAws_restXmlListBucketMetricsConfigurationsCommand = exports.deserializeAws_restXmlListBucketInventoryConfigurationsCommand = exports.deserializeAws_restXmlListBucketIntelligentTieringConfigurationsCommand = exports.deserializeAws_restXmlListBucketAnalyticsConfigurationsCommand = exports.deserializeAws_restXmlHeadObjectCommand = exports.deserializeAws_restXmlHeadBucketCommand = exports.deserializeAws_restXmlGetPublicAccessBlockCommand = exports.deserializeAws_restXmlGetObjectTorrentCommand = exports.deserializeAws_restXmlGetObjectTaggingCommand = exports.deserializeAws_restXmlGetObjectRetentionCommand = exports.deserializeAws_restXmlGetObjectLockConfigurationCommand = exports.deserializeAws_restXmlGetObjectLegalHoldCommand = exports.deserializeAws_restXmlGetObjectAttributesCommand = exports.deserializeAws_restXmlGetObjectAclCommand = exports.deserializeAws_restXmlGetObjectCommand = exports.deserializeAws_restXmlGetBucketWebsiteCommand = exports.deserializeAws_restXmlGetBucketVersioningCommand = exports.deserializeAws_restXmlGetBucketTaggingCommand = exports.deserializeAws_restXmlGetBucketRequestPaymentCommand = exports.deserializeAws_restXmlGetBucketReplicationCommand = exports.deserializeAws_restXmlGetBucketPolicyStatusCommand = exports.deserializeAws_restXmlGetBucketPolicyCommand = exports.deserializeAws_restXmlGetBucketOwnershipControlsCommand = exports.deserializeAws_restXmlGetBucketNotificationConfigurationCommand = exports.deserializeAws_restXmlGetBucketMetricsConfigurationCommand = exports.deserializeAws_restXmlGetBucketLoggingCommand = exports.deserializeAws_restXmlGetBucketLocationCommand = exports.deserializeAws_restXmlGetBucketLifecycleConfigurationCommand = exports.deserializeAws_restXmlGetBucketInventoryConfigurationCommand = exports.deserializeAws_restXmlGetBucketIntelligentTieringConfigurationCommand = exports.deserializeAws_restXmlGetBucketEncryptionCommand = exports.deserializeAws_restXmlGetBucketCorsCommand = exports.deserializeAws_restXmlGetBucketAnalyticsConfigurationCommand = exports.deserializeAws_restXmlGetBucketAclCommand = exports.deserializeAws_restXmlGetBucketAccelerateConfigurationCommand = exports.deserializeAws_restXmlDeletePublicAccessBlockCommand = exports.deserializeAws_restXmlDeleteObjectTaggingCommand = exports.deserializeAws_restXmlDeleteObjectsCommand = exports.deserializeAws_restXmlDeleteObjectCommand = exports.deserializeAws_restXmlDeleteBucketWebsiteCommand = exports.deserializeAws_restXmlDeleteBucketTaggingCommand = exports.deserializeAws_restXmlDeleteBucketReplicationCommand = exports.deserializeAws_restXmlDeleteBucketPolicyCommand = exports.deserializeAws_restXmlDeleteBucketOwnershipControlsCommand = exports.deserializeAws_restXmlDeleteBucketMetricsConfigurationCommand = exports.deserializeAws_restXmlDeleteBucketLifecycleCommand = exports.deserializeAws_restXmlDeleteBucketInventoryConfigurationCommand = exports.deserializeAws_restXmlDeleteBucketIntelligentTieringConfigurationCommand = exports.deserializeAws_restXmlDeleteBucketEncryptionCommand = exports.deserializeAws_restXmlDeleteBucketCorsCommand = void 0;
    exports.deserializeAws_restXmlWriteGetObjectResponseCommand = exports.deserializeAws_restXmlUploadPartCopyCommand = exports.deserializeAws_restXmlUploadPartCommand = exports.deserializeAws_restXmlSelectObjectContentCommand = exports.deserializeAws_restXmlRestoreObjectCommand = exports.deserializeAws_restXmlPutPublicAccessBlockCommand = exports.deserializeAws_restXmlPutObjectTaggingCommand = exports.deserializeAws_restXmlPutObjectRetentionCommand = exports.deserializeAws_restXmlPutObjectLockConfigurationCommand = exports.deserializeAws_restXmlPutObjectLegalHoldCommand = exports.deserializeAws_restXmlPutObjectAclCommand = exports.deserializeAws_restXmlPutObjectCommand = exports.deserializeAws_restXmlPutBucketWebsiteCommand = exports.deserializeAws_restXmlPutBucketVersioningCommand = exports.deserializeAws_restXmlPutBucketTaggingCommand = exports.deserializeAws_restXmlPutBucketRequestPaymentCommand = exports.deserializeAws_restXmlPutBucketReplicationCommand = exports.deserializeAws_restXmlPutBucketPolicyCommand = exports.deserializeAws_restXmlPutBucketOwnershipControlsCommand = exports.deserializeAws_restXmlPutBucketNotificationConfigurationCommand = exports.deserializeAws_restXmlPutBucketMetricsConfigurationCommand = exports.deserializeAws_restXmlPutBucketLoggingCommand = exports.deserializeAws_restXmlPutBucketLifecycleConfigurationCommand = exports.deserializeAws_restXmlPutBucketInventoryConfigurationCommand = exports.deserializeAws_restXmlPutBucketIntelligentTieringConfigurationCommand = exports.deserializeAws_restXmlPutBucketEncryptionCommand = exports.deserializeAws_restXmlPutBucketCorsCommand = exports.deserializeAws_restXmlPutBucketAnalyticsConfigurationCommand = exports.deserializeAws_restXmlPutBucketAclCommand = exports.deserializeAws_restXmlPutBucketAccelerateConfigurationCommand = exports.deserializeAws_restXmlListPartsCommand = exports.deserializeAws_restXmlListObjectVersionsCommand = exports.deserializeAws_restXmlListObjectsV2Command = exports.deserializeAws_restXmlListObjectsCommand = exports.deserializeAws_restXmlListMultipartUploadsCommand = exports.deserializeAws_restXmlListBucketsCommand = void 0;
    var protocol_http_1 = require_dist_cjs8();
    var smithy_client_1 = require_dist_cjs7();
    var xml_builder_1 = require_dist_cjs9();
    var fast_xml_parser_1 = require_fxp();
    var models_0_1 = require_models_0();
    var models_1_1 = require_models_1();
    var S3ServiceException_1 = require_S3ServiceException();
    var serializeAws_restXmlAbortMultipartUploadCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "x-amz-request-payer": input.RequestPayer,
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/{Key+}`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Key", () => input.Key, "{Key+}", true);
      const query = map({
        "x-id": [, "AbortMultipartUpload"],
        uploadId: [, (0, smithy_client_1.expectNonNull)(input.UploadId, `UploadId`)]
      });
      let body;
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "DELETE",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlAbortMultipartUploadCommand = serializeAws_restXmlAbortMultipartUploadCommand;
    var serializeAws_restXmlCompleteMultipartUploadCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "content-type": "application/xml",
        "x-amz-checksum-crc32": input.ChecksumCRC32,
        "x-amz-checksum-crc32c": input.ChecksumCRC32C,
        "x-amz-checksum-sha1": input.ChecksumSHA1,
        "x-amz-checksum-sha256": input.ChecksumSHA256,
        "x-amz-request-payer": input.RequestPayer,
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner,
        "x-amz-server-side-encryption-customer-algorithm": input.SSECustomerAlgorithm,
        "x-amz-server-side-encryption-customer-key": input.SSECustomerKey,
        "x-amz-server-side-encryption-customer-key-md5": input.SSECustomerKeyMD5
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/{Key+}`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Key", () => input.Key, "{Key+}", true);
      const query = map({
        "x-id": [, "CompleteMultipartUpload"],
        uploadId: [, (0, smithy_client_1.expectNonNull)(input.UploadId, `UploadId`)]
      });
      let body;
      if (input.MultipartUpload !== void 0) {
        body = serializeAws_restXmlCompletedMultipartUpload(input.MultipartUpload, context);
      }
      let contents;
      if (input.MultipartUpload !== void 0) {
        contents = serializeAws_restXmlCompletedMultipartUpload(input.MultipartUpload, context);
        contents = contents.withName("CompleteMultipartUpload");
        body = '<?xml version="1.0" encoding="UTF-8"?>';
        contents.addAttribute("xmlns", "http://s3.amazonaws.com/doc/2006-03-01/");
        body += contents.toString();
      }
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "POST",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlCompleteMultipartUploadCommand = serializeAws_restXmlCompleteMultipartUploadCommand;
    var serializeAws_restXmlCopyObjectCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "x-amz-acl": input.ACL,
        "cache-control": input.CacheControl,
        "x-amz-checksum-algorithm": input.ChecksumAlgorithm,
        "content-disposition": input.ContentDisposition,
        "content-encoding": input.ContentEncoding,
        "content-language": input.ContentLanguage,
        "content-type": input.ContentType,
        "x-amz-copy-source": input.CopySource,
        "x-amz-copy-source-if-match": input.CopySourceIfMatch,
        "x-amz-copy-source-if-modified-since": [
          () => isSerializableHeaderValue(input.CopySourceIfModifiedSince),
          () => (0, smithy_client_1.dateToUtcString)(input.CopySourceIfModifiedSince).toString()
        ],
        "x-amz-copy-source-if-none-match": input.CopySourceIfNoneMatch,
        "x-amz-copy-source-if-unmodified-since": [
          () => isSerializableHeaderValue(input.CopySourceIfUnmodifiedSince),
          () => (0, smithy_client_1.dateToUtcString)(input.CopySourceIfUnmodifiedSince).toString()
        ],
        expires: [() => isSerializableHeaderValue(input.Expires), () => (0, smithy_client_1.dateToUtcString)(input.Expires).toString()],
        "x-amz-grant-full-control": input.GrantFullControl,
        "x-amz-grant-read": input.GrantRead,
        "x-amz-grant-read-acp": input.GrantReadACP,
        "x-amz-grant-write-acp": input.GrantWriteACP,
        "x-amz-metadata-directive": input.MetadataDirective,
        "x-amz-tagging-directive": input.TaggingDirective,
        "x-amz-server-side-encryption": input.ServerSideEncryption,
        "x-amz-storage-class": input.StorageClass,
        "x-amz-website-redirect-location": input.WebsiteRedirectLocation,
        "x-amz-server-side-encryption-customer-algorithm": input.SSECustomerAlgorithm,
        "x-amz-server-side-encryption-customer-key": input.SSECustomerKey,
        "x-amz-server-side-encryption-customer-key-md5": input.SSECustomerKeyMD5,
        "x-amz-server-side-encryption-aws-kms-key-id": input.SSEKMSKeyId,
        "x-amz-server-side-encryption-context": input.SSEKMSEncryptionContext,
        "x-amz-server-side-encryption-bucket-key-enabled": [
          () => isSerializableHeaderValue(input.BucketKeyEnabled),
          () => input.BucketKeyEnabled.toString()
        ],
        "x-amz-copy-source-server-side-encryption-customer-algorithm": input.CopySourceSSECustomerAlgorithm,
        "x-amz-copy-source-server-side-encryption-customer-key": input.CopySourceSSECustomerKey,
        "x-amz-copy-source-server-side-encryption-customer-key-md5": input.CopySourceSSECustomerKeyMD5,
        "x-amz-request-payer": input.RequestPayer,
        "x-amz-tagging": input.Tagging,
        "x-amz-object-lock-mode": input.ObjectLockMode,
        "x-amz-object-lock-retain-until-date": [
          () => isSerializableHeaderValue(input.ObjectLockRetainUntilDate),
          () => (input.ObjectLockRetainUntilDate.toISOString().split(".")[0] + "Z").toString()
        ],
        "x-amz-object-lock-legal-hold": input.ObjectLockLegalHoldStatus,
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner,
        "x-amz-source-expected-bucket-owner": input.ExpectedSourceBucketOwner,
        ...input.Metadata !== void 0 && Object.keys(input.Metadata).reduce((acc, suffix) => {
          acc[`x-amz-meta-${suffix.toLowerCase()}`] = input.Metadata[suffix];
          return acc;
        }, {})
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/{Key+}`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Key", () => input.Key, "{Key+}", true);
      const query = map({
        "x-id": [, "CopyObject"]
      });
      let body;
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "PUT",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlCopyObjectCommand = serializeAws_restXmlCopyObjectCommand;
    var serializeAws_restXmlCreateBucketCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "content-type": "application/xml",
        "x-amz-acl": input.ACL,
        "x-amz-grant-full-control": input.GrantFullControl,
        "x-amz-grant-read": input.GrantRead,
        "x-amz-grant-read-acp": input.GrantReadACP,
        "x-amz-grant-write": input.GrantWrite,
        "x-amz-grant-write-acp": input.GrantWriteACP,
        "x-amz-bucket-object-lock-enabled": [
          () => isSerializableHeaderValue(input.ObjectLockEnabledForBucket),
          () => input.ObjectLockEnabledForBucket.toString()
        ],
        "x-amz-object-ownership": input.ObjectOwnership
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      let body;
      if (input.CreateBucketConfiguration !== void 0) {
        body = serializeAws_restXmlCreateBucketConfiguration(input.CreateBucketConfiguration, context);
      }
      let contents;
      if (input.CreateBucketConfiguration !== void 0) {
        contents = serializeAws_restXmlCreateBucketConfiguration(input.CreateBucketConfiguration, context);
        body = '<?xml version="1.0" encoding="UTF-8"?>';
        contents.addAttribute("xmlns", "http://s3.amazonaws.com/doc/2006-03-01/");
        body += contents.toString();
      }
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "PUT",
        headers,
        path: resolvedPath,
        body
      });
    };
    exports.serializeAws_restXmlCreateBucketCommand = serializeAws_restXmlCreateBucketCommand;
    var serializeAws_restXmlCreateMultipartUploadCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "x-amz-acl": input.ACL,
        "cache-control": input.CacheControl,
        "content-disposition": input.ContentDisposition,
        "content-encoding": input.ContentEncoding,
        "content-language": input.ContentLanguage,
        "content-type": input.ContentType,
        expires: [() => isSerializableHeaderValue(input.Expires), () => (0, smithy_client_1.dateToUtcString)(input.Expires).toString()],
        "x-amz-grant-full-control": input.GrantFullControl,
        "x-amz-grant-read": input.GrantRead,
        "x-amz-grant-read-acp": input.GrantReadACP,
        "x-amz-grant-write-acp": input.GrantWriteACP,
        "x-amz-server-side-encryption": input.ServerSideEncryption,
        "x-amz-storage-class": input.StorageClass,
        "x-amz-website-redirect-location": input.WebsiteRedirectLocation,
        "x-amz-server-side-encryption-customer-algorithm": input.SSECustomerAlgorithm,
        "x-amz-server-side-encryption-customer-key": input.SSECustomerKey,
        "x-amz-server-side-encryption-customer-key-md5": input.SSECustomerKeyMD5,
        "x-amz-server-side-encryption-aws-kms-key-id": input.SSEKMSKeyId,
        "x-amz-server-side-encryption-context": input.SSEKMSEncryptionContext,
        "x-amz-server-side-encryption-bucket-key-enabled": [
          () => isSerializableHeaderValue(input.BucketKeyEnabled),
          () => input.BucketKeyEnabled.toString()
        ],
        "x-amz-request-payer": input.RequestPayer,
        "x-amz-tagging": input.Tagging,
        "x-amz-object-lock-mode": input.ObjectLockMode,
        "x-amz-object-lock-retain-until-date": [
          () => isSerializableHeaderValue(input.ObjectLockRetainUntilDate),
          () => (input.ObjectLockRetainUntilDate.toISOString().split(".")[0] + "Z").toString()
        ],
        "x-amz-object-lock-legal-hold": input.ObjectLockLegalHoldStatus,
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner,
        "x-amz-checksum-algorithm": input.ChecksumAlgorithm,
        ...input.Metadata !== void 0 && Object.keys(input.Metadata).reduce((acc, suffix) => {
          acc[`x-amz-meta-${suffix.toLowerCase()}`] = input.Metadata[suffix];
          return acc;
        }, {})
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/{Key+}`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Key", () => input.Key, "{Key+}", true);
      const query = map({
        uploads: [, ""],
        "x-id": [, "CreateMultipartUpload"]
      });
      let body;
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "POST",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlCreateMultipartUploadCommand = serializeAws_restXmlCreateMultipartUploadCommand;
    var serializeAws_restXmlDeleteBucketCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      let body;
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "DELETE",
        headers,
        path: resolvedPath,
        body
      });
    };
    exports.serializeAws_restXmlDeleteBucketCommand = serializeAws_restXmlDeleteBucketCommand;
    var serializeAws_restXmlDeleteBucketAnalyticsConfigurationCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      const query = map({
        analytics: [, ""],
        id: [, (0, smithy_client_1.expectNonNull)(input.Id, `Id`)]
      });
      let body;
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "DELETE",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlDeleteBucketAnalyticsConfigurationCommand = serializeAws_restXmlDeleteBucketAnalyticsConfigurationCommand;
    var serializeAws_restXmlDeleteBucketCorsCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      const query = map({
        cors: [, ""]
      });
      let body;
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "DELETE",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlDeleteBucketCorsCommand = serializeAws_restXmlDeleteBucketCorsCommand;
    var serializeAws_restXmlDeleteBucketEncryptionCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      const query = map({
        encryption: [, ""]
      });
      let body;
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "DELETE",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlDeleteBucketEncryptionCommand = serializeAws_restXmlDeleteBucketEncryptionCommand;
    var serializeAws_restXmlDeleteBucketIntelligentTieringConfigurationCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = {};
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      const query = map({
        "intelligent-tiering": [, ""],
        id: [, (0, smithy_client_1.expectNonNull)(input.Id, `Id`)]
      });
      let body;
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "DELETE",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlDeleteBucketIntelligentTieringConfigurationCommand = serializeAws_restXmlDeleteBucketIntelligentTieringConfigurationCommand;
    var serializeAws_restXmlDeleteBucketInventoryConfigurationCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      const query = map({
        inventory: [, ""],
        id: [, (0, smithy_client_1.expectNonNull)(input.Id, `Id`)]
      });
      let body;
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "DELETE",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlDeleteBucketInventoryConfigurationCommand = serializeAws_restXmlDeleteBucketInventoryConfigurationCommand;
    var serializeAws_restXmlDeleteBucketLifecycleCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      const query = map({
        lifecycle: [, ""]
      });
      let body;
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "DELETE",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlDeleteBucketLifecycleCommand = serializeAws_restXmlDeleteBucketLifecycleCommand;
    var serializeAws_restXmlDeleteBucketMetricsConfigurationCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      const query = map({
        metrics: [, ""],
        id: [, (0, smithy_client_1.expectNonNull)(input.Id, `Id`)]
      });
      let body;
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "DELETE",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlDeleteBucketMetricsConfigurationCommand = serializeAws_restXmlDeleteBucketMetricsConfigurationCommand;
    var serializeAws_restXmlDeleteBucketOwnershipControlsCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      const query = map({
        ownershipControls: [, ""]
      });
      let body;
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "DELETE",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlDeleteBucketOwnershipControlsCommand = serializeAws_restXmlDeleteBucketOwnershipControlsCommand;
    var serializeAws_restXmlDeleteBucketPolicyCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      const query = map({
        policy: [, ""]
      });
      let body;
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "DELETE",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlDeleteBucketPolicyCommand = serializeAws_restXmlDeleteBucketPolicyCommand;
    var serializeAws_restXmlDeleteBucketReplicationCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      const query = map({
        replication: [, ""]
      });
      let body;
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "DELETE",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlDeleteBucketReplicationCommand = serializeAws_restXmlDeleteBucketReplicationCommand;
    var serializeAws_restXmlDeleteBucketTaggingCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      const query = map({
        tagging: [, ""]
      });
      let body;
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "DELETE",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlDeleteBucketTaggingCommand = serializeAws_restXmlDeleteBucketTaggingCommand;
    var serializeAws_restXmlDeleteBucketWebsiteCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      const query = map({
        website: [, ""]
      });
      let body;
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "DELETE",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlDeleteBucketWebsiteCommand = serializeAws_restXmlDeleteBucketWebsiteCommand;
    var serializeAws_restXmlDeleteObjectCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "x-amz-mfa": input.MFA,
        "x-amz-request-payer": input.RequestPayer,
        "x-amz-bypass-governance-retention": [
          () => isSerializableHeaderValue(input.BypassGovernanceRetention),
          () => input.BypassGovernanceRetention.toString()
        ],
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/{Key+}`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Key", () => input.Key, "{Key+}", true);
      const query = map({
        "x-id": [, "DeleteObject"],
        versionId: [, input.VersionId]
      });
      let body;
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "DELETE",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlDeleteObjectCommand = serializeAws_restXmlDeleteObjectCommand;
    var serializeAws_restXmlDeleteObjectsCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "content-type": "application/xml",
        "x-amz-mfa": input.MFA,
        "x-amz-request-payer": input.RequestPayer,
        "x-amz-bypass-governance-retention": [
          () => isSerializableHeaderValue(input.BypassGovernanceRetention),
          () => input.BypassGovernanceRetention.toString()
        ],
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner,
        "x-amz-sdk-checksum-algorithm": input.ChecksumAlgorithm
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      const query = map({
        delete: [, ""],
        "x-id": [, "DeleteObjects"]
      });
      let body;
      if (input.Delete !== void 0) {
        body = serializeAws_restXmlDelete(input.Delete, context);
      }
      let contents;
      if (input.Delete !== void 0) {
        contents = serializeAws_restXmlDelete(input.Delete, context);
        body = '<?xml version="1.0" encoding="UTF-8"?>';
        contents.addAttribute("xmlns", "http://s3.amazonaws.com/doc/2006-03-01/");
        body += contents.toString();
      }
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "POST",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlDeleteObjectsCommand = serializeAws_restXmlDeleteObjectsCommand;
    var serializeAws_restXmlDeleteObjectTaggingCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/{Key+}`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Key", () => input.Key, "{Key+}", true);
      const query = map({
        tagging: [, ""],
        versionId: [, input.VersionId]
      });
      let body;
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "DELETE",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlDeleteObjectTaggingCommand = serializeAws_restXmlDeleteObjectTaggingCommand;
    var serializeAws_restXmlDeletePublicAccessBlockCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      const query = map({
        publicAccessBlock: [, ""]
      });
      let body;
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "DELETE",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlDeletePublicAccessBlockCommand = serializeAws_restXmlDeletePublicAccessBlockCommand;
    var serializeAws_restXmlGetBucketAccelerateConfigurationCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      const query = map({
        accelerate: [, ""]
      });
      let body;
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "GET",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlGetBucketAccelerateConfigurationCommand = serializeAws_restXmlGetBucketAccelerateConfigurationCommand;
    var serializeAws_restXmlGetBucketAclCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      const query = map({
        acl: [, ""]
      });
      let body;
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "GET",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlGetBucketAclCommand = serializeAws_restXmlGetBucketAclCommand;
    var serializeAws_restXmlGetBucketAnalyticsConfigurationCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      const query = map({
        analytics: [, ""],
        "x-id": [, "GetBucketAnalyticsConfiguration"],
        id: [, (0, smithy_client_1.expectNonNull)(input.Id, `Id`)]
      });
      let body;
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "GET",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlGetBucketAnalyticsConfigurationCommand = serializeAws_restXmlGetBucketAnalyticsConfigurationCommand;
    var serializeAws_restXmlGetBucketCorsCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      const query = map({
        cors: [, ""]
      });
      let body;
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "GET",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlGetBucketCorsCommand = serializeAws_restXmlGetBucketCorsCommand;
    var serializeAws_restXmlGetBucketEncryptionCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      const query = map({
        encryption: [, ""]
      });
      let body;
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "GET",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlGetBucketEncryptionCommand = serializeAws_restXmlGetBucketEncryptionCommand;
    var serializeAws_restXmlGetBucketIntelligentTieringConfigurationCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = {};
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      const query = map({
        "intelligent-tiering": [, ""],
        "x-id": [, "GetBucketIntelligentTieringConfiguration"],
        id: [, (0, smithy_client_1.expectNonNull)(input.Id, `Id`)]
      });
      let body;
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "GET",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlGetBucketIntelligentTieringConfigurationCommand = serializeAws_restXmlGetBucketIntelligentTieringConfigurationCommand;
    var serializeAws_restXmlGetBucketInventoryConfigurationCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      const query = map({
        inventory: [, ""],
        "x-id": [, "GetBucketInventoryConfiguration"],
        id: [, (0, smithy_client_1.expectNonNull)(input.Id, `Id`)]
      });
      let body;
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "GET",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlGetBucketInventoryConfigurationCommand = serializeAws_restXmlGetBucketInventoryConfigurationCommand;
    var serializeAws_restXmlGetBucketLifecycleConfigurationCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      const query = map({
        lifecycle: [, ""]
      });
      let body;
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "GET",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlGetBucketLifecycleConfigurationCommand = serializeAws_restXmlGetBucketLifecycleConfigurationCommand;
    var serializeAws_restXmlGetBucketLocationCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      const query = map({
        location: [, ""]
      });
      let body;
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "GET",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlGetBucketLocationCommand = serializeAws_restXmlGetBucketLocationCommand;
    var serializeAws_restXmlGetBucketLoggingCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      const query = map({
        logging: [, ""]
      });
      let body;
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "GET",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlGetBucketLoggingCommand = serializeAws_restXmlGetBucketLoggingCommand;
    var serializeAws_restXmlGetBucketMetricsConfigurationCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      const query = map({
        metrics: [, ""],
        "x-id": [, "GetBucketMetricsConfiguration"],
        id: [, (0, smithy_client_1.expectNonNull)(input.Id, `Id`)]
      });
      let body;
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "GET",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlGetBucketMetricsConfigurationCommand = serializeAws_restXmlGetBucketMetricsConfigurationCommand;
    var serializeAws_restXmlGetBucketNotificationConfigurationCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      const query = map({
        notification: [, ""]
      });
      let body;
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "GET",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlGetBucketNotificationConfigurationCommand = serializeAws_restXmlGetBucketNotificationConfigurationCommand;
    var serializeAws_restXmlGetBucketOwnershipControlsCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      const query = map({
        ownershipControls: [, ""]
      });
      let body;
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "GET",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlGetBucketOwnershipControlsCommand = serializeAws_restXmlGetBucketOwnershipControlsCommand;
    var serializeAws_restXmlGetBucketPolicyCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      const query = map({
        policy: [, ""]
      });
      let body;
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "GET",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlGetBucketPolicyCommand = serializeAws_restXmlGetBucketPolicyCommand;
    var serializeAws_restXmlGetBucketPolicyStatusCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      const query = map({
        policyStatus: [, ""]
      });
      let body;
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "GET",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlGetBucketPolicyStatusCommand = serializeAws_restXmlGetBucketPolicyStatusCommand;
    var serializeAws_restXmlGetBucketReplicationCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      const query = map({
        replication: [, ""]
      });
      let body;
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "GET",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlGetBucketReplicationCommand = serializeAws_restXmlGetBucketReplicationCommand;
    var serializeAws_restXmlGetBucketRequestPaymentCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      const query = map({
        requestPayment: [, ""]
      });
      let body;
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "GET",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlGetBucketRequestPaymentCommand = serializeAws_restXmlGetBucketRequestPaymentCommand;
    var serializeAws_restXmlGetBucketTaggingCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      const query = map({
        tagging: [, ""]
      });
      let body;
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "GET",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlGetBucketTaggingCommand = serializeAws_restXmlGetBucketTaggingCommand;
    var serializeAws_restXmlGetBucketVersioningCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      const query = map({
        versioning: [, ""]
      });
      let body;
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "GET",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlGetBucketVersioningCommand = serializeAws_restXmlGetBucketVersioningCommand;
    var serializeAws_restXmlGetBucketWebsiteCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      const query = map({
        website: [, ""]
      });
      let body;
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "GET",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlGetBucketWebsiteCommand = serializeAws_restXmlGetBucketWebsiteCommand;
    var serializeAws_restXmlGetObjectCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "if-match": input.IfMatch,
        "if-modified-since": [
          () => isSerializableHeaderValue(input.IfModifiedSince),
          () => (0, smithy_client_1.dateToUtcString)(input.IfModifiedSince).toString()
        ],
        "if-none-match": input.IfNoneMatch,
        "if-unmodified-since": [
          () => isSerializableHeaderValue(input.IfUnmodifiedSince),
          () => (0, smithy_client_1.dateToUtcString)(input.IfUnmodifiedSince).toString()
        ],
        range: input.Range,
        "x-amz-server-side-encryption-customer-algorithm": input.SSECustomerAlgorithm,
        "x-amz-server-side-encryption-customer-key": input.SSECustomerKey,
        "x-amz-server-side-encryption-customer-key-md5": input.SSECustomerKeyMD5,
        "x-amz-request-payer": input.RequestPayer,
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner,
        "x-amz-checksum-mode": input.ChecksumMode
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/{Key+}`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Key", () => input.Key, "{Key+}", true);
      const query = map({
        "x-id": [, "GetObject"],
        "response-cache-control": [, input.ResponseCacheControl],
        "response-content-disposition": [, input.ResponseContentDisposition],
        "response-content-encoding": [, input.ResponseContentEncoding],
        "response-content-language": [, input.ResponseContentLanguage],
        "response-content-type": [, input.ResponseContentType],
        "response-expires": [
          () => input.ResponseExpires !== void 0,
          () => (0, smithy_client_1.dateToUtcString)(input.ResponseExpires).toString()
        ],
        versionId: [, input.VersionId],
        partNumber: [() => input.PartNumber !== void 0, () => input.PartNumber.toString()]
      });
      let body;
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "GET",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlGetObjectCommand = serializeAws_restXmlGetObjectCommand;
    var serializeAws_restXmlGetObjectAclCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "x-amz-request-payer": input.RequestPayer,
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/{Key+}`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Key", () => input.Key, "{Key+}", true);
      const query = map({
        acl: [, ""],
        versionId: [, input.VersionId]
      });
      let body;
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "GET",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlGetObjectAclCommand = serializeAws_restXmlGetObjectAclCommand;
    var serializeAws_restXmlGetObjectAttributesCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "x-amz-max-parts": [() => isSerializableHeaderValue(input.MaxParts), () => input.MaxParts.toString()],
        "x-amz-part-number-marker": input.PartNumberMarker,
        "x-amz-server-side-encryption-customer-algorithm": input.SSECustomerAlgorithm,
        "x-amz-server-side-encryption-customer-key": input.SSECustomerKey,
        "x-amz-server-side-encryption-customer-key-md5": input.SSECustomerKeyMD5,
        "x-amz-request-payer": input.RequestPayer,
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner,
        "x-amz-object-attributes": [
          () => isSerializableHeaderValue(input.ObjectAttributes),
          () => (input.ObjectAttributes || []).map((_entry) => _entry).join(", ")
        ]
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/{Key+}`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Key", () => input.Key, "{Key+}", true);
      const query = map({
        attributes: [, ""],
        versionId: [, input.VersionId]
      });
      let body;
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "GET",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlGetObjectAttributesCommand = serializeAws_restXmlGetObjectAttributesCommand;
    var serializeAws_restXmlGetObjectLegalHoldCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "x-amz-request-payer": input.RequestPayer,
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/{Key+}`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Key", () => input.Key, "{Key+}", true);
      const query = map({
        "legal-hold": [, ""],
        versionId: [, input.VersionId]
      });
      let body;
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "GET",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlGetObjectLegalHoldCommand = serializeAws_restXmlGetObjectLegalHoldCommand;
    var serializeAws_restXmlGetObjectLockConfigurationCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      const query = map({
        "object-lock": [, ""]
      });
      let body;
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "GET",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlGetObjectLockConfigurationCommand = serializeAws_restXmlGetObjectLockConfigurationCommand;
    var serializeAws_restXmlGetObjectRetentionCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "x-amz-request-payer": input.RequestPayer,
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/{Key+}`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Key", () => input.Key, "{Key+}", true);
      const query = map({
        retention: [, ""],
        versionId: [, input.VersionId]
      });
      let body;
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "GET",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlGetObjectRetentionCommand = serializeAws_restXmlGetObjectRetentionCommand;
    var serializeAws_restXmlGetObjectTaggingCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner,
        "x-amz-request-payer": input.RequestPayer
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/{Key+}`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Key", () => input.Key, "{Key+}", true);
      const query = map({
        tagging: [, ""],
        versionId: [, input.VersionId]
      });
      let body;
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "GET",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlGetObjectTaggingCommand = serializeAws_restXmlGetObjectTaggingCommand;
    var serializeAws_restXmlGetObjectTorrentCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "x-amz-request-payer": input.RequestPayer,
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/{Key+}`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Key", () => input.Key, "{Key+}", true);
      const query = map({
        torrent: [, ""]
      });
      let body;
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "GET",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlGetObjectTorrentCommand = serializeAws_restXmlGetObjectTorrentCommand;
    var serializeAws_restXmlGetPublicAccessBlockCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      const query = map({
        publicAccessBlock: [, ""]
      });
      let body;
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "GET",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlGetPublicAccessBlockCommand = serializeAws_restXmlGetPublicAccessBlockCommand;
    var serializeAws_restXmlHeadBucketCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      let body;
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "HEAD",
        headers,
        path: resolvedPath,
        body
      });
    };
    exports.serializeAws_restXmlHeadBucketCommand = serializeAws_restXmlHeadBucketCommand;
    var serializeAws_restXmlHeadObjectCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "if-match": input.IfMatch,
        "if-modified-since": [
          () => isSerializableHeaderValue(input.IfModifiedSince),
          () => (0, smithy_client_1.dateToUtcString)(input.IfModifiedSince).toString()
        ],
        "if-none-match": input.IfNoneMatch,
        "if-unmodified-since": [
          () => isSerializableHeaderValue(input.IfUnmodifiedSince),
          () => (0, smithy_client_1.dateToUtcString)(input.IfUnmodifiedSince).toString()
        ],
        range: input.Range,
        "x-amz-server-side-encryption-customer-algorithm": input.SSECustomerAlgorithm,
        "x-amz-server-side-encryption-customer-key": input.SSECustomerKey,
        "x-amz-server-side-encryption-customer-key-md5": input.SSECustomerKeyMD5,
        "x-amz-request-payer": input.RequestPayer,
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner,
        "x-amz-checksum-mode": input.ChecksumMode
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/{Key+}`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Key", () => input.Key, "{Key+}", true);
      const query = map({
        versionId: [, input.VersionId],
        partNumber: [() => input.PartNumber !== void 0, () => input.PartNumber.toString()]
      });
      let body;
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "HEAD",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlHeadObjectCommand = serializeAws_restXmlHeadObjectCommand;
    var serializeAws_restXmlListBucketAnalyticsConfigurationsCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      const query = map({
        analytics: [, ""],
        "x-id": [, "ListBucketAnalyticsConfigurations"],
        "continuation-token": [, input.ContinuationToken]
      });
      let body;
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "GET",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlListBucketAnalyticsConfigurationsCommand = serializeAws_restXmlListBucketAnalyticsConfigurationsCommand;
    var serializeAws_restXmlListBucketIntelligentTieringConfigurationsCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = {};
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      const query = map({
        "intelligent-tiering": [, ""],
        "x-id": [, "ListBucketIntelligentTieringConfigurations"],
        "continuation-token": [, input.ContinuationToken]
      });
      let body;
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "GET",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlListBucketIntelligentTieringConfigurationsCommand = serializeAws_restXmlListBucketIntelligentTieringConfigurationsCommand;
    var serializeAws_restXmlListBucketInventoryConfigurationsCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      const query = map({
        inventory: [, ""],
        "x-id": [, "ListBucketInventoryConfigurations"],
        "continuation-token": [, input.ContinuationToken]
      });
      let body;
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "GET",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlListBucketInventoryConfigurationsCommand = serializeAws_restXmlListBucketInventoryConfigurationsCommand;
    var serializeAws_restXmlListBucketMetricsConfigurationsCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      const query = map({
        metrics: [, ""],
        "x-id": [, "ListBucketMetricsConfigurations"],
        "continuation-token": [, input.ContinuationToken]
      });
      let body;
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "GET",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlListBucketMetricsConfigurationsCommand = serializeAws_restXmlListBucketMetricsConfigurationsCommand;
    var serializeAws_restXmlListBucketsCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = {
        "content-type": "application/xml"
      };
      const resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`;
      let body;
      body = "";
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "GET",
        headers,
        path: resolvedPath,
        body
      });
    };
    exports.serializeAws_restXmlListBucketsCommand = serializeAws_restXmlListBucketsCommand;
    var serializeAws_restXmlListMultipartUploadsCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      const query = map({
        uploads: [, ""],
        delimiter: [, input.Delimiter],
        "encoding-type": [, input.EncodingType],
        "key-marker": [, input.KeyMarker],
        "max-uploads": [() => input.MaxUploads !== void 0, () => input.MaxUploads.toString()],
        prefix: [, input.Prefix],
        "upload-id-marker": [, input.UploadIdMarker]
      });
      let body;
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "GET",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlListMultipartUploadsCommand = serializeAws_restXmlListMultipartUploadsCommand;
    var serializeAws_restXmlListObjectsCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "x-amz-request-payer": input.RequestPayer,
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      const query = map({
        delimiter: [, input.Delimiter],
        "encoding-type": [, input.EncodingType],
        marker: [, input.Marker],
        "max-keys": [() => input.MaxKeys !== void 0, () => input.MaxKeys.toString()],
        prefix: [, input.Prefix]
      });
      let body;
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "GET",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlListObjectsCommand = serializeAws_restXmlListObjectsCommand;
    var serializeAws_restXmlListObjectsV2Command = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "x-amz-request-payer": input.RequestPayer,
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      const query = map({
        "list-type": [, "2"],
        delimiter: [, input.Delimiter],
        "encoding-type": [, input.EncodingType],
        "max-keys": [() => input.MaxKeys !== void 0, () => input.MaxKeys.toString()],
        prefix: [, input.Prefix],
        "continuation-token": [, input.ContinuationToken],
        "fetch-owner": [() => input.FetchOwner !== void 0, () => input.FetchOwner.toString()],
        "start-after": [, input.StartAfter]
      });
      let body;
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "GET",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlListObjectsV2Command = serializeAws_restXmlListObjectsV2Command;
    var serializeAws_restXmlListObjectVersionsCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      const query = map({
        versions: [, ""],
        delimiter: [, input.Delimiter],
        "encoding-type": [, input.EncodingType],
        "key-marker": [, input.KeyMarker],
        "max-keys": [() => input.MaxKeys !== void 0, () => input.MaxKeys.toString()],
        prefix: [, input.Prefix],
        "version-id-marker": [, input.VersionIdMarker]
      });
      let body;
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "GET",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlListObjectVersionsCommand = serializeAws_restXmlListObjectVersionsCommand;
    var serializeAws_restXmlListPartsCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "x-amz-request-payer": input.RequestPayer,
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner,
        "x-amz-server-side-encryption-customer-algorithm": input.SSECustomerAlgorithm,
        "x-amz-server-side-encryption-customer-key": input.SSECustomerKey,
        "x-amz-server-side-encryption-customer-key-md5": input.SSECustomerKeyMD5
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/{Key+}`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Key", () => input.Key, "{Key+}", true);
      const query = map({
        "x-id": [, "ListParts"],
        "max-parts": [() => input.MaxParts !== void 0, () => input.MaxParts.toString()],
        "part-number-marker": [, input.PartNumberMarker],
        uploadId: [, (0, smithy_client_1.expectNonNull)(input.UploadId, `UploadId`)]
      });
      let body;
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "GET",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlListPartsCommand = serializeAws_restXmlListPartsCommand;
    var serializeAws_restXmlPutBucketAccelerateConfigurationCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "content-type": "application/xml",
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner,
        "x-amz-sdk-checksum-algorithm": input.ChecksumAlgorithm
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      const query = map({
        accelerate: [, ""]
      });
      let body;
      if (input.AccelerateConfiguration !== void 0) {
        body = serializeAws_restXmlAccelerateConfiguration(input.AccelerateConfiguration, context);
      }
      let contents;
      if (input.AccelerateConfiguration !== void 0) {
        contents = serializeAws_restXmlAccelerateConfiguration(input.AccelerateConfiguration, context);
        body = '<?xml version="1.0" encoding="UTF-8"?>';
        contents.addAttribute("xmlns", "http://s3.amazonaws.com/doc/2006-03-01/");
        body += contents.toString();
      }
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "PUT",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlPutBucketAccelerateConfigurationCommand = serializeAws_restXmlPutBucketAccelerateConfigurationCommand;
    var serializeAws_restXmlPutBucketAclCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "content-type": "application/xml",
        "x-amz-acl": input.ACL,
        "content-md5": input.ContentMD5,
        "x-amz-sdk-checksum-algorithm": input.ChecksumAlgorithm,
        "x-amz-grant-full-control": input.GrantFullControl,
        "x-amz-grant-read": input.GrantRead,
        "x-amz-grant-read-acp": input.GrantReadACP,
        "x-amz-grant-write": input.GrantWrite,
        "x-amz-grant-write-acp": input.GrantWriteACP,
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      const query = map({
        acl: [, ""]
      });
      let body;
      if (input.AccessControlPolicy !== void 0) {
        body = serializeAws_restXmlAccessControlPolicy(input.AccessControlPolicy, context);
      }
      let contents;
      if (input.AccessControlPolicy !== void 0) {
        contents = serializeAws_restXmlAccessControlPolicy(input.AccessControlPolicy, context);
        body = '<?xml version="1.0" encoding="UTF-8"?>';
        contents.addAttribute("xmlns", "http://s3.amazonaws.com/doc/2006-03-01/");
        body += contents.toString();
      }
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "PUT",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlPutBucketAclCommand = serializeAws_restXmlPutBucketAclCommand;
    var serializeAws_restXmlPutBucketAnalyticsConfigurationCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "content-type": "application/xml",
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      const query = map({
        analytics: [, ""],
        id: [, (0, smithy_client_1.expectNonNull)(input.Id, `Id`)]
      });
      let body;
      if (input.AnalyticsConfiguration !== void 0) {
        body = serializeAws_restXmlAnalyticsConfiguration(input.AnalyticsConfiguration, context);
      }
      let contents;
      if (input.AnalyticsConfiguration !== void 0) {
        contents = serializeAws_restXmlAnalyticsConfiguration(input.AnalyticsConfiguration, context);
        body = '<?xml version="1.0" encoding="UTF-8"?>';
        contents.addAttribute("xmlns", "http://s3.amazonaws.com/doc/2006-03-01/");
        body += contents.toString();
      }
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "PUT",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlPutBucketAnalyticsConfigurationCommand = serializeAws_restXmlPutBucketAnalyticsConfigurationCommand;
    var serializeAws_restXmlPutBucketCorsCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "content-type": "application/xml",
        "content-md5": input.ContentMD5,
        "x-amz-sdk-checksum-algorithm": input.ChecksumAlgorithm,
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      const query = map({
        cors: [, ""]
      });
      let body;
      if (input.CORSConfiguration !== void 0) {
        body = serializeAws_restXmlCORSConfiguration(input.CORSConfiguration, context);
      }
      let contents;
      if (input.CORSConfiguration !== void 0) {
        contents = serializeAws_restXmlCORSConfiguration(input.CORSConfiguration, context);
        body = '<?xml version="1.0" encoding="UTF-8"?>';
        contents.addAttribute("xmlns", "http://s3.amazonaws.com/doc/2006-03-01/");
        body += contents.toString();
      }
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "PUT",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlPutBucketCorsCommand = serializeAws_restXmlPutBucketCorsCommand;
    var serializeAws_restXmlPutBucketEncryptionCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "content-type": "application/xml",
        "content-md5": input.ContentMD5,
        "x-amz-sdk-checksum-algorithm": input.ChecksumAlgorithm,
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      const query = map({
        encryption: [, ""]
      });
      let body;
      if (input.ServerSideEncryptionConfiguration !== void 0) {
        body = serializeAws_restXmlServerSideEncryptionConfiguration(input.ServerSideEncryptionConfiguration, context);
      }
      let contents;
      if (input.ServerSideEncryptionConfiguration !== void 0) {
        contents = serializeAws_restXmlServerSideEncryptionConfiguration(input.ServerSideEncryptionConfiguration, context);
        body = '<?xml version="1.0" encoding="UTF-8"?>';
        contents.addAttribute("xmlns", "http://s3.amazonaws.com/doc/2006-03-01/");
        body += contents.toString();
      }
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "PUT",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlPutBucketEncryptionCommand = serializeAws_restXmlPutBucketEncryptionCommand;
    var serializeAws_restXmlPutBucketIntelligentTieringConfigurationCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = {
        "content-type": "application/xml"
      };
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      const query = map({
        "intelligent-tiering": [, ""],
        id: [, (0, smithy_client_1.expectNonNull)(input.Id, `Id`)]
      });
      let body;
      if (input.IntelligentTieringConfiguration !== void 0) {
        body = serializeAws_restXmlIntelligentTieringConfiguration(input.IntelligentTieringConfiguration, context);
      }
      let contents;
      if (input.IntelligentTieringConfiguration !== void 0) {
        contents = serializeAws_restXmlIntelligentTieringConfiguration(input.IntelligentTieringConfiguration, context);
        body = '<?xml version="1.0" encoding="UTF-8"?>';
        contents.addAttribute("xmlns", "http://s3.amazonaws.com/doc/2006-03-01/");
        body += contents.toString();
      }
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "PUT",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlPutBucketIntelligentTieringConfigurationCommand = serializeAws_restXmlPutBucketIntelligentTieringConfigurationCommand;
    var serializeAws_restXmlPutBucketInventoryConfigurationCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "content-type": "application/xml",
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      const query = map({
        inventory: [, ""],
        id: [, (0, smithy_client_1.expectNonNull)(input.Id, `Id`)]
      });
      let body;
      if (input.InventoryConfiguration !== void 0) {
        body = serializeAws_restXmlInventoryConfiguration(input.InventoryConfiguration, context);
      }
      let contents;
      if (input.InventoryConfiguration !== void 0) {
        contents = serializeAws_restXmlInventoryConfiguration(input.InventoryConfiguration, context);
        body = '<?xml version="1.0" encoding="UTF-8"?>';
        contents.addAttribute("xmlns", "http://s3.amazonaws.com/doc/2006-03-01/");
        body += contents.toString();
      }
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "PUT",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlPutBucketInventoryConfigurationCommand = serializeAws_restXmlPutBucketInventoryConfigurationCommand;
    var serializeAws_restXmlPutBucketLifecycleConfigurationCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "content-type": "application/xml",
        "x-amz-sdk-checksum-algorithm": input.ChecksumAlgorithm,
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      const query = map({
        lifecycle: [, ""]
      });
      let body;
      if (input.LifecycleConfiguration !== void 0) {
        body = serializeAws_restXmlBucketLifecycleConfiguration(input.LifecycleConfiguration, context);
      }
      let contents;
      if (input.LifecycleConfiguration !== void 0) {
        contents = serializeAws_restXmlBucketLifecycleConfiguration(input.LifecycleConfiguration, context);
        contents = contents.withName("LifecycleConfiguration");
        body = '<?xml version="1.0" encoding="UTF-8"?>';
        contents.addAttribute("xmlns", "http://s3.amazonaws.com/doc/2006-03-01/");
        body += contents.toString();
      }
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "PUT",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlPutBucketLifecycleConfigurationCommand = serializeAws_restXmlPutBucketLifecycleConfigurationCommand;
    var serializeAws_restXmlPutBucketLoggingCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "content-type": "application/xml",
        "content-md5": input.ContentMD5,
        "x-amz-sdk-checksum-algorithm": input.ChecksumAlgorithm,
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      const query = map({
        logging: [, ""]
      });
      let body;
      if (input.BucketLoggingStatus !== void 0) {
        body = serializeAws_restXmlBucketLoggingStatus(input.BucketLoggingStatus, context);
      }
      let contents;
      if (input.BucketLoggingStatus !== void 0) {
        contents = serializeAws_restXmlBucketLoggingStatus(input.BucketLoggingStatus, context);
        body = '<?xml version="1.0" encoding="UTF-8"?>';
        contents.addAttribute("xmlns", "http://s3.amazonaws.com/doc/2006-03-01/");
        body += contents.toString();
      }
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "PUT",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlPutBucketLoggingCommand = serializeAws_restXmlPutBucketLoggingCommand;
    var serializeAws_restXmlPutBucketMetricsConfigurationCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "content-type": "application/xml",
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      const query = map({
        metrics: [, ""],
        id: [, (0, smithy_client_1.expectNonNull)(input.Id, `Id`)]
      });
      let body;
      if (input.MetricsConfiguration !== void 0) {
        body = serializeAws_restXmlMetricsConfiguration(input.MetricsConfiguration, context);
      }
      let contents;
      if (input.MetricsConfiguration !== void 0) {
        contents = serializeAws_restXmlMetricsConfiguration(input.MetricsConfiguration, context);
        body = '<?xml version="1.0" encoding="UTF-8"?>';
        contents.addAttribute("xmlns", "http://s3.amazonaws.com/doc/2006-03-01/");
        body += contents.toString();
      }
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "PUT",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlPutBucketMetricsConfigurationCommand = serializeAws_restXmlPutBucketMetricsConfigurationCommand;
    var serializeAws_restXmlPutBucketNotificationConfigurationCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "content-type": "application/xml",
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner,
        "x-amz-skip-destination-validation": [
          () => isSerializableHeaderValue(input.SkipDestinationValidation),
          () => input.SkipDestinationValidation.toString()
        ]
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      const query = map({
        notification: [, ""]
      });
      let body;
      if (input.NotificationConfiguration !== void 0) {
        body = serializeAws_restXmlNotificationConfiguration(input.NotificationConfiguration, context);
      }
      let contents;
      if (input.NotificationConfiguration !== void 0) {
        contents = serializeAws_restXmlNotificationConfiguration(input.NotificationConfiguration, context);
        body = '<?xml version="1.0" encoding="UTF-8"?>';
        contents.addAttribute("xmlns", "http://s3.amazonaws.com/doc/2006-03-01/");
        body += contents.toString();
      }
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "PUT",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlPutBucketNotificationConfigurationCommand = serializeAws_restXmlPutBucketNotificationConfigurationCommand;
    var serializeAws_restXmlPutBucketOwnershipControlsCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "content-type": "application/xml",
        "content-md5": input.ContentMD5,
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      const query = map({
        ownershipControls: [, ""]
      });
      let body;
      if (input.OwnershipControls !== void 0) {
        body = serializeAws_restXmlOwnershipControls(input.OwnershipControls, context);
      }
      let contents;
      if (input.OwnershipControls !== void 0) {
        contents = serializeAws_restXmlOwnershipControls(input.OwnershipControls, context);
        body = '<?xml version="1.0" encoding="UTF-8"?>';
        contents.addAttribute("xmlns", "http://s3.amazonaws.com/doc/2006-03-01/");
        body += contents.toString();
      }
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "PUT",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlPutBucketOwnershipControlsCommand = serializeAws_restXmlPutBucketOwnershipControlsCommand;
    var serializeAws_restXmlPutBucketPolicyCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "content-type": "text/plain",
        "content-md5": input.ContentMD5,
        "x-amz-sdk-checksum-algorithm": input.ChecksumAlgorithm,
        "x-amz-confirm-remove-self-bucket-access": [
          () => isSerializableHeaderValue(input.ConfirmRemoveSelfBucketAccess),
          () => input.ConfirmRemoveSelfBucketAccess.toString()
        ],
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      const query = map({
        policy: [, ""]
      });
      let body;
      if (input.Policy !== void 0) {
        body = input.Policy;
      }
      let contents;
      if (input.Policy !== void 0) {
        contents = input.Policy;
        body = contents;
      }
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "PUT",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlPutBucketPolicyCommand = serializeAws_restXmlPutBucketPolicyCommand;
    var serializeAws_restXmlPutBucketReplicationCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "content-type": "application/xml",
        "content-md5": input.ContentMD5,
        "x-amz-sdk-checksum-algorithm": input.ChecksumAlgorithm,
        "x-amz-bucket-object-lock-token": input.Token,
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      const query = map({
        replication: [, ""]
      });
      let body;
      if (input.ReplicationConfiguration !== void 0) {
        body = serializeAws_restXmlReplicationConfiguration(input.ReplicationConfiguration, context);
      }
      let contents;
      if (input.ReplicationConfiguration !== void 0) {
        contents = serializeAws_restXmlReplicationConfiguration(input.ReplicationConfiguration, context);
        body = '<?xml version="1.0" encoding="UTF-8"?>';
        contents.addAttribute("xmlns", "http://s3.amazonaws.com/doc/2006-03-01/");
        body += contents.toString();
      }
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "PUT",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlPutBucketReplicationCommand = serializeAws_restXmlPutBucketReplicationCommand;
    var serializeAws_restXmlPutBucketRequestPaymentCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "content-type": "application/xml",
        "content-md5": input.ContentMD5,
        "x-amz-sdk-checksum-algorithm": input.ChecksumAlgorithm,
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      const query = map({
        requestPayment: [, ""]
      });
      let body;
      if (input.RequestPaymentConfiguration !== void 0) {
        body = serializeAws_restXmlRequestPaymentConfiguration(input.RequestPaymentConfiguration, context);
      }
      let contents;
      if (input.RequestPaymentConfiguration !== void 0) {
        contents = serializeAws_restXmlRequestPaymentConfiguration(input.RequestPaymentConfiguration, context);
        body = '<?xml version="1.0" encoding="UTF-8"?>';
        contents.addAttribute("xmlns", "http://s3.amazonaws.com/doc/2006-03-01/");
        body += contents.toString();
      }
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "PUT",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlPutBucketRequestPaymentCommand = serializeAws_restXmlPutBucketRequestPaymentCommand;
    var serializeAws_restXmlPutBucketTaggingCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "content-type": "application/xml",
        "content-md5": input.ContentMD5,
        "x-amz-sdk-checksum-algorithm": input.ChecksumAlgorithm,
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      const query = map({
        tagging: [, ""]
      });
      let body;
      if (input.Tagging !== void 0) {
        body = serializeAws_restXmlTagging(input.Tagging, context);
      }
      let contents;
      if (input.Tagging !== void 0) {
        contents = serializeAws_restXmlTagging(input.Tagging, context);
        body = '<?xml version="1.0" encoding="UTF-8"?>';
        contents.addAttribute("xmlns", "http://s3.amazonaws.com/doc/2006-03-01/");
        body += contents.toString();
      }
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "PUT",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlPutBucketTaggingCommand = serializeAws_restXmlPutBucketTaggingCommand;
    var serializeAws_restXmlPutBucketVersioningCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "content-type": "application/xml",
        "content-md5": input.ContentMD5,
        "x-amz-sdk-checksum-algorithm": input.ChecksumAlgorithm,
        "x-amz-mfa": input.MFA,
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      const query = map({
        versioning: [, ""]
      });
      let body;
      if (input.VersioningConfiguration !== void 0) {
        body = serializeAws_restXmlVersioningConfiguration(input.VersioningConfiguration, context);
      }
      let contents;
      if (input.VersioningConfiguration !== void 0) {
        contents = serializeAws_restXmlVersioningConfiguration(input.VersioningConfiguration, context);
        body = '<?xml version="1.0" encoding="UTF-8"?>';
        contents.addAttribute("xmlns", "http://s3.amazonaws.com/doc/2006-03-01/");
        body += contents.toString();
      }
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "PUT",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlPutBucketVersioningCommand = serializeAws_restXmlPutBucketVersioningCommand;
    var serializeAws_restXmlPutBucketWebsiteCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "content-type": "application/xml",
        "content-md5": input.ContentMD5,
        "x-amz-sdk-checksum-algorithm": input.ChecksumAlgorithm,
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      const query = map({
        website: [, ""]
      });
      let body;
      if (input.WebsiteConfiguration !== void 0) {
        body = serializeAws_restXmlWebsiteConfiguration(input.WebsiteConfiguration, context);
      }
      let contents;
      if (input.WebsiteConfiguration !== void 0) {
        contents = serializeAws_restXmlWebsiteConfiguration(input.WebsiteConfiguration, context);
        body = '<?xml version="1.0" encoding="UTF-8"?>';
        contents.addAttribute("xmlns", "http://s3.amazonaws.com/doc/2006-03-01/");
        body += contents.toString();
      }
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "PUT",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlPutBucketWebsiteCommand = serializeAws_restXmlPutBucketWebsiteCommand;
    var serializeAws_restXmlPutObjectCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "content-type": input.ContentType || "application/octet-stream",
        "x-amz-acl": input.ACL,
        "cache-control": input.CacheControl,
        "content-disposition": input.ContentDisposition,
        "content-encoding": input.ContentEncoding,
        "content-language": input.ContentLanguage,
        "content-length": [() => isSerializableHeaderValue(input.ContentLength), () => input.ContentLength.toString()],
        "content-md5": input.ContentMD5,
        "x-amz-sdk-checksum-algorithm": input.ChecksumAlgorithm,
        "x-amz-checksum-crc32": input.ChecksumCRC32,
        "x-amz-checksum-crc32c": input.ChecksumCRC32C,
        "x-amz-checksum-sha1": input.ChecksumSHA1,
        "x-amz-checksum-sha256": input.ChecksumSHA256,
        expires: [() => isSerializableHeaderValue(input.Expires), () => (0, smithy_client_1.dateToUtcString)(input.Expires).toString()],
        "x-amz-grant-full-control": input.GrantFullControl,
        "x-amz-grant-read": input.GrantRead,
        "x-amz-grant-read-acp": input.GrantReadACP,
        "x-amz-grant-write-acp": input.GrantWriteACP,
        "x-amz-server-side-encryption": input.ServerSideEncryption,
        "x-amz-storage-class": input.StorageClass,
        "x-amz-website-redirect-location": input.WebsiteRedirectLocation,
        "x-amz-server-side-encryption-customer-algorithm": input.SSECustomerAlgorithm,
        "x-amz-server-side-encryption-customer-key": input.SSECustomerKey,
        "x-amz-server-side-encryption-customer-key-md5": input.SSECustomerKeyMD5,
        "x-amz-server-side-encryption-aws-kms-key-id": input.SSEKMSKeyId,
        "x-amz-server-side-encryption-context": input.SSEKMSEncryptionContext,
        "x-amz-server-side-encryption-bucket-key-enabled": [
          () => isSerializableHeaderValue(input.BucketKeyEnabled),
          () => input.BucketKeyEnabled.toString()
        ],
        "x-amz-request-payer": input.RequestPayer,
        "x-amz-tagging": input.Tagging,
        "x-amz-object-lock-mode": input.ObjectLockMode,
        "x-amz-object-lock-retain-until-date": [
          () => isSerializableHeaderValue(input.ObjectLockRetainUntilDate),
          () => (input.ObjectLockRetainUntilDate.toISOString().split(".")[0] + "Z").toString()
        ],
        "x-amz-object-lock-legal-hold": input.ObjectLockLegalHoldStatus,
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner,
        ...input.Metadata !== void 0 && Object.keys(input.Metadata).reduce((acc, suffix) => {
          acc[`x-amz-meta-${suffix.toLowerCase()}`] = input.Metadata[suffix];
          return acc;
        }, {})
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/{Key+}`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Key", () => input.Key, "{Key+}", true);
      const query = map({
        "x-id": [, "PutObject"]
      });
      let body;
      if (input.Body !== void 0) {
        body = input.Body;
      }
      let contents;
      if (input.Body !== void 0) {
        contents = input.Body;
        body = contents;
      }
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "PUT",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlPutObjectCommand = serializeAws_restXmlPutObjectCommand;
    var serializeAws_restXmlPutObjectAclCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "content-type": "application/xml",
        "x-amz-acl": input.ACL,
        "content-md5": input.ContentMD5,
        "x-amz-sdk-checksum-algorithm": input.ChecksumAlgorithm,
        "x-amz-grant-full-control": input.GrantFullControl,
        "x-amz-grant-read": input.GrantRead,
        "x-amz-grant-read-acp": input.GrantReadACP,
        "x-amz-grant-write": input.GrantWrite,
        "x-amz-grant-write-acp": input.GrantWriteACP,
        "x-amz-request-payer": input.RequestPayer,
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/{Key+}`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Key", () => input.Key, "{Key+}", true);
      const query = map({
        acl: [, ""],
        versionId: [, input.VersionId]
      });
      let body;
      if (input.AccessControlPolicy !== void 0) {
        body = serializeAws_restXmlAccessControlPolicy(input.AccessControlPolicy, context);
      }
      let contents;
      if (input.AccessControlPolicy !== void 0) {
        contents = serializeAws_restXmlAccessControlPolicy(input.AccessControlPolicy, context);
        body = '<?xml version="1.0" encoding="UTF-8"?>';
        contents.addAttribute("xmlns", "http://s3.amazonaws.com/doc/2006-03-01/");
        body += contents.toString();
      }
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "PUT",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlPutObjectAclCommand = serializeAws_restXmlPutObjectAclCommand;
    var serializeAws_restXmlPutObjectLegalHoldCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "content-type": "application/xml",
        "x-amz-request-payer": input.RequestPayer,
        "content-md5": input.ContentMD5,
        "x-amz-sdk-checksum-algorithm": input.ChecksumAlgorithm,
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/{Key+}`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Key", () => input.Key, "{Key+}", true);
      const query = map({
        "legal-hold": [, ""],
        versionId: [, input.VersionId]
      });
      let body;
      if (input.LegalHold !== void 0) {
        body = serializeAws_restXmlObjectLockLegalHold(input.LegalHold, context);
      }
      let contents;
      if (input.LegalHold !== void 0) {
        contents = serializeAws_restXmlObjectLockLegalHold(input.LegalHold, context);
        contents = contents.withName("LegalHold");
        body = '<?xml version="1.0" encoding="UTF-8"?>';
        contents.addAttribute("xmlns", "http://s3.amazonaws.com/doc/2006-03-01/");
        body += contents.toString();
      }
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "PUT",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlPutObjectLegalHoldCommand = serializeAws_restXmlPutObjectLegalHoldCommand;
    var serializeAws_restXmlPutObjectLockConfigurationCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "content-type": "application/xml",
        "x-amz-request-payer": input.RequestPayer,
        "x-amz-bucket-object-lock-token": input.Token,
        "content-md5": input.ContentMD5,
        "x-amz-sdk-checksum-algorithm": input.ChecksumAlgorithm,
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      const query = map({
        "object-lock": [, ""]
      });
      let body;
      if (input.ObjectLockConfiguration !== void 0) {
        body = serializeAws_restXmlObjectLockConfiguration(input.ObjectLockConfiguration, context);
      }
      let contents;
      if (input.ObjectLockConfiguration !== void 0) {
        contents = serializeAws_restXmlObjectLockConfiguration(input.ObjectLockConfiguration, context);
        body = '<?xml version="1.0" encoding="UTF-8"?>';
        contents.addAttribute("xmlns", "http://s3.amazonaws.com/doc/2006-03-01/");
        body += contents.toString();
      }
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "PUT",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlPutObjectLockConfigurationCommand = serializeAws_restXmlPutObjectLockConfigurationCommand;
    var serializeAws_restXmlPutObjectRetentionCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "content-type": "application/xml",
        "x-amz-request-payer": input.RequestPayer,
        "x-amz-bypass-governance-retention": [
          () => isSerializableHeaderValue(input.BypassGovernanceRetention),
          () => input.BypassGovernanceRetention.toString()
        ],
        "content-md5": input.ContentMD5,
        "x-amz-sdk-checksum-algorithm": input.ChecksumAlgorithm,
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/{Key+}`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Key", () => input.Key, "{Key+}", true);
      const query = map({
        retention: [, ""],
        versionId: [, input.VersionId]
      });
      let body;
      if (input.Retention !== void 0) {
        body = serializeAws_restXmlObjectLockRetention(input.Retention, context);
      }
      let contents;
      if (input.Retention !== void 0) {
        contents = serializeAws_restXmlObjectLockRetention(input.Retention, context);
        contents = contents.withName("Retention");
        body = '<?xml version="1.0" encoding="UTF-8"?>';
        contents.addAttribute("xmlns", "http://s3.amazonaws.com/doc/2006-03-01/");
        body += contents.toString();
      }
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "PUT",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlPutObjectRetentionCommand = serializeAws_restXmlPutObjectRetentionCommand;
    var serializeAws_restXmlPutObjectTaggingCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "content-type": "application/xml",
        "content-md5": input.ContentMD5,
        "x-amz-sdk-checksum-algorithm": input.ChecksumAlgorithm,
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner,
        "x-amz-request-payer": input.RequestPayer
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/{Key+}`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Key", () => input.Key, "{Key+}", true);
      const query = map({
        tagging: [, ""],
        versionId: [, input.VersionId]
      });
      let body;
      if (input.Tagging !== void 0) {
        body = serializeAws_restXmlTagging(input.Tagging, context);
      }
      let contents;
      if (input.Tagging !== void 0) {
        contents = serializeAws_restXmlTagging(input.Tagging, context);
        body = '<?xml version="1.0" encoding="UTF-8"?>';
        contents.addAttribute("xmlns", "http://s3.amazonaws.com/doc/2006-03-01/");
        body += contents.toString();
      }
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "PUT",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlPutObjectTaggingCommand = serializeAws_restXmlPutObjectTaggingCommand;
    var serializeAws_restXmlPutPublicAccessBlockCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "content-type": "application/xml",
        "content-md5": input.ContentMD5,
        "x-amz-sdk-checksum-algorithm": input.ChecksumAlgorithm,
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      const query = map({
        publicAccessBlock: [, ""]
      });
      let body;
      if (input.PublicAccessBlockConfiguration !== void 0) {
        body = serializeAws_restXmlPublicAccessBlockConfiguration(input.PublicAccessBlockConfiguration, context);
      }
      let contents;
      if (input.PublicAccessBlockConfiguration !== void 0) {
        contents = serializeAws_restXmlPublicAccessBlockConfiguration(input.PublicAccessBlockConfiguration, context);
        body = '<?xml version="1.0" encoding="UTF-8"?>';
        contents.addAttribute("xmlns", "http://s3.amazonaws.com/doc/2006-03-01/");
        body += contents.toString();
      }
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "PUT",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlPutPublicAccessBlockCommand = serializeAws_restXmlPutPublicAccessBlockCommand;
    var serializeAws_restXmlRestoreObjectCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "content-type": "application/xml",
        "x-amz-request-payer": input.RequestPayer,
        "x-amz-sdk-checksum-algorithm": input.ChecksumAlgorithm,
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/{Key+}`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Key", () => input.Key, "{Key+}", true);
      const query = map({
        restore: [, ""],
        "x-id": [, "RestoreObject"],
        versionId: [, input.VersionId]
      });
      let body;
      if (input.RestoreRequest !== void 0) {
        body = serializeAws_restXmlRestoreRequest(input.RestoreRequest, context);
      }
      let contents;
      if (input.RestoreRequest !== void 0) {
        contents = serializeAws_restXmlRestoreRequest(input.RestoreRequest, context);
        body = '<?xml version="1.0" encoding="UTF-8"?>';
        contents.addAttribute("xmlns", "http://s3.amazonaws.com/doc/2006-03-01/");
        body += contents.toString();
      }
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "POST",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlRestoreObjectCommand = serializeAws_restXmlRestoreObjectCommand;
    var serializeAws_restXmlSelectObjectContentCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "content-type": "application/xml",
        "x-amz-server-side-encryption-customer-algorithm": input.SSECustomerAlgorithm,
        "x-amz-server-side-encryption-customer-key": input.SSECustomerKey,
        "x-amz-server-side-encryption-customer-key-md5": input.SSECustomerKeyMD5,
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/{Key+}`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Key", () => input.Key, "{Key+}", true);
      const query = map({
        select: [, ""],
        "select-type": [, "2"],
        "x-id": [, "SelectObjectContent"]
      });
      let body;
      body = '<?xml version="1.0" encoding="UTF-8"?>';
      const bodyNode = new xml_builder_1.XmlNode("SelectObjectContentRequest");
      bodyNode.addAttribute("xmlns", "http://s3.amazonaws.com/doc/2006-03-01/");
      if (input.Expression !== void 0) {
        const node = xml_builder_1.XmlNode.of("Expression", input.Expression).withName("Expression");
        bodyNode.addChildNode(node);
      }
      if (input.ExpressionType !== void 0) {
        const node = xml_builder_1.XmlNode.of("ExpressionType", input.ExpressionType).withName("ExpressionType");
        bodyNode.addChildNode(node);
      }
      if (input.InputSerialization !== void 0) {
        const node = serializeAws_restXmlInputSerialization(input.InputSerialization, context).withName("InputSerialization");
        bodyNode.addChildNode(node);
      }
      if (input.OutputSerialization !== void 0) {
        const node = serializeAws_restXmlOutputSerialization(input.OutputSerialization, context).withName("OutputSerialization");
        bodyNode.addChildNode(node);
      }
      if (input.RequestProgress !== void 0) {
        const node = serializeAws_restXmlRequestProgress(input.RequestProgress, context).withName("RequestProgress");
        bodyNode.addChildNode(node);
      }
      if (input.ScanRange !== void 0) {
        const node = serializeAws_restXmlScanRange(input.ScanRange, context).withName("ScanRange");
        bodyNode.addChildNode(node);
      }
      body += bodyNode.toString();
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "POST",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlSelectObjectContentCommand = serializeAws_restXmlSelectObjectContentCommand;
    var serializeAws_restXmlUploadPartCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "content-type": "application/octet-stream",
        "content-length": [() => isSerializableHeaderValue(input.ContentLength), () => input.ContentLength.toString()],
        "content-md5": input.ContentMD5,
        "x-amz-sdk-checksum-algorithm": input.ChecksumAlgorithm,
        "x-amz-checksum-crc32": input.ChecksumCRC32,
        "x-amz-checksum-crc32c": input.ChecksumCRC32C,
        "x-amz-checksum-sha1": input.ChecksumSHA1,
        "x-amz-checksum-sha256": input.ChecksumSHA256,
        "x-amz-server-side-encryption-customer-algorithm": input.SSECustomerAlgorithm,
        "x-amz-server-side-encryption-customer-key": input.SSECustomerKey,
        "x-amz-server-side-encryption-customer-key-md5": input.SSECustomerKeyMD5,
        "x-amz-request-payer": input.RequestPayer,
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/{Key+}`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Key", () => input.Key, "{Key+}", true);
      const query = map({
        "x-id": [, "UploadPart"],
        partNumber: [(0, smithy_client_1.expectNonNull)(input.PartNumber, `PartNumber`) != null, () => input.PartNumber.toString()],
        uploadId: [, (0, smithy_client_1.expectNonNull)(input.UploadId, `UploadId`)]
      });
      let body;
      if (input.Body !== void 0) {
        body = input.Body;
      }
      let contents;
      if (input.Body !== void 0) {
        contents = input.Body;
        body = contents;
      }
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "PUT",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlUploadPartCommand = serializeAws_restXmlUploadPartCommand;
    var serializeAws_restXmlUploadPartCopyCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "x-amz-copy-source": input.CopySource,
        "x-amz-copy-source-if-match": input.CopySourceIfMatch,
        "x-amz-copy-source-if-modified-since": [
          () => isSerializableHeaderValue(input.CopySourceIfModifiedSince),
          () => (0, smithy_client_1.dateToUtcString)(input.CopySourceIfModifiedSince).toString()
        ],
        "x-amz-copy-source-if-none-match": input.CopySourceIfNoneMatch,
        "x-amz-copy-source-if-unmodified-since": [
          () => isSerializableHeaderValue(input.CopySourceIfUnmodifiedSince),
          () => (0, smithy_client_1.dateToUtcString)(input.CopySourceIfUnmodifiedSince).toString()
        ],
        "x-amz-copy-source-range": input.CopySourceRange,
        "x-amz-server-side-encryption-customer-algorithm": input.SSECustomerAlgorithm,
        "x-amz-server-side-encryption-customer-key": input.SSECustomerKey,
        "x-amz-server-side-encryption-customer-key-md5": input.SSECustomerKeyMD5,
        "x-amz-copy-source-server-side-encryption-customer-algorithm": input.CopySourceSSECustomerAlgorithm,
        "x-amz-copy-source-server-side-encryption-customer-key": input.CopySourceSSECustomerKey,
        "x-amz-copy-source-server-side-encryption-customer-key-md5": input.CopySourceSSECustomerKeyMD5,
        "x-amz-request-payer": input.RequestPayer,
        "x-amz-expected-bucket-owner": input.ExpectedBucketOwner,
        "x-amz-source-expected-bucket-owner": input.ExpectedSourceBucketOwner
      });
      let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/{Key+}`;
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
      resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Key", () => input.Key, "{Key+}", true);
      const query = map({
        "x-id": [, "UploadPartCopy"],
        partNumber: [(0, smithy_client_1.expectNonNull)(input.PartNumber, `PartNumber`) != null, () => input.PartNumber.toString()],
        uploadId: [, (0, smithy_client_1.expectNonNull)(input.UploadId, `UploadId`)]
      });
      let body;
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname,
        port,
        method: "PUT",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlUploadPartCopyCommand = serializeAws_restXmlUploadPartCopyCommand;
    var serializeAws_restXmlWriteGetObjectResponseCommand = async (input, context) => {
      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
      const headers = map({}, isSerializableHeaderValue, {
        "x-amz-content-sha256": "UNSIGNED-PAYLOAD",
        "content-type": "application/octet-stream",
        "x-amz-request-route": input.RequestRoute,
        "x-amz-request-token": input.RequestToken,
        "x-amz-fwd-status": [() => isSerializableHeaderValue(input.StatusCode), () => input.StatusCode.toString()],
        "x-amz-fwd-error-code": input.ErrorCode,
        "x-amz-fwd-error-message": input.ErrorMessage,
        "x-amz-fwd-header-accept-ranges": input.AcceptRanges,
        "x-amz-fwd-header-cache-control": input.CacheControl,
        "x-amz-fwd-header-content-disposition": input.ContentDisposition,
        "x-amz-fwd-header-content-encoding": input.ContentEncoding,
        "x-amz-fwd-header-content-language": input.ContentLanguage,
        "content-length": [() => isSerializableHeaderValue(input.ContentLength), () => input.ContentLength.toString()],
        "x-amz-fwd-header-content-range": input.ContentRange,
        "x-amz-fwd-header-content-type": input.ContentType,
        "x-amz-fwd-header-x-amz-checksum-crc32": input.ChecksumCRC32,
        "x-amz-fwd-header-x-amz-checksum-crc32c": input.ChecksumCRC32C,
        "x-amz-fwd-header-x-amz-checksum-sha1": input.ChecksumSHA1,
        "x-amz-fwd-header-x-amz-checksum-sha256": input.ChecksumSHA256,
        "x-amz-fwd-header-x-amz-delete-marker": [
          () => isSerializableHeaderValue(input.DeleteMarker),
          () => input.DeleteMarker.toString()
        ],
        "x-amz-fwd-header-etag": input.ETag,
        "x-amz-fwd-header-expires": [
          () => isSerializableHeaderValue(input.Expires),
          () => (0, smithy_client_1.dateToUtcString)(input.Expires).toString()
        ],
        "x-amz-fwd-header-x-amz-expiration": input.Expiration,
        "x-amz-fwd-header-last-modified": [
          () => isSerializableHeaderValue(input.LastModified),
          () => (0, smithy_client_1.dateToUtcString)(input.LastModified).toString()
        ],
        "x-amz-fwd-header-x-amz-missing-meta": [
          () => isSerializableHeaderValue(input.MissingMeta),
          () => input.MissingMeta.toString()
        ],
        "x-amz-fwd-header-x-amz-object-lock-mode": input.ObjectLockMode,
        "x-amz-fwd-header-x-amz-object-lock-legal-hold": input.ObjectLockLegalHoldStatus,
        "x-amz-fwd-header-x-amz-object-lock-retain-until-date": [
          () => isSerializableHeaderValue(input.ObjectLockRetainUntilDate),
          () => (input.ObjectLockRetainUntilDate.toISOString().split(".")[0] + "Z").toString()
        ],
        "x-amz-fwd-header-x-amz-mp-parts-count": [
          () => isSerializableHeaderValue(input.PartsCount),
          () => input.PartsCount.toString()
        ],
        "x-amz-fwd-header-x-amz-replication-status": input.ReplicationStatus,
        "x-amz-fwd-header-x-amz-request-charged": input.RequestCharged,
        "x-amz-fwd-header-x-amz-restore": input.Restore,
        "x-amz-fwd-header-x-amz-server-side-encryption": input.ServerSideEncryption,
        "x-amz-fwd-header-x-amz-server-side-encryption-customer-algorithm": input.SSECustomerAlgorithm,
        "x-amz-fwd-header-x-amz-server-side-encryption-aws-kms-key-id": input.SSEKMSKeyId,
        "x-amz-fwd-header-x-amz-server-side-encryption-customer-key-md5": input.SSECustomerKeyMD5,
        "x-amz-fwd-header-x-amz-storage-class": input.StorageClass,
        "x-amz-fwd-header-x-amz-tagging-count": [
          () => isSerializableHeaderValue(input.TagCount),
          () => input.TagCount.toString()
        ],
        "x-amz-fwd-header-x-amz-version-id": input.VersionId,
        "x-amz-fwd-header-x-amz-server-side-encryption-bucket-key-enabled": [
          () => isSerializableHeaderValue(input.BucketKeyEnabled),
          () => input.BucketKeyEnabled.toString()
        ],
        ...input.Metadata !== void 0 && Object.keys(input.Metadata).reduce((acc, suffix) => {
          acc[`x-amz-meta-${suffix.toLowerCase()}`] = input.Metadata[suffix];
          return acc;
        }, {})
      });
      const resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/WriteGetObjectResponse`;
      const query = map({
        "x-id": [, "WriteGetObjectResponse"]
      });
      let body;
      if (input.Body !== void 0) {
        body = input.Body;
      }
      let contents;
      if (input.Body !== void 0) {
        contents = input.Body;
        body = contents;
      }
      let { hostname: resolvedHostname } = await context.endpoint();
      if (context.disableHostPrefix !== true) {
        resolvedHostname = "{RequestRoute}." + resolvedHostname;
        if (input.RequestRoute === void 0) {
          throw new Error("Empty value provided for input host prefix: RequestRoute.");
        }
        resolvedHostname = resolvedHostname.replace("{RequestRoute}", input.RequestRoute);
        if (!(0, protocol_http_1.isValidHostname)(resolvedHostname)) {
          throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
        }
      }
      return new protocol_http_1.HttpRequest({
        protocol,
        hostname: resolvedHostname,
        port,
        method: "POST",
        headers,
        path: resolvedPath,
        query,
        body
      });
    };
    exports.serializeAws_restXmlWriteGetObjectResponseCommand = serializeAws_restXmlWriteGetObjectResponseCommand;
    var deserializeAws_restXmlAbortMultipartUploadCommand = async (output, context) => {
      if (output.statusCode !== 204 && output.statusCode >= 300) {
        return deserializeAws_restXmlAbortMultipartUploadCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output),
        RequestCharged: [, output.headers["x-amz-request-charged"]]
      });
      await collectBody(output.body, context);
      return contents;
    };
    exports.deserializeAws_restXmlAbortMultipartUploadCommand = deserializeAws_restXmlAbortMultipartUploadCommand;
    var deserializeAws_restXmlAbortMultipartUploadCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      switch (errorCode) {
        case "NoSuchUpload":
        case "com.amazonaws.s3#NoSuchUpload":
          throw await deserializeAws_restXmlNoSuchUploadResponse(parsedOutput, context);
        default:
          const parsedBody = parsedOutput.body;
          (0, smithy_client_1.throwDefaultError)({
            output,
            parsedBody,
            exceptionCtor: S3ServiceException_1.S3ServiceException,
            errorCode
          });
      }
    };
    var deserializeAws_restXmlCompleteMultipartUploadCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return deserializeAws_restXmlCompleteMultipartUploadCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output),
        Expiration: [, output.headers["x-amz-expiration"]],
        ServerSideEncryption: [, output.headers["x-amz-server-side-encryption"]],
        VersionId: [, output.headers["x-amz-version-id"]],
        SSEKMSKeyId: [, output.headers["x-amz-server-side-encryption-aws-kms-key-id"]],
        BucketKeyEnabled: [
          () => void 0 !== output.headers["x-amz-server-side-encryption-bucket-key-enabled"],
          () => (0, smithy_client_1.parseBoolean)(output.headers["x-amz-server-side-encryption-bucket-key-enabled"])
        ],
        RequestCharged: [, output.headers["x-amz-request-charged"]]
      });
      const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
      if (data["Bucket"] !== void 0) {
        contents.Bucket = (0, smithy_client_1.expectString)(data["Bucket"]);
      }
      if (data["ChecksumCRC32"] !== void 0) {
        contents.ChecksumCRC32 = (0, smithy_client_1.expectString)(data["ChecksumCRC32"]);
      }
      if (data["ChecksumCRC32C"] !== void 0) {
        contents.ChecksumCRC32C = (0, smithy_client_1.expectString)(data["ChecksumCRC32C"]);
      }
      if (data["ChecksumSHA1"] !== void 0) {
        contents.ChecksumSHA1 = (0, smithy_client_1.expectString)(data["ChecksumSHA1"]);
      }
      if (data["ChecksumSHA256"] !== void 0) {
        contents.ChecksumSHA256 = (0, smithy_client_1.expectString)(data["ChecksumSHA256"]);
      }
      if (data["ETag"] !== void 0) {
        contents.ETag = (0, smithy_client_1.expectString)(data["ETag"]);
      }
      if (data["Key"] !== void 0) {
        contents.Key = (0, smithy_client_1.expectString)(data["Key"]);
      }
      if (data["Location"] !== void 0) {
        contents.Location = (0, smithy_client_1.expectString)(data["Location"]);
      }
      return contents;
    };
    exports.deserializeAws_restXmlCompleteMultipartUploadCommand = deserializeAws_restXmlCompleteMultipartUploadCommand;
    var deserializeAws_restXmlCompleteMultipartUploadCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      const parsedBody = parsedOutput.body;
      (0, smithy_client_1.throwDefaultError)({
        output,
        parsedBody,
        exceptionCtor: S3ServiceException_1.S3ServiceException,
        errorCode
      });
    };
    var deserializeAws_restXmlCopyObjectCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return deserializeAws_restXmlCopyObjectCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output),
        Expiration: [, output.headers["x-amz-expiration"]],
        CopySourceVersionId: [, output.headers["x-amz-copy-source-version-id"]],
        VersionId: [, output.headers["x-amz-version-id"]],
        ServerSideEncryption: [, output.headers["x-amz-server-side-encryption"]],
        SSECustomerAlgorithm: [, output.headers["x-amz-server-side-encryption-customer-algorithm"]],
        SSECustomerKeyMD5: [, output.headers["x-amz-server-side-encryption-customer-key-md5"]],
        SSEKMSKeyId: [, output.headers["x-amz-server-side-encryption-aws-kms-key-id"]],
        SSEKMSEncryptionContext: [, output.headers["x-amz-server-side-encryption-context"]],
        BucketKeyEnabled: [
          () => void 0 !== output.headers["x-amz-server-side-encryption-bucket-key-enabled"],
          () => (0, smithy_client_1.parseBoolean)(output.headers["x-amz-server-side-encryption-bucket-key-enabled"])
        ],
        RequestCharged: [, output.headers["x-amz-request-charged"]]
      });
      const data = (0, smithy_client_1.expectObject)(await parseBody(output.body, context));
      contents.CopyObjectResult = deserializeAws_restXmlCopyObjectResult(data, context);
      return contents;
    };
    exports.deserializeAws_restXmlCopyObjectCommand = deserializeAws_restXmlCopyObjectCommand;
    var deserializeAws_restXmlCopyObjectCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      switch (errorCode) {
        case "ObjectNotInActiveTierError":
        case "com.amazonaws.s3#ObjectNotInActiveTierError":
          throw await deserializeAws_restXmlObjectNotInActiveTierErrorResponse(parsedOutput, context);
        default:
          const parsedBody = parsedOutput.body;
          (0, smithy_client_1.throwDefaultError)({
            output,
            parsedBody,
            exceptionCtor: S3ServiceException_1.S3ServiceException,
            errorCode
          });
      }
    };
    var deserializeAws_restXmlCreateBucketCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return deserializeAws_restXmlCreateBucketCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output),
        Location: [, output.headers["location"]]
      });
      await collectBody(output.body, context);
      return contents;
    };
    exports.deserializeAws_restXmlCreateBucketCommand = deserializeAws_restXmlCreateBucketCommand;
    var deserializeAws_restXmlCreateBucketCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      switch (errorCode) {
        case "BucketAlreadyExists":
        case "com.amazonaws.s3#BucketAlreadyExists":
          throw await deserializeAws_restXmlBucketAlreadyExistsResponse(parsedOutput, context);
        case "BucketAlreadyOwnedByYou":
        case "com.amazonaws.s3#BucketAlreadyOwnedByYou":
          throw await deserializeAws_restXmlBucketAlreadyOwnedByYouResponse(parsedOutput, context);
        default:
          const parsedBody = parsedOutput.body;
          (0, smithy_client_1.throwDefaultError)({
            output,
            parsedBody,
            exceptionCtor: S3ServiceException_1.S3ServiceException,
            errorCode
          });
      }
    };
    var deserializeAws_restXmlCreateMultipartUploadCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return deserializeAws_restXmlCreateMultipartUploadCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output),
        AbortDate: [
          () => void 0 !== output.headers["x-amz-abort-date"],
          () => (0, smithy_client_1.expectNonNull)((0, smithy_client_1.parseRfc7231DateTime)(output.headers["x-amz-abort-date"]))
        ],
        AbortRuleId: [, output.headers["x-amz-abort-rule-id"]],
        ServerSideEncryption: [, output.headers["x-amz-server-side-encryption"]],
        SSECustomerAlgorithm: [, output.headers["x-amz-server-side-encryption-customer-algorithm"]],
        SSECustomerKeyMD5: [, output.headers["x-amz-server-side-encryption-customer-key-md5"]],
        SSEKMSKeyId: [, output.headers["x-amz-server-side-encryption-aws-kms-key-id"]],
        SSEKMSEncryptionContext: [, output.headers["x-amz-server-side-encryption-context"]],
        BucketKeyEnabled: [
          () => void 0 !== output.headers["x-amz-server-side-encryption-bucket-key-enabled"],
          () => (0, smithy_client_1.parseBoolean)(output.headers["x-amz-server-side-encryption-bucket-key-enabled"])
        ],
        RequestCharged: [, output.headers["x-amz-request-charged"]],
        ChecksumAlgorithm: [, output.headers["x-amz-checksum-algorithm"]]
      });
      const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
      if (data["Bucket"] !== void 0) {
        contents.Bucket = (0, smithy_client_1.expectString)(data["Bucket"]);
      }
      if (data["Key"] !== void 0) {
        contents.Key = (0, smithy_client_1.expectString)(data["Key"]);
      }
      if (data["UploadId"] !== void 0) {
        contents.UploadId = (0, smithy_client_1.expectString)(data["UploadId"]);
      }
      return contents;
    };
    exports.deserializeAws_restXmlCreateMultipartUploadCommand = deserializeAws_restXmlCreateMultipartUploadCommand;
    var deserializeAws_restXmlCreateMultipartUploadCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      const parsedBody = parsedOutput.body;
      (0, smithy_client_1.throwDefaultError)({
        output,
        parsedBody,
        exceptionCtor: S3ServiceException_1.S3ServiceException,
        errorCode
      });
    };
    var deserializeAws_restXmlDeleteBucketCommand = async (output, context) => {
      if (output.statusCode !== 204 && output.statusCode >= 300) {
        return deserializeAws_restXmlDeleteBucketCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output)
      });
      await collectBody(output.body, context);
      return contents;
    };
    exports.deserializeAws_restXmlDeleteBucketCommand = deserializeAws_restXmlDeleteBucketCommand;
    var deserializeAws_restXmlDeleteBucketCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      const parsedBody = parsedOutput.body;
      (0, smithy_client_1.throwDefaultError)({
        output,
        parsedBody,
        exceptionCtor: S3ServiceException_1.S3ServiceException,
        errorCode
      });
    };
    var deserializeAws_restXmlDeleteBucketAnalyticsConfigurationCommand = async (output, context) => {
      if (output.statusCode !== 204 && output.statusCode >= 300) {
        return deserializeAws_restXmlDeleteBucketAnalyticsConfigurationCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output)
      });
      await collectBody(output.body, context);
      return contents;
    };
    exports.deserializeAws_restXmlDeleteBucketAnalyticsConfigurationCommand = deserializeAws_restXmlDeleteBucketAnalyticsConfigurationCommand;
    var deserializeAws_restXmlDeleteBucketAnalyticsConfigurationCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      const parsedBody = parsedOutput.body;
      (0, smithy_client_1.throwDefaultError)({
        output,
        parsedBody,
        exceptionCtor: S3ServiceException_1.S3ServiceException,
        errorCode
      });
    };
    var deserializeAws_restXmlDeleteBucketCorsCommand = async (output, context) => {
      if (output.statusCode !== 204 && output.statusCode >= 300) {
        return deserializeAws_restXmlDeleteBucketCorsCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output)
      });
      await collectBody(output.body, context);
      return contents;
    };
    exports.deserializeAws_restXmlDeleteBucketCorsCommand = deserializeAws_restXmlDeleteBucketCorsCommand;
    var deserializeAws_restXmlDeleteBucketCorsCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      const parsedBody = parsedOutput.body;
      (0, smithy_client_1.throwDefaultError)({
        output,
        parsedBody,
        exceptionCtor: S3ServiceException_1.S3ServiceException,
        errorCode
      });
    };
    var deserializeAws_restXmlDeleteBucketEncryptionCommand = async (output, context) => {
      if (output.statusCode !== 204 && output.statusCode >= 300) {
        return deserializeAws_restXmlDeleteBucketEncryptionCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output)
      });
      await collectBody(output.body, context);
      return contents;
    };
    exports.deserializeAws_restXmlDeleteBucketEncryptionCommand = deserializeAws_restXmlDeleteBucketEncryptionCommand;
    var deserializeAws_restXmlDeleteBucketEncryptionCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      const parsedBody = parsedOutput.body;
      (0, smithy_client_1.throwDefaultError)({
        output,
        parsedBody,
        exceptionCtor: S3ServiceException_1.S3ServiceException,
        errorCode
      });
    };
    var deserializeAws_restXmlDeleteBucketIntelligentTieringConfigurationCommand = async (output, context) => {
      if (output.statusCode !== 204 && output.statusCode >= 300) {
        return deserializeAws_restXmlDeleteBucketIntelligentTieringConfigurationCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output)
      });
      await collectBody(output.body, context);
      return contents;
    };
    exports.deserializeAws_restXmlDeleteBucketIntelligentTieringConfigurationCommand = deserializeAws_restXmlDeleteBucketIntelligentTieringConfigurationCommand;
    var deserializeAws_restXmlDeleteBucketIntelligentTieringConfigurationCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      const parsedBody = parsedOutput.body;
      (0, smithy_client_1.throwDefaultError)({
        output,
        parsedBody,
        exceptionCtor: S3ServiceException_1.S3ServiceException,
        errorCode
      });
    };
    var deserializeAws_restXmlDeleteBucketInventoryConfigurationCommand = async (output, context) => {
      if (output.statusCode !== 204 && output.statusCode >= 300) {
        return deserializeAws_restXmlDeleteBucketInventoryConfigurationCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output)
      });
      await collectBody(output.body, context);
      return contents;
    };
    exports.deserializeAws_restXmlDeleteBucketInventoryConfigurationCommand = deserializeAws_restXmlDeleteBucketInventoryConfigurationCommand;
    var deserializeAws_restXmlDeleteBucketInventoryConfigurationCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      const parsedBody = parsedOutput.body;
      (0, smithy_client_1.throwDefaultError)({
        output,
        parsedBody,
        exceptionCtor: S3ServiceException_1.S3ServiceException,
        errorCode
      });
    };
    var deserializeAws_restXmlDeleteBucketLifecycleCommand = async (output, context) => {
      if (output.statusCode !== 204 && output.statusCode >= 300) {
        return deserializeAws_restXmlDeleteBucketLifecycleCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output)
      });
      await collectBody(output.body, context);
      return contents;
    };
    exports.deserializeAws_restXmlDeleteBucketLifecycleCommand = deserializeAws_restXmlDeleteBucketLifecycleCommand;
    var deserializeAws_restXmlDeleteBucketLifecycleCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      const parsedBody = parsedOutput.body;
      (0, smithy_client_1.throwDefaultError)({
        output,
        parsedBody,
        exceptionCtor: S3ServiceException_1.S3ServiceException,
        errorCode
      });
    };
    var deserializeAws_restXmlDeleteBucketMetricsConfigurationCommand = async (output, context) => {
      if (output.statusCode !== 204 && output.statusCode >= 300) {
        return deserializeAws_restXmlDeleteBucketMetricsConfigurationCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output)
      });
      await collectBody(output.body, context);
      return contents;
    };
    exports.deserializeAws_restXmlDeleteBucketMetricsConfigurationCommand = deserializeAws_restXmlDeleteBucketMetricsConfigurationCommand;
    var deserializeAws_restXmlDeleteBucketMetricsConfigurationCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      const parsedBody = parsedOutput.body;
      (0, smithy_client_1.throwDefaultError)({
        output,
        parsedBody,
        exceptionCtor: S3ServiceException_1.S3ServiceException,
        errorCode
      });
    };
    var deserializeAws_restXmlDeleteBucketOwnershipControlsCommand = async (output, context) => {
      if (output.statusCode !== 204 && output.statusCode >= 300) {
        return deserializeAws_restXmlDeleteBucketOwnershipControlsCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output)
      });
      await collectBody(output.body, context);
      return contents;
    };
    exports.deserializeAws_restXmlDeleteBucketOwnershipControlsCommand = deserializeAws_restXmlDeleteBucketOwnershipControlsCommand;
    var deserializeAws_restXmlDeleteBucketOwnershipControlsCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      const parsedBody = parsedOutput.body;
      (0, smithy_client_1.throwDefaultError)({
        output,
        parsedBody,
        exceptionCtor: S3ServiceException_1.S3ServiceException,
        errorCode
      });
    };
    var deserializeAws_restXmlDeleteBucketPolicyCommand = async (output, context) => {
      if (output.statusCode !== 204 && output.statusCode >= 300) {
        return deserializeAws_restXmlDeleteBucketPolicyCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output)
      });
      await collectBody(output.body, context);
      return contents;
    };
    exports.deserializeAws_restXmlDeleteBucketPolicyCommand = deserializeAws_restXmlDeleteBucketPolicyCommand;
    var deserializeAws_restXmlDeleteBucketPolicyCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      const parsedBody = parsedOutput.body;
      (0, smithy_client_1.throwDefaultError)({
        output,
        parsedBody,
        exceptionCtor: S3ServiceException_1.S3ServiceException,
        errorCode
      });
    };
    var deserializeAws_restXmlDeleteBucketReplicationCommand = async (output, context) => {
      if (output.statusCode !== 204 && output.statusCode >= 300) {
        return deserializeAws_restXmlDeleteBucketReplicationCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output)
      });
      await collectBody(output.body, context);
      return contents;
    };
    exports.deserializeAws_restXmlDeleteBucketReplicationCommand = deserializeAws_restXmlDeleteBucketReplicationCommand;
    var deserializeAws_restXmlDeleteBucketReplicationCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      const parsedBody = parsedOutput.body;
      (0, smithy_client_1.throwDefaultError)({
        output,
        parsedBody,
        exceptionCtor: S3ServiceException_1.S3ServiceException,
        errorCode
      });
    };
    var deserializeAws_restXmlDeleteBucketTaggingCommand = async (output, context) => {
      if (output.statusCode !== 204 && output.statusCode >= 300) {
        return deserializeAws_restXmlDeleteBucketTaggingCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output)
      });
      await collectBody(output.body, context);
      return contents;
    };
    exports.deserializeAws_restXmlDeleteBucketTaggingCommand = deserializeAws_restXmlDeleteBucketTaggingCommand;
    var deserializeAws_restXmlDeleteBucketTaggingCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      const parsedBody = parsedOutput.body;
      (0, smithy_client_1.throwDefaultError)({
        output,
        parsedBody,
        exceptionCtor: S3ServiceException_1.S3ServiceException,
        errorCode
      });
    };
    var deserializeAws_restXmlDeleteBucketWebsiteCommand = async (output, context) => {
      if (output.statusCode !== 204 && output.statusCode >= 300) {
        return deserializeAws_restXmlDeleteBucketWebsiteCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output)
      });
      await collectBody(output.body, context);
      return contents;
    };
    exports.deserializeAws_restXmlDeleteBucketWebsiteCommand = deserializeAws_restXmlDeleteBucketWebsiteCommand;
    var deserializeAws_restXmlDeleteBucketWebsiteCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      const parsedBody = parsedOutput.body;
      (0, smithy_client_1.throwDefaultError)({
        output,
        parsedBody,
        exceptionCtor: S3ServiceException_1.S3ServiceException,
        errorCode
      });
    };
    var deserializeAws_restXmlDeleteObjectCommand = async (output, context) => {
      if (output.statusCode !== 204 && output.statusCode >= 300) {
        return deserializeAws_restXmlDeleteObjectCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output),
        DeleteMarker: [
          () => void 0 !== output.headers["x-amz-delete-marker"],
          () => (0, smithy_client_1.parseBoolean)(output.headers["x-amz-delete-marker"])
        ],
        VersionId: [, output.headers["x-amz-version-id"]],
        RequestCharged: [, output.headers["x-amz-request-charged"]]
      });
      await collectBody(output.body, context);
      return contents;
    };
    exports.deserializeAws_restXmlDeleteObjectCommand = deserializeAws_restXmlDeleteObjectCommand;
    var deserializeAws_restXmlDeleteObjectCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      const parsedBody = parsedOutput.body;
      (0, smithy_client_1.throwDefaultError)({
        output,
        parsedBody,
        exceptionCtor: S3ServiceException_1.S3ServiceException,
        errorCode
      });
    };
    var deserializeAws_restXmlDeleteObjectsCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return deserializeAws_restXmlDeleteObjectsCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output),
        RequestCharged: [, output.headers["x-amz-request-charged"]]
      });
      const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
      if (data.Deleted === "") {
        contents.Deleted = [];
      } else if (data["Deleted"] !== void 0) {
        contents.Deleted = deserializeAws_restXmlDeletedObjects((0, smithy_client_1.getArrayIfSingleItem)(data["Deleted"]), context);
      }
      if (data.Error === "") {
        contents.Errors = [];
      } else if (data["Error"] !== void 0) {
        contents.Errors = deserializeAws_restXmlErrors((0, smithy_client_1.getArrayIfSingleItem)(data["Error"]), context);
      }
      return contents;
    };
    exports.deserializeAws_restXmlDeleteObjectsCommand = deserializeAws_restXmlDeleteObjectsCommand;
    var deserializeAws_restXmlDeleteObjectsCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      const parsedBody = parsedOutput.body;
      (0, smithy_client_1.throwDefaultError)({
        output,
        parsedBody,
        exceptionCtor: S3ServiceException_1.S3ServiceException,
        errorCode
      });
    };
    var deserializeAws_restXmlDeleteObjectTaggingCommand = async (output, context) => {
      if (output.statusCode !== 204 && output.statusCode >= 300) {
        return deserializeAws_restXmlDeleteObjectTaggingCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output),
        VersionId: [, output.headers["x-amz-version-id"]]
      });
      await collectBody(output.body, context);
      return contents;
    };
    exports.deserializeAws_restXmlDeleteObjectTaggingCommand = deserializeAws_restXmlDeleteObjectTaggingCommand;
    var deserializeAws_restXmlDeleteObjectTaggingCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      const parsedBody = parsedOutput.body;
      (0, smithy_client_1.throwDefaultError)({
        output,
        parsedBody,
        exceptionCtor: S3ServiceException_1.S3ServiceException,
        errorCode
      });
    };
    var deserializeAws_restXmlDeletePublicAccessBlockCommand = async (output, context) => {
      if (output.statusCode !== 204 && output.statusCode >= 300) {
        return deserializeAws_restXmlDeletePublicAccessBlockCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output)
      });
      await collectBody(output.body, context);
      return contents;
    };
    exports.deserializeAws_restXmlDeletePublicAccessBlockCommand = deserializeAws_restXmlDeletePublicAccessBlockCommand;
    var deserializeAws_restXmlDeletePublicAccessBlockCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      const parsedBody = parsedOutput.body;
      (0, smithy_client_1.throwDefaultError)({
        output,
        parsedBody,
        exceptionCtor: S3ServiceException_1.S3ServiceException,
        errorCode
      });
    };
    var deserializeAws_restXmlGetBucketAccelerateConfigurationCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return deserializeAws_restXmlGetBucketAccelerateConfigurationCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output)
      });
      const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
      if (data["Status"] !== void 0) {
        contents.Status = (0, smithy_client_1.expectString)(data["Status"]);
      }
      return contents;
    };
    exports.deserializeAws_restXmlGetBucketAccelerateConfigurationCommand = deserializeAws_restXmlGetBucketAccelerateConfigurationCommand;
    var deserializeAws_restXmlGetBucketAccelerateConfigurationCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      const parsedBody = parsedOutput.body;
      (0, smithy_client_1.throwDefaultError)({
        output,
        parsedBody,
        exceptionCtor: S3ServiceException_1.S3ServiceException,
        errorCode
      });
    };
    var deserializeAws_restXmlGetBucketAclCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return deserializeAws_restXmlGetBucketAclCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output)
      });
      const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
      if (data.AccessControlList === "") {
        contents.Grants = [];
      } else if (data["AccessControlList"] !== void 0 && data["AccessControlList"]["Grant"] !== void 0) {
        contents.Grants = deserializeAws_restXmlGrants((0, smithy_client_1.getArrayIfSingleItem)(data["AccessControlList"]["Grant"]), context);
      }
      if (data["Owner"] !== void 0) {
        contents.Owner = deserializeAws_restXmlOwner(data["Owner"], context);
      }
      return contents;
    };
    exports.deserializeAws_restXmlGetBucketAclCommand = deserializeAws_restXmlGetBucketAclCommand;
    var deserializeAws_restXmlGetBucketAclCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      const parsedBody = parsedOutput.body;
      (0, smithy_client_1.throwDefaultError)({
        output,
        parsedBody,
        exceptionCtor: S3ServiceException_1.S3ServiceException,
        errorCode
      });
    };
    var deserializeAws_restXmlGetBucketAnalyticsConfigurationCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return deserializeAws_restXmlGetBucketAnalyticsConfigurationCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output)
      });
      const data = (0, smithy_client_1.expectObject)(await parseBody(output.body, context));
      contents.AnalyticsConfiguration = deserializeAws_restXmlAnalyticsConfiguration(data, context);
      return contents;
    };
    exports.deserializeAws_restXmlGetBucketAnalyticsConfigurationCommand = deserializeAws_restXmlGetBucketAnalyticsConfigurationCommand;
    var deserializeAws_restXmlGetBucketAnalyticsConfigurationCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      const parsedBody = parsedOutput.body;
      (0, smithy_client_1.throwDefaultError)({
        output,
        parsedBody,
        exceptionCtor: S3ServiceException_1.S3ServiceException,
        errorCode
      });
    };
    var deserializeAws_restXmlGetBucketCorsCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return deserializeAws_restXmlGetBucketCorsCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output)
      });
      const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
      if (data.CORSRule === "") {
        contents.CORSRules = [];
      } else if (data["CORSRule"] !== void 0) {
        contents.CORSRules = deserializeAws_restXmlCORSRules((0, smithy_client_1.getArrayIfSingleItem)(data["CORSRule"]), context);
      }
      return contents;
    };
    exports.deserializeAws_restXmlGetBucketCorsCommand = deserializeAws_restXmlGetBucketCorsCommand;
    var deserializeAws_restXmlGetBucketCorsCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      const parsedBody = parsedOutput.body;
      (0, smithy_client_1.throwDefaultError)({
        output,
        parsedBody,
        exceptionCtor: S3ServiceException_1.S3ServiceException,
        errorCode
      });
    };
    var deserializeAws_restXmlGetBucketEncryptionCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return deserializeAws_restXmlGetBucketEncryptionCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output)
      });
      const data = (0, smithy_client_1.expectObject)(await parseBody(output.body, context));
      contents.ServerSideEncryptionConfiguration = deserializeAws_restXmlServerSideEncryptionConfiguration(data, context);
      return contents;
    };
    exports.deserializeAws_restXmlGetBucketEncryptionCommand = deserializeAws_restXmlGetBucketEncryptionCommand;
    var deserializeAws_restXmlGetBucketEncryptionCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      const parsedBody = parsedOutput.body;
      (0, smithy_client_1.throwDefaultError)({
        output,
        parsedBody,
        exceptionCtor: S3ServiceException_1.S3ServiceException,
        errorCode
      });
    };
    var deserializeAws_restXmlGetBucketIntelligentTieringConfigurationCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return deserializeAws_restXmlGetBucketIntelligentTieringConfigurationCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output)
      });
      const data = (0, smithy_client_1.expectObject)(await parseBody(output.body, context));
      contents.IntelligentTieringConfiguration = deserializeAws_restXmlIntelligentTieringConfiguration(data, context);
      return contents;
    };
    exports.deserializeAws_restXmlGetBucketIntelligentTieringConfigurationCommand = deserializeAws_restXmlGetBucketIntelligentTieringConfigurationCommand;
    var deserializeAws_restXmlGetBucketIntelligentTieringConfigurationCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      const parsedBody = parsedOutput.body;
      (0, smithy_client_1.throwDefaultError)({
        output,
        parsedBody,
        exceptionCtor: S3ServiceException_1.S3ServiceException,
        errorCode
      });
    };
    var deserializeAws_restXmlGetBucketInventoryConfigurationCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return deserializeAws_restXmlGetBucketInventoryConfigurationCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output)
      });
      const data = (0, smithy_client_1.expectObject)(await parseBody(output.body, context));
      contents.InventoryConfiguration = deserializeAws_restXmlInventoryConfiguration(data, context);
      return contents;
    };
    exports.deserializeAws_restXmlGetBucketInventoryConfigurationCommand = deserializeAws_restXmlGetBucketInventoryConfigurationCommand;
    var deserializeAws_restXmlGetBucketInventoryConfigurationCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      const parsedBody = parsedOutput.body;
      (0, smithy_client_1.throwDefaultError)({
        output,
        parsedBody,
        exceptionCtor: S3ServiceException_1.S3ServiceException,
        errorCode
      });
    };
    var deserializeAws_restXmlGetBucketLifecycleConfigurationCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return deserializeAws_restXmlGetBucketLifecycleConfigurationCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output)
      });
      const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
      if (data.Rule === "") {
        contents.Rules = [];
      } else if (data["Rule"] !== void 0) {
        contents.Rules = deserializeAws_restXmlLifecycleRules((0, smithy_client_1.getArrayIfSingleItem)(data["Rule"]), context);
      }
      return contents;
    };
    exports.deserializeAws_restXmlGetBucketLifecycleConfigurationCommand = deserializeAws_restXmlGetBucketLifecycleConfigurationCommand;
    var deserializeAws_restXmlGetBucketLifecycleConfigurationCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      const parsedBody = parsedOutput.body;
      (0, smithy_client_1.throwDefaultError)({
        output,
        parsedBody,
        exceptionCtor: S3ServiceException_1.S3ServiceException,
        errorCode
      });
    };
    var deserializeAws_restXmlGetBucketLocationCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return deserializeAws_restXmlGetBucketLocationCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output)
      });
      const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
      if (data["LocationConstraint"] !== void 0) {
        contents.LocationConstraint = (0, smithy_client_1.expectString)(data["LocationConstraint"]);
      }
      return contents;
    };
    exports.deserializeAws_restXmlGetBucketLocationCommand = deserializeAws_restXmlGetBucketLocationCommand;
    var deserializeAws_restXmlGetBucketLocationCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      const parsedBody = parsedOutput.body;
      (0, smithy_client_1.throwDefaultError)({
        output,
        parsedBody,
        exceptionCtor: S3ServiceException_1.S3ServiceException,
        errorCode
      });
    };
    var deserializeAws_restXmlGetBucketLoggingCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return deserializeAws_restXmlGetBucketLoggingCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output)
      });
      const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
      if (data["LoggingEnabled"] !== void 0) {
        contents.LoggingEnabled = deserializeAws_restXmlLoggingEnabled(data["LoggingEnabled"], context);
      }
      return contents;
    };
    exports.deserializeAws_restXmlGetBucketLoggingCommand = deserializeAws_restXmlGetBucketLoggingCommand;
    var deserializeAws_restXmlGetBucketLoggingCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      const parsedBody = parsedOutput.body;
      (0, smithy_client_1.throwDefaultError)({
        output,
        parsedBody,
        exceptionCtor: S3ServiceException_1.S3ServiceException,
        errorCode
      });
    };
    var deserializeAws_restXmlGetBucketMetricsConfigurationCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return deserializeAws_restXmlGetBucketMetricsConfigurationCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output)
      });
      const data = (0, smithy_client_1.expectObject)(await parseBody(output.body, context));
      contents.MetricsConfiguration = deserializeAws_restXmlMetricsConfiguration(data, context);
      return contents;
    };
    exports.deserializeAws_restXmlGetBucketMetricsConfigurationCommand = deserializeAws_restXmlGetBucketMetricsConfigurationCommand;
    var deserializeAws_restXmlGetBucketMetricsConfigurationCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      const parsedBody = parsedOutput.body;
      (0, smithy_client_1.throwDefaultError)({
        output,
        parsedBody,
        exceptionCtor: S3ServiceException_1.S3ServiceException,
        errorCode
      });
    };
    var deserializeAws_restXmlGetBucketNotificationConfigurationCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return deserializeAws_restXmlGetBucketNotificationConfigurationCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output)
      });
      const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
      if (data["EventBridgeConfiguration"] !== void 0) {
        contents.EventBridgeConfiguration = deserializeAws_restXmlEventBridgeConfiguration(data["EventBridgeConfiguration"], context);
      }
      if (data.CloudFunctionConfiguration === "") {
        contents.LambdaFunctionConfigurations = [];
      } else if (data["CloudFunctionConfiguration"] !== void 0) {
        contents.LambdaFunctionConfigurations = deserializeAws_restXmlLambdaFunctionConfigurationList((0, smithy_client_1.getArrayIfSingleItem)(data["CloudFunctionConfiguration"]), context);
      }
      if (data.QueueConfiguration === "") {
        contents.QueueConfigurations = [];
      } else if (data["QueueConfiguration"] !== void 0) {
        contents.QueueConfigurations = deserializeAws_restXmlQueueConfigurationList((0, smithy_client_1.getArrayIfSingleItem)(data["QueueConfiguration"]), context);
      }
      if (data.TopicConfiguration === "") {
        contents.TopicConfigurations = [];
      } else if (data["TopicConfiguration"] !== void 0) {
        contents.TopicConfigurations = deserializeAws_restXmlTopicConfigurationList((0, smithy_client_1.getArrayIfSingleItem)(data["TopicConfiguration"]), context);
      }
      return contents;
    };
    exports.deserializeAws_restXmlGetBucketNotificationConfigurationCommand = deserializeAws_restXmlGetBucketNotificationConfigurationCommand;
    var deserializeAws_restXmlGetBucketNotificationConfigurationCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      const parsedBody = parsedOutput.body;
      (0, smithy_client_1.throwDefaultError)({
        output,
        parsedBody,
        exceptionCtor: S3ServiceException_1.S3ServiceException,
        errorCode
      });
    };
    var deserializeAws_restXmlGetBucketOwnershipControlsCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return deserializeAws_restXmlGetBucketOwnershipControlsCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output)
      });
      const data = (0, smithy_client_1.expectObject)(await parseBody(output.body, context));
      contents.OwnershipControls = deserializeAws_restXmlOwnershipControls(data, context);
      return contents;
    };
    exports.deserializeAws_restXmlGetBucketOwnershipControlsCommand = deserializeAws_restXmlGetBucketOwnershipControlsCommand;
    var deserializeAws_restXmlGetBucketOwnershipControlsCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      const parsedBody = parsedOutput.body;
      (0, smithy_client_1.throwDefaultError)({
        output,
        parsedBody,
        exceptionCtor: S3ServiceException_1.S3ServiceException,
        errorCode
      });
    };
    var deserializeAws_restXmlGetBucketPolicyCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return deserializeAws_restXmlGetBucketPolicyCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output)
      });
      const data = await collectBodyString(output.body, context);
      contents.Policy = (0, smithy_client_1.expectString)(data);
      return contents;
    };
    exports.deserializeAws_restXmlGetBucketPolicyCommand = deserializeAws_restXmlGetBucketPolicyCommand;
    var deserializeAws_restXmlGetBucketPolicyCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      const parsedBody = parsedOutput.body;
      (0, smithy_client_1.throwDefaultError)({
        output,
        parsedBody,
        exceptionCtor: S3ServiceException_1.S3ServiceException,
        errorCode
      });
    };
    var deserializeAws_restXmlGetBucketPolicyStatusCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return deserializeAws_restXmlGetBucketPolicyStatusCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output)
      });
      const data = (0, smithy_client_1.expectObject)(await parseBody(output.body, context));
      contents.PolicyStatus = deserializeAws_restXmlPolicyStatus(data, context);
      return contents;
    };
    exports.deserializeAws_restXmlGetBucketPolicyStatusCommand = deserializeAws_restXmlGetBucketPolicyStatusCommand;
    var deserializeAws_restXmlGetBucketPolicyStatusCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      const parsedBody = parsedOutput.body;
      (0, smithy_client_1.throwDefaultError)({
        output,
        parsedBody,
        exceptionCtor: S3ServiceException_1.S3ServiceException,
        errorCode
      });
    };
    var deserializeAws_restXmlGetBucketReplicationCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return deserializeAws_restXmlGetBucketReplicationCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output)
      });
      const data = (0, smithy_client_1.expectObject)(await parseBody(output.body, context));
      contents.ReplicationConfiguration = deserializeAws_restXmlReplicationConfiguration(data, context);
      return contents;
    };
    exports.deserializeAws_restXmlGetBucketReplicationCommand = deserializeAws_restXmlGetBucketReplicationCommand;
    var deserializeAws_restXmlGetBucketReplicationCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      const parsedBody = parsedOutput.body;
      (0, smithy_client_1.throwDefaultError)({
        output,
        parsedBody,
        exceptionCtor: S3ServiceException_1.S3ServiceException,
        errorCode
      });
    };
    var deserializeAws_restXmlGetBucketRequestPaymentCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return deserializeAws_restXmlGetBucketRequestPaymentCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output)
      });
      const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
      if (data["Payer"] !== void 0) {
        contents.Payer = (0, smithy_client_1.expectString)(data["Payer"]);
      }
      return contents;
    };
    exports.deserializeAws_restXmlGetBucketRequestPaymentCommand = deserializeAws_restXmlGetBucketRequestPaymentCommand;
    var deserializeAws_restXmlGetBucketRequestPaymentCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      const parsedBody = parsedOutput.body;
      (0, smithy_client_1.throwDefaultError)({
        output,
        parsedBody,
        exceptionCtor: S3ServiceException_1.S3ServiceException,
        errorCode
      });
    };
    var deserializeAws_restXmlGetBucketTaggingCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return deserializeAws_restXmlGetBucketTaggingCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output)
      });
      const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
      if (data.TagSet === "") {
        contents.TagSet = [];
      } else if (data["TagSet"] !== void 0 && data["TagSet"]["Tag"] !== void 0) {
        contents.TagSet = deserializeAws_restXmlTagSet((0, smithy_client_1.getArrayIfSingleItem)(data["TagSet"]["Tag"]), context);
      }
      return contents;
    };
    exports.deserializeAws_restXmlGetBucketTaggingCommand = deserializeAws_restXmlGetBucketTaggingCommand;
    var deserializeAws_restXmlGetBucketTaggingCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      const parsedBody = parsedOutput.body;
      (0, smithy_client_1.throwDefaultError)({
        output,
        parsedBody,
        exceptionCtor: S3ServiceException_1.S3ServiceException,
        errorCode
      });
    };
    var deserializeAws_restXmlGetBucketVersioningCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return deserializeAws_restXmlGetBucketVersioningCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output)
      });
      const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
      if (data["MfaDelete"] !== void 0) {
        contents.MFADelete = (0, smithy_client_1.expectString)(data["MfaDelete"]);
      }
      if (data["Status"] !== void 0) {
        contents.Status = (0, smithy_client_1.expectString)(data["Status"]);
      }
      return contents;
    };
    exports.deserializeAws_restXmlGetBucketVersioningCommand = deserializeAws_restXmlGetBucketVersioningCommand;
    var deserializeAws_restXmlGetBucketVersioningCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      const parsedBody = parsedOutput.body;
      (0, smithy_client_1.throwDefaultError)({
        output,
        parsedBody,
        exceptionCtor: S3ServiceException_1.S3ServiceException,
        errorCode
      });
    };
    var deserializeAws_restXmlGetBucketWebsiteCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return deserializeAws_restXmlGetBucketWebsiteCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output)
      });
      const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
      if (data["ErrorDocument"] !== void 0) {
        contents.ErrorDocument = deserializeAws_restXmlErrorDocument(data["ErrorDocument"], context);
      }
      if (data["IndexDocument"] !== void 0) {
        contents.IndexDocument = deserializeAws_restXmlIndexDocument(data["IndexDocument"], context);
      }
      if (data["RedirectAllRequestsTo"] !== void 0) {
        contents.RedirectAllRequestsTo = deserializeAws_restXmlRedirectAllRequestsTo(data["RedirectAllRequestsTo"], context);
      }
      if (data.RoutingRules === "") {
        contents.RoutingRules = [];
      } else if (data["RoutingRules"] !== void 0 && data["RoutingRules"]["RoutingRule"] !== void 0) {
        contents.RoutingRules = deserializeAws_restXmlRoutingRules((0, smithy_client_1.getArrayIfSingleItem)(data["RoutingRules"]["RoutingRule"]), context);
      }
      return contents;
    };
    exports.deserializeAws_restXmlGetBucketWebsiteCommand = deserializeAws_restXmlGetBucketWebsiteCommand;
    var deserializeAws_restXmlGetBucketWebsiteCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      const parsedBody = parsedOutput.body;
      (0, smithy_client_1.throwDefaultError)({
        output,
        parsedBody,
        exceptionCtor: S3ServiceException_1.S3ServiceException,
        errorCode
      });
    };
    var deserializeAws_restXmlGetObjectCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return deserializeAws_restXmlGetObjectCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output),
        DeleteMarker: [
          () => void 0 !== output.headers["x-amz-delete-marker"],
          () => (0, smithy_client_1.parseBoolean)(output.headers["x-amz-delete-marker"])
        ],
        AcceptRanges: [, output.headers["accept-ranges"]],
        Expiration: [, output.headers["x-amz-expiration"]],
        Restore: [, output.headers["x-amz-restore"]],
        LastModified: [
          () => void 0 !== output.headers["last-modified"],
          () => (0, smithy_client_1.expectNonNull)((0, smithy_client_1.parseRfc7231DateTime)(output.headers["last-modified"]))
        ],
        ContentLength: [
          () => void 0 !== output.headers["content-length"],
          () => (0, smithy_client_1.strictParseLong)(output.headers["content-length"])
        ],
        ETag: [, output.headers["etag"]],
        ChecksumCRC32: [, output.headers["x-amz-checksum-crc32"]],
        ChecksumCRC32C: [, output.headers["x-amz-checksum-crc32c"]],
        ChecksumSHA1: [, output.headers["x-amz-checksum-sha1"]],
        ChecksumSHA256: [, output.headers["x-amz-checksum-sha256"]],
        MissingMeta: [
          () => void 0 !== output.headers["x-amz-missing-meta"],
          () => (0, smithy_client_1.strictParseInt32)(output.headers["x-amz-missing-meta"])
        ],
        VersionId: [, output.headers["x-amz-version-id"]],
        CacheControl: [, output.headers["cache-control"]],
        ContentDisposition: [, output.headers["content-disposition"]],
        ContentEncoding: [, output.headers["content-encoding"]],
        ContentLanguage: [, output.headers["content-language"]],
        ContentRange: [, output.headers["content-range"]],
        ContentType: [, output.headers["content-type"]],
        Expires: [
          () => void 0 !== output.headers["expires"],
          () => (0, smithy_client_1.expectNonNull)((0, smithy_client_1.parseRfc7231DateTime)(output.headers["expires"]))
        ],
        WebsiteRedirectLocation: [, output.headers["x-amz-website-redirect-location"]],
        ServerSideEncryption: [, output.headers["x-amz-server-side-encryption"]],
        SSECustomerAlgorithm: [, output.headers["x-amz-server-side-encryption-customer-algorithm"]],
        SSECustomerKeyMD5: [, output.headers["x-amz-server-side-encryption-customer-key-md5"]],
        SSEKMSKeyId: [, output.headers["x-amz-server-side-encryption-aws-kms-key-id"]],
        BucketKeyEnabled: [
          () => void 0 !== output.headers["x-amz-server-side-encryption-bucket-key-enabled"],
          () => (0, smithy_client_1.parseBoolean)(output.headers["x-amz-server-side-encryption-bucket-key-enabled"])
        ],
        StorageClass: [, output.headers["x-amz-storage-class"]],
        RequestCharged: [, output.headers["x-amz-request-charged"]],
        ReplicationStatus: [, output.headers["x-amz-replication-status"]],
        PartsCount: [
          () => void 0 !== output.headers["x-amz-mp-parts-count"],
          () => (0, smithy_client_1.strictParseInt32)(output.headers["x-amz-mp-parts-count"])
        ],
        TagCount: [
          () => void 0 !== output.headers["x-amz-tagging-count"],
          () => (0, smithy_client_1.strictParseInt32)(output.headers["x-amz-tagging-count"])
        ],
        ObjectLockMode: [, output.headers["x-amz-object-lock-mode"]],
        ObjectLockRetainUntilDate: [
          () => void 0 !== output.headers["x-amz-object-lock-retain-until-date"],
          () => (0, smithy_client_1.expectNonNull)((0, smithy_client_1.parseRfc3339DateTimeWithOffset)(output.headers["x-amz-object-lock-retain-until-date"]))
        ],
        ObjectLockLegalHoldStatus: [, output.headers["x-amz-object-lock-legal-hold"]],
        Metadata: [
          ,
          Object.keys(output.headers).filter((header) => header.startsWith("x-amz-meta-")).reduce((acc, header) => {
            acc[header.substring(11)] = output.headers[header];
            return acc;
          }, {})
        ]
      });
      const data = output.body;
      context.sdkStreamMixin(data);
      contents.Body = data;
      return contents;
    };
    exports.deserializeAws_restXmlGetObjectCommand = deserializeAws_restXmlGetObjectCommand;
    var deserializeAws_restXmlGetObjectCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      switch (errorCode) {
        case "InvalidObjectState":
        case "com.amazonaws.s3#InvalidObjectState":
          throw await deserializeAws_restXmlInvalidObjectStateResponse(parsedOutput, context);
        case "NoSuchKey":
        case "com.amazonaws.s3#NoSuchKey":
          throw await deserializeAws_restXmlNoSuchKeyResponse(parsedOutput, context);
        default:
          const parsedBody = parsedOutput.body;
          (0, smithy_client_1.throwDefaultError)({
            output,
            parsedBody,
            exceptionCtor: S3ServiceException_1.S3ServiceException,
            errorCode
          });
      }
    };
    var deserializeAws_restXmlGetObjectAclCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return deserializeAws_restXmlGetObjectAclCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output),
        RequestCharged: [, output.headers["x-amz-request-charged"]]
      });
      const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
      if (data.AccessControlList === "") {
        contents.Grants = [];
      } else if (data["AccessControlList"] !== void 0 && data["AccessControlList"]["Grant"] !== void 0) {
        contents.Grants = deserializeAws_restXmlGrants((0, smithy_client_1.getArrayIfSingleItem)(data["AccessControlList"]["Grant"]), context);
      }
      if (data["Owner"] !== void 0) {
        contents.Owner = deserializeAws_restXmlOwner(data["Owner"], context);
      }
      return contents;
    };
    exports.deserializeAws_restXmlGetObjectAclCommand = deserializeAws_restXmlGetObjectAclCommand;
    var deserializeAws_restXmlGetObjectAclCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      switch (errorCode) {
        case "NoSuchKey":
        case "com.amazonaws.s3#NoSuchKey":
          throw await deserializeAws_restXmlNoSuchKeyResponse(parsedOutput, context);
        default:
          const parsedBody = parsedOutput.body;
          (0, smithy_client_1.throwDefaultError)({
            output,
            parsedBody,
            exceptionCtor: S3ServiceException_1.S3ServiceException,
            errorCode
          });
      }
    };
    var deserializeAws_restXmlGetObjectAttributesCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return deserializeAws_restXmlGetObjectAttributesCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output),
        DeleteMarker: [
          () => void 0 !== output.headers["x-amz-delete-marker"],
          () => (0, smithy_client_1.parseBoolean)(output.headers["x-amz-delete-marker"])
        ],
        LastModified: [
          () => void 0 !== output.headers["last-modified"],
          () => (0, smithy_client_1.expectNonNull)((0, smithy_client_1.parseRfc7231DateTime)(output.headers["last-modified"]))
        ],
        VersionId: [, output.headers["x-amz-version-id"]],
        RequestCharged: [, output.headers["x-amz-request-charged"]]
      });
      const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
      if (data["Checksum"] !== void 0) {
        contents.Checksum = deserializeAws_restXmlChecksum(data["Checksum"], context);
      }
      if (data["ETag"] !== void 0) {
        contents.ETag = (0, smithy_client_1.expectString)(data["ETag"]);
      }
      if (data["ObjectParts"] !== void 0) {
        contents.ObjectParts = deserializeAws_restXmlGetObjectAttributesParts(data["ObjectParts"], context);
      }
      if (data["ObjectSize"] !== void 0) {
        contents.ObjectSize = (0, smithy_client_1.strictParseLong)(data["ObjectSize"]);
      }
      if (data["StorageClass"] !== void 0) {
        contents.StorageClass = (0, smithy_client_1.expectString)(data["StorageClass"]);
      }
      return contents;
    };
    exports.deserializeAws_restXmlGetObjectAttributesCommand = deserializeAws_restXmlGetObjectAttributesCommand;
    var deserializeAws_restXmlGetObjectAttributesCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      switch (errorCode) {
        case "NoSuchKey":
        case "com.amazonaws.s3#NoSuchKey":
          throw await deserializeAws_restXmlNoSuchKeyResponse(parsedOutput, context);
        default:
          const parsedBody = parsedOutput.body;
          (0, smithy_client_1.throwDefaultError)({
            output,
            parsedBody,
            exceptionCtor: S3ServiceException_1.S3ServiceException,
            errorCode
          });
      }
    };
    var deserializeAws_restXmlGetObjectLegalHoldCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return deserializeAws_restXmlGetObjectLegalHoldCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output)
      });
      const data = (0, smithy_client_1.expectObject)(await parseBody(output.body, context));
      contents.LegalHold = deserializeAws_restXmlObjectLockLegalHold(data, context);
      return contents;
    };
    exports.deserializeAws_restXmlGetObjectLegalHoldCommand = deserializeAws_restXmlGetObjectLegalHoldCommand;
    var deserializeAws_restXmlGetObjectLegalHoldCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      const parsedBody = parsedOutput.body;
      (0, smithy_client_1.throwDefaultError)({
        output,
        parsedBody,
        exceptionCtor: S3ServiceException_1.S3ServiceException,
        errorCode
      });
    };
    var deserializeAws_restXmlGetObjectLockConfigurationCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return deserializeAws_restXmlGetObjectLockConfigurationCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output)
      });
      const data = (0, smithy_client_1.expectObject)(await parseBody(output.body, context));
      contents.ObjectLockConfiguration = deserializeAws_restXmlObjectLockConfiguration(data, context);
      return contents;
    };
    exports.deserializeAws_restXmlGetObjectLockConfigurationCommand = deserializeAws_restXmlGetObjectLockConfigurationCommand;
    var deserializeAws_restXmlGetObjectLockConfigurationCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      const parsedBody = parsedOutput.body;
      (0, smithy_client_1.throwDefaultError)({
        output,
        parsedBody,
        exceptionCtor: S3ServiceException_1.S3ServiceException,
        errorCode
      });
    };
    var deserializeAws_restXmlGetObjectRetentionCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return deserializeAws_restXmlGetObjectRetentionCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output)
      });
      const data = (0, smithy_client_1.expectObject)(await parseBody(output.body, context));
      contents.Retention = deserializeAws_restXmlObjectLockRetention(data, context);
      return contents;
    };
    exports.deserializeAws_restXmlGetObjectRetentionCommand = deserializeAws_restXmlGetObjectRetentionCommand;
    var deserializeAws_restXmlGetObjectRetentionCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      const parsedBody = parsedOutput.body;
      (0, smithy_client_1.throwDefaultError)({
        output,
        parsedBody,
        exceptionCtor: S3ServiceException_1.S3ServiceException,
        errorCode
      });
    };
    var deserializeAws_restXmlGetObjectTaggingCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return deserializeAws_restXmlGetObjectTaggingCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output),
        VersionId: [, output.headers["x-amz-version-id"]]
      });
      const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
      if (data.TagSet === "") {
        contents.TagSet = [];
      } else if (data["TagSet"] !== void 0 && data["TagSet"]["Tag"] !== void 0) {
        contents.TagSet = deserializeAws_restXmlTagSet((0, smithy_client_1.getArrayIfSingleItem)(data["TagSet"]["Tag"]), context);
      }
      return contents;
    };
    exports.deserializeAws_restXmlGetObjectTaggingCommand = deserializeAws_restXmlGetObjectTaggingCommand;
    var deserializeAws_restXmlGetObjectTaggingCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      const parsedBody = parsedOutput.body;
      (0, smithy_client_1.throwDefaultError)({
        output,
        parsedBody,
        exceptionCtor: S3ServiceException_1.S3ServiceException,
        errorCode
      });
    };
    var deserializeAws_restXmlGetObjectTorrentCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return deserializeAws_restXmlGetObjectTorrentCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output),
        RequestCharged: [, output.headers["x-amz-request-charged"]]
      });
      const data = output.body;
      context.sdkStreamMixin(data);
      contents.Body = data;
      return contents;
    };
    exports.deserializeAws_restXmlGetObjectTorrentCommand = deserializeAws_restXmlGetObjectTorrentCommand;
    var deserializeAws_restXmlGetObjectTorrentCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      const parsedBody = parsedOutput.body;
      (0, smithy_client_1.throwDefaultError)({
        output,
        parsedBody,
        exceptionCtor: S3ServiceException_1.S3ServiceException,
        errorCode
      });
    };
    var deserializeAws_restXmlGetPublicAccessBlockCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return deserializeAws_restXmlGetPublicAccessBlockCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output)
      });
      const data = (0, smithy_client_1.expectObject)(await parseBody(output.body, context));
      contents.PublicAccessBlockConfiguration = deserializeAws_restXmlPublicAccessBlockConfiguration(data, context);
      return contents;
    };
    exports.deserializeAws_restXmlGetPublicAccessBlockCommand = deserializeAws_restXmlGetPublicAccessBlockCommand;
    var deserializeAws_restXmlGetPublicAccessBlockCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      const parsedBody = parsedOutput.body;
      (0, smithy_client_1.throwDefaultError)({
        output,
        parsedBody,
        exceptionCtor: S3ServiceException_1.S3ServiceException,
        errorCode
      });
    };
    var deserializeAws_restXmlHeadBucketCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return deserializeAws_restXmlHeadBucketCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output)
      });
      await collectBody(output.body, context);
      return contents;
    };
    exports.deserializeAws_restXmlHeadBucketCommand = deserializeAws_restXmlHeadBucketCommand;
    var deserializeAws_restXmlHeadBucketCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      switch (errorCode) {
        case "NotFound":
        case "com.amazonaws.s3#NotFound":
          throw await deserializeAws_restXmlNotFoundResponse(parsedOutput, context);
        default:
          const parsedBody = parsedOutput.body;
          (0, smithy_client_1.throwDefaultError)({
            output,
            parsedBody,
            exceptionCtor: S3ServiceException_1.S3ServiceException,
            errorCode
          });
      }
    };
    var deserializeAws_restXmlHeadObjectCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return deserializeAws_restXmlHeadObjectCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output),
        DeleteMarker: [
          () => void 0 !== output.headers["x-amz-delete-marker"],
          () => (0, smithy_client_1.parseBoolean)(output.headers["x-amz-delete-marker"])
        ],
        AcceptRanges: [, output.headers["accept-ranges"]],
        Expiration: [, output.headers["x-amz-expiration"]],
        Restore: [, output.headers["x-amz-restore"]],
        ArchiveStatus: [, output.headers["x-amz-archive-status"]],
        LastModified: [
          () => void 0 !== output.headers["last-modified"],
          () => (0, smithy_client_1.expectNonNull)((0, smithy_client_1.parseRfc7231DateTime)(output.headers["last-modified"]))
        ],
        ContentLength: [
          () => void 0 !== output.headers["content-length"],
          () => (0, smithy_client_1.strictParseLong)(output.headers["content-length"])
        ],
        ChecksumCRC32: [, output.headers["x-amz-checksum-crc32"]],
        ChecksumCRC32C: [, output.headers["x-amz-checksum-crc32c"]],
        ChecksumSHA1: [, output.headers["x-amz-checksum-sha1"]],
        ChecksumSHA256: [, output.headers["x-amz-checksum-sha256"]],
        ETag: [, output.headers["etag"]],
        MissingMeta: [
          () => void 0 !== output.headers["x-amz-missing-meta"],
          () => (0, smithy_client_1.strictParseInt32)(output.headers["x-amz-missing-meta"])
        ],
        VersionId: [, output.headers["x-amz-version-id"]],
        CacheControl: [, output.headers["cache-control"]],
        ContentDisposition: [, output.headers["content-disposition"]],
        ContentEncoding: [, output.headers["content-encoding"]],
        ContentLanguage: [, output.headers["content-language"]],
        ContentType: [, output.headers["content-type"]],
        Expires: [
          () => void 0 !== output.headers["expires"],
          () => (0, smithy_client_1.expectNonNull)((0, smithy_client_1.parseRfc7231DateTime)(output.headers["expires"]))
        ],
        WebsiteRedirectLocation: [, output.headers["x-amz-website-redirect-location"]],
        ServerSideEncryption: [, output.headers["x-amz-server-side-encryption"]],
        SSECustomerAlgorithm: [, output.headers["x-amz-server-side-encryption-customer-algorithm"]],
        SSECustomerKeyMD5: [, output.headers["x-amz-server-side-encryption-customer-key-md5"]],
        SSEKMSKeyId: [, output.headers["x-amz-server-side-encryption-aws-kms-key-id"]],
        BucketKeyEnabled: [
          () => void 0 !== output.headers["x-amz-server-side-encryption-bucket-key-enabled"],
          () => (0, smithy_client_1.parseBoolean)(output.headers["x-amz-server-side-encryption-bucket-key-enabled"])
        ],
        StorageClass: [, output.headers["x-amz-storage-class"]],
        RequestCharged: [, output.headers["x-amz-request-charged"]],
        ReplicationStatus: [, output.headers["x-amz-replication-status"]],
        PartsCount: [
          () => void 0 !== output.headers["x-amz-mp-parts-count"],
          () => (0, smithy_client_1.strictParseInt32)(output.headers["x-amz-mp-parts-count"])
        ],
        ObjectLockMode: [, output.headers["x-amz-object-lock-mode"]],
        ObjectLockRetainUntilDate: [
          () => void 0 !== output.headers["x-amz-object-lock-retain-until-date"],
          () => (0, smithy_client_1.expectNonNull)((0, smithy_client_1.parseRfc3339DateTimeWithOffset)(output.headers["x-amz-object-lock-retain-until-date"]))
        ],
        ObjectLockLegalHoldStatus: [, output.headers["x-amz-object-lock-legal-hold"]],
        Metadata: [
          ,
          Object.keys(output.headers).filter((header) => header.startsWith("x-amz-meta-")).reduce((acc, header) => {
            acc[header.substring(11)] = output.headers[header];
            return acc;
          }, {})
        ]
      });
      await collectBody(output.body, context);
      return contents;
    };
    exports.deserializeAws_restXmlHeadObjectCommand = deserializeAws_restXmlHeadObjectCommand;
    var deserializeAws_restXmlHeadObjectCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      switch (errorCode) {
        case "NotFound":
        case "com.amazonaws.s3#NotFound":
          throw await deserializeAws_restXmlNotFoundResponse(parsedOutput, context);
        default:
          const parsedBody = parsedOutput.body;
          (0, smithy_client_1.throwDefaultError)({
            output,
            parsedBody,
            exceptionCtor: S3ServiceException_1.S3ServiceException,
            errorCode
          });
      }
    };
    var deserializeAws_restXmlListBucketAnalyticsConfigurationsCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return deserializeAws_restXmlListBucketAnalyticsConfigurationsCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output)
      });
      const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
      if (data.AnalyticsConfiguration === "") {
        contents.AnalyticsConfigurationList = [];
      } else if (data["AnalyticsConfiguration"] !== void 0) {
        contents.AnalyticsConfigurationList = deserializeAws_restXmlAnalyticsConfigurationList((0, smithy_client_1.getArrayIfSingleItem)(data["AnalyticsConfiguration"]), context);
      }
      if (data["ContinuationToken"] !== void 0) {
        contents.ContinuationToken = (0, smithy_client_1.expectString)(data["ContinuationToken"]);
      }
      if (data["IsTruncated"] !== void 0) {
        contents.IsTruncated = (0, smithy_client_1.parseBoolean)(data["IsTruncated"]);
      }
      if (data["NextContinuationToken"] !== void 0) {
        contents.NextContinuationToken = (0, smithy_client_1.expectString)(data["NextContinuationToken"]);
      }
      return contents;
    };
    exports.deserializeAws_restXmlListBucketAnalyticsConfigurationsCommand = deserializeAws_restXmlListBucketAnalyticsConfigurationsCommand;
    var deserializeAws_restXmlListBucketAnalyticsConfigurationsCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      const parsedBody = parsedOutput.body;
      (0, smithy_client_1.throwDefaultError)({
        output,
        parsedBody,
        exceptionCtor: S3ServiceException_1.S3ServiceException,
        errorCode
      });
    };
    var deserializeAws_restXmlListBucketIntelligentTieringConfigurationsCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return deserializeAws_restXmlListBucketIntelligentTieringConfigurationsCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output)
      });
      const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
      if (data["ContinuationToken"] !== void 0) {
        contents.ContinuationToken = (0, smithy_client_1.expectString)(data["ContinuationToken"]);
      }
      if (data.IntelligentTieringConfiguration === "") {
        contents.IntelligentTieringConfigurationList = [];
      } else if (data["IntelligentTieringConfiguration"] !== void 0) {
        contents.IntelligentTieringConfigurationList = deserializeAws_restXmlIntelligentTieringConfigurationList((0, smithy_client_1.getArrayIfSingleItem)(data["IntelligentTieringConfiguration"]), context);
      }
      if (data["IsTruncated"] !== void 0) {
        contents.IsTruncated = (0, smithy_client_1.parseBoolean)(data["IsTruncated"]);
      }
      if (data["NextContinuationToken"] !== void 0) {
        contents.NextContinuationToken = (0, smithy_client_1.expectString)(data["NextContinuationToken"]);
      }
      return contents;
    };
    exports.deserializeAws_restXmlListBucketIntelligentTieringConfigurationsCommand = deserializeAws_restXmlListBucketIntelligentTieringConfigurationsCommand;
    var deserializeAws_restXmlListBucketIntelligentTieringConfigurationsCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      const parsedBody = parsedOutput.body;
      (0, smithy_client_1.throwDefaultError)({
        output,
        parsedBody,
        exceptionCtor: S3ServiceException_1.S3ServiceException,
        errorCode
      });
    };
    var deserializeAws_restXmlListBucketInventoryConfigurationsCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return deserializeAws_restXmlListBucketInventoryConfigurationsCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output)
      });
      const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
      if (data["ContinuationToken"] !== void 0) {
        contents.ContinuationToken = (0, smithy_client_1.expectString)(data["ContinuationToken"]);
      }
      if (data.InventoryConfiguration === "") {
        contents.InventoryConfigurationList = [];
      } else if (data["InventoryConfiguration"] !== void 0) {
        contents.InventoryConfigurationList = deserializeAws_restXmlInventoryConfigurationList((0, smithy_client_1.getArrayIfSingleItem)(data["InventoryConfiguration"]), context);
      }
      if (data["IsTruncated"] !== void 0) {
        contents.IsTruncated = (0, smithy_client_1.parseBoolean)(data["IsTruncated"]);
      }
      if (data["NextContinuationToken"] !== void 0) {
        contents.NextContinuationToken = (0, smithy_client_1.expectString)(data["NextContinuationToken"]);
      }
      return contents;
    };
    exports.deserializeAws_restXmlListBucketInventoryConfigurationsCommand = deserializeAws_restXmlListBucketInventoryConfigurationsCommand;
    var deserializeAws_restXmlListBucketInventoryConfigurationsCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      const parsedBody = parsedOutput.body;
      (0, smithy_client_1.throwDefaultError)({
        output,
        parsedBody,
        exceptionCtor: S3ServiceException_1.S3ServiceException,
        errorCode
      });
    };
    var deserializeAws_restXmlListBucketMetricsConfigurationsCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return deserializeAws_restXmlListBucketMetricsConfigurationsCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output)
      });
      const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
      if (data["ContinuationToken"] !== void 0) {
        contents.ContinuationToken = (0, smithy_client_1.expectString)(data["ContinuationToken"]);
      }
      if (data["IsTruncated"] !== void 0) {
        contents.IsTruncated = (0, smithy_client_1.parseBoolean)(data["IsTruncated"]);
      }
      if (data.MetricsConfiguration === "") {
        contents.MetricsConfigurationList = [];
      } else if (data["MetricsConfiguration"] !== void 0) {
        contents.MetricsConfigurationList = deserializeAws_restXmlMetricsConfigurationList((0, smithy_client_1.getArrayIfSingleItem)(data["MetricsConfiguration"]), context);
      }
      if (data["NextContinuationToken"] !== void 0) {
        contents.NextContinuationToken = (0, smithy_client_1.expectString)(data["NextContinuationToken"]);
      }
      return contents;
    };
    exports.deserializeAws_restXmlListBucketMetricsConfigurationsCommand = deserializeAws_restXmlListBucketMetricsConfigurationsCommand;
    var deserializeAws_restXmlListBucketMetricsConfigurationsCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      const parsedBody = parsedOutput.body;
      (0, smithy_client_1.throwDefaultError)({
        output,
        parsedBody,
        exceptionCtor: S3ServiceException_1.S3ServiceException,
        errorCode
      });
    };
    var deserializeAws_restXmlListBucketsCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return deserializeAws_restXmlListBucketsCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output)
      });
      const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
      if (data.Buckets === "") {
        contents.Buckets = [];
      } else if (data["Buckets"] !== void 0 && data["Buckets"]["Bucket"] !== void 0) {
        contents.Buckets = deserializeAws_restXmlBuckets((0, smithy_client_1.getArrayIfSingleItem)(data["Buckets"]["Bucket"]), context);
      }
      if (data["Owner"] !== void 0) {
        contents.Owner = deserializeAws_restXmlOwner(data["Owner"], context);
      }
      return contents;
    };
    exports.deserializeAws_restXmlListBucketsCommand = deserializeAws_restXmlListBucketsCommand;
    var deserializeAws_restXmlListBucketsCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      const parsedBody = parsedOutput.body;
      (0, smithy_client_1.throwDefaultError)({
        output,
        parsedBody,
        exceptionCtor: S3ServiceException_1.S3ServiceException,
        errorCode
      });
    };
    var deserializeAws_restXmlListMultipartUploadsCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return deserializeAws_restXmlListMultipartUploadsCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output)
      });
      const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
      if (data["Bucket"] !== void 0) {
        contents.Bucket = (0, smithy_client_1.expectString)(data["Bucket"]);
      }
      if (data.CommonPrefixes === "") {
        contents.CommonPrefixes = [];
      } else if (data["CommonPrefixes"] !== void 0) {
        contents.CommonPrefixes = deserializeAws_restXmlCommonPrefixList((0, smithy_client_1.getArrayIfSingleItem)(data["CommonPrefixes"]), context);
      }
      if (data["Delimiter"] !== void 0) {
        contents.Delimiter = (0, smithy_client_1.expectString)(data["Delimiter"]);
      }
      if (data["EncodingType"] !== void 0) {
        contents.EncodingType = (0, smithy_client_1.expectString)(data["EncodingType"]);
      }
      if (data["IsTruncated"] !== void 0) {
        contents.IsTruncated = (0, smithy_client_1.parseBoolean)(data["IsTruncated"]);
      }
      if (data["KeyMarker"] !== void 0) {
        contents.KeyMarker = (0, smithy_client_1.expectString)(data["KeyMarker"]);
      }
      if (data["MaxUploads"] !== void 0) {
        contents.MaxUploads = (0, smithy_client_1.strictParseInt32)(data["MaxUploads"]);
      }
      if (data["NextKeyMarker"] !== void 0) {
        contents.NextKeyMarker = (0, smithy_client_1.expectString)(data["NextKeyMarker"]);
      }
      if (data["NextUploadIdMarker"] !== void 0) {
        contents.NextUploadIdMarker = (0, smithy_client_1.expectString)(data["NextUploadIdMarker"]);
      }
      if (data["Prefix"] !== void 0) {
        contents.Prefix = (0, smithy_client_1.expectString)(data["Prefix"]);
      }
      if (data["UploadIdMarker"] !== void 0) {
        contents.UploadIdMarker = (0, smithy_client_1.expectString)(data["UploadIdMarker"]);
      }
      if (data.Upload === "") {
        contents.Uploads = [];
      } else if (data["Upload"] !== void 0) {
        contents.Uploads = deserializeAws_restXmlMultipartUploadList((0, smithy_client_1.getArrayIfSingleItem)(data["Upload"]), context);
      }
      return contents;
    };
    exports.deserializeAws_restXmlListMultipartUploadsCommand = deserializeAws_restXmlListMultipartUploadsCommand;
    var deserializeAws_restXmlListMultipartUploadsCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      const parsedBody = parsedOutput.body;
      (0, smithy_client_1.throwDefaultError)({
        output,
        parsedBody,
        exceptionCtor: S3ServiceException_1.S3ServiceException,
        errorCode
      });
    };
    var deserializeAws_restXmlListObjectsCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return deserializeAws_restXmlListObjectsCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output)
      });
      const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
      if (data.CommonPrefixes === "") {
        contents.CommonPrefixes = [];
      } else if (data["CommonPrefixes"] !== void 0) {
        contents.CommonPrefixes = deserializeAws_restXmlCommonPrefixList((0, smithy_client_1.getArrayIfSingleItem)(data["CommonPrefixes"]), context);
      }
      if (data.Contents === "") {
        contents.Contents = [];
      } else if (data["Contents"] !== void 0) {
        contents.Contents = deserializeAws_restXmlObjectList((0, smithy_client_1.getArrayIfSingleItem)(data["Contents"]), context);
      }
      if (data["Delimiter"] !== void 0) {
        contents.Delimiter = (0, smithy_client_1.expectString)(data["Delimiter"]);
      }
      if (data["EncodingType"] !== void 0) {
        contents.EncodingType = (0, smithy_client_1.expectString)(data["EncodingType"]);
      }
      if (data["IsTruncated"] !== void 0) {
        contents.IsTruncated = (0, smithy_client_1.parseBoolean)(data["IsTruncated"]);
      }
      if (data["Marker"] !== void 0) {
        contents.Marker = (0, smithy_client_1.expectString)(data["Marker"]);
      }
      if (data["MaxKeys"] !== void 0) {
        contents.MaxKeys = (0, smithy_client_1.strictParseInt32)(data["MaxKeys"]);
      }
      if (data["Name"] !== void 0) {
        contents.Name = (0, smithy_client_1.expectString)(data["Name"]);
      }
      if (data["NextMarker"] !== void 0) {
        contents.NextMarker = (0, smithy_client_1.expectString)(data["NextMarker"]);
      }
      if (data["Prefix"] !== void 0) {
        contents.Prefix = (0, smithy_client_1.expectString)(data["Prefix"]);
      }
      return contents;
    };
    exports.deserializeAws_restXmlListObjectsCommand = deserializeAws_restXmlListObjectsCommand;
    var deserializeAws_restXmlListObjectsCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      switch (errorCode) {
        case "NoSuchBucket":
        case "com.amazonaws.s3#NoSuchBucket":
          throw await deserializeAws_restXmlNoSuchBucketResponse(parsedOutput, context);
        default:
          const parsedBody = parsedOutput.body;
          (0, smithy_client_1.throwDefaultError)({
            output,
            parsedBody,
            exceptionCtor: S3ServiceException_1.S3ServiceException,
            errorCode
          });
      }
    };
    var deserializeAws_restXmlListObjectsV2Command = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return deserializeAws_restXmlListObjectsV2CommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output)
      });
      const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
      if (data.CommonPrefixes === "") {
        contents.CommonPrefixes = [];
      } else if (data["CommonPrefixes"] !== void 0) {
        contents.CommonPrefixes = deserializeAws_restXmlCommonPrefixList((0, smithy_client_1.getArrayIfSingleItem)(data["CommonPrefixes"]), context);
      }
      if (data.Contents === "") {
        contents.Contents = [];
      } else if (data["Contents"] !== void 0) {
        contents.Contents = deserializeAws_restXmlObjectList((0, smithy_client_1.getArrayIfSingleItem)(data["Contents"]), context);
      }
      if (data["ContinuationToken"] !== void 0) {
        contents.ContinuationToken = (0, smithy_client_1.expectString)(data["ContinuationToken"]);
      }
      if (data["Delimiter"] !== void 0) {
        contents.Delimiter = (0, smithy_client_1.expectString)(data["Delimiter"]);
      }
      if (data["EncodingType"] !== void 0) {
        contents.EncodingType = (0, smithy_client_1.expectString)(data["EncodingType"]);
      }
      if (data["IsTruncated"] !== void 0) {
        contents.IsTruncated = (0, smithy_client_1.parseBoolean)(data["IsTruncated"]);
      }
      if (data["KeyCount"] !== void 0) {
        contents.KeyCount = (0, smithy_client_1.strictParseInt32)(data["KeyCount"]);
      }
      if (data["MaxKeys"] !== void 0) {
        contents.MaxKeys = (0, smithy_client_1.strictParseInt32)(data["MaxKeys"]);
      }
      if (data["Name"] !== void 0) {
        contents.Name = (0, smithy_client_1.expectString)(data["Name"]);
      }
      if (data["NextContinuationToken"] !== void 0) {
        contents.NextContinuationToken = (0, smithy_client_1.expectString)(data["NextContinuationToken"]);
      }
      if (data["Prefix"] !== void 0) {
        contents.Prefix = (0, smithy_client_1.expectString)(data["Prefix"]);
      }
      if (data["StartAfter"] !== void 0) {
        contents.StartAfter = (0, smithy_client_1.expectString)(data["StartAfter"]);
      }
      return contents;
    };
    exports.deserializeAws_restXmlListObjectsV2Command = deserializeAws_restXmlListObjectsV2Command;
    var deserializeAws_restXmlListObjectsV2CommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      switch (errorCode) {
        case "NoSuchBucket":
        case "com.amazonaws.s3#NoSuchBucket":
          throw await deserializeAws_restXmlNoSuchBucketResponse(parsedOutput, context);
        default:
          const parsedBody = parsedOutput.body;
          (0, smithy_client_1.throwDefaultError)({
            output,
            parsedBody,
            exceptionCtor: S3ServiceException_1.S3ServiceException,
            errorCode
          });
      }
    };
    var deserializeAws_restXmlListObjectVersionsCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return deserializeAws_restXmlListObjectVersionsCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output)
      });
      const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
      if (data.CommonPrefixes === "") {
        contents.CommonPrefixes = [];
      } else if (data["CommonPrefixes"] !== void 0) {
        contents.CommonPrefixes = deserializeAws_restXmlCommonPrefixList((0, smithy_client_1.getArrayIfSingleItem)(data["CommonPrefixes"]), context);
      }
      if (data.DeleteMarker === "") {
        contents.DeleteMarkers = [];
      } else if (data["DeleteMarker"] !== void 0) {
        contents.DeleteMarkers = deserializeAws_restXmlDeleteMarkers((0, smithy_client_1.getArrayIfSingleItem)(data["DeleteMarker"]), context);
      }
      if (data["Delimiter"] !== void 0) {
        contents.Delimiter = (0, smithy_client_1.expectString)(data["Delimiter"]);
      }
      if (data["EncodingType"] !== void 0) {
        contents.EncodingType = (0, smithy_client_1.expectString)(data["EncodingType"]);
      }
      if (data["IsTruncated"] !== void 0) {
        contents.IsTruncated = (0, smithy_client_1.parseBoolean)(data["IsTruncated"]);
      }
      if (data["KeyMarker"] !== void 0) {
        contents.KeyMarker = (0, smithy_client_1.expectString)(data["KeyMarker"]);
      }
      if (data["MaxKeys"] !== void 0) {
        contents.MaxKeys = (0, smithy_client_1.strictParseInt32)(data["MaxKeys"]);
      }
      if (data["Name"] !== void 0) {
        contents.Name = (0, smithy_client_1.expectString)(data["Name"]);
      }
      if (data["NextKeyMarker"] !== void 0) {
        contents.NextKeyMarker = (0, smithy_client_1.expectString)(data["NextKeyMarker"]);
      }
      if (data["NextVersionIdMarker"] !== void 0) {
        contents.NextVersionIdMarker = (0, smithy_client_1.expectString)(data["NextVersionIdMarker"]);
      }
      if (data["Prefix"] !== void 0) {
        contents.Prefix = (0, smithy_client_1.expectString)(data["Prefix"]);
      }
      if (data["VersionIdMarker"] !== void 0) {
        contents.VersionIdMarker = (0, smithy_client_1.expectString)(data["VersionIdMarker"]);
      }
      if (data.Version === "") {
        contents.Versions = [];
      } else if (data["Version"] !== void 0) {
        contents.Versions = deserializeAws_restXmlObjectVersionList((0, smithy_client_1.getArrayIfSingleItem)(data["Version"]), context);
      }
      return contents;
    };
    exports.deserializeAws_restXmlListObjectVersionsCommand = deserializeAws_restXmlListObjectVersionsCommand;
    var deserializeAws_restXmlListObjectVersionsCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      const parsedBody = parsedOutput.body;
      (0, smithy_client_1.throwDefaultError)({
        output,
        parsedBody,
        exceptionCtor: S3ServiceException_1.S3ServiceException,
        errorCode
      });
    };
    var deserializeAws_restXmlListPartsCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return deserializeAws_restXmlListPartsCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output),
        AbortDate: [
          () => void 0 !== output.headers["x-amz-abort-date"],
          () => (0, smithy_client_1.expectNonNull)((0, smithy_client_1.parseRfc7231DateTime)(output.headers["x-amz-abort-date"]))
        ],
        AbortRuleId: [, output.headers["x-amz-abort-rule-id"]],
        RequestCharged: [, output.headers["x-amz-request-charged"]]
      });
      const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
      if (data["Bucket"] !== void 0) {
        contents.Bucket = (0, smithy_client_1.expectString)(data["Bucket"]);
      }
      if (data["ChecksumAlgorithm"] !== void 0) {
        contents.ChecksumAlgorithm = (0, smithy_client_1.expectString)(data["ChecksumAlgorithm"]);
      }
      if (data["Initiator"] !== void 0) {
        contents.Initiator = deserializeAws_restXmlInitiator(data["Initiator"], context);
      }
      if (data["IsTruncated"] !== void 0) {
        contents.IsTruncated = (0, smithy_client_1.parseBoolean)(data["IsTruncated"]);
      }
      if (data["Key"] !== void 0) {
        contents.Key = (0, smithy_client_1.expectString)(data["Key"]);
      }
      if (data["MaxParts"] !== void 0) {
        contents.MaxParts = (0, smithy_client_1.strictParseInt32)(data["MaxParts"]);
      }
      if (data["NextPartNumberMarker"] !== void 0) {
        contents.NextPartNumberMarker = (0, smithy_client_1.expectString)(data["NextPartNumberMarker"]);
      }
      if (data["Owner"] !== void 0) {
        contents.Owner = deserializeAws_restXmlOwner(data["Owner"], context);
      }
      if (data["PartNumberMarker"] !== void 0) {
        contents.PartNumberMarker = (0, smithy_client_1.expectString)(data["PartNumberMarker"]);
      }
      if (data.Part === "") {
        contents.Parts = [];
      } else if (data["Part"] !== void 0) {
        contents.Parts = deserializeAws_restXmlParts((0, smithy_client_1.getArrayIfSingleItem)(data["Part"]), context);
      }
      if (data["StorageClass"] !== void 0) {
        contents.StorageClass = (0, smithy_client_1.expectString)(data["StorageClass"]);
      }
      if (data["UploadId"] !== void 0) {
        contents.UploadId = (0, smithy_client_1.expectString)(data["UploadId"]);
      }
      return contents;
    };
    exports.deserializeAws_restXmlListPartsCommand = deserializeAws_restXmlListPartsCommand;
    var deserializeAws_restXmlListPartsCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      const parsedBody = parsedOutput.body;
      (0, smithy_client_1.throwDefaultError)({
        output,
        parsedBody,
        exceptionCtor: S3ServiceException_1.S3ServiceException,
        errorCode
      });
    };
    var deserializeAws_restXmlPutBucketAccelerateConfigurationCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return deserializeAws_restXmlPutBucketAccelerateConfigurationCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output)
      });
      await collectBody(output.body, context);
      return contents;
    };
    exports.deserializeAws_restXmlPutBucketAccelerateConfigurationCommand = deserializeAws_restXmlPutBucketAccelerateConfigurationCommand;
    var deserializeAws_restXmlPutBucketAccelerateConfigurationCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      const parsedBody = parsedOutput.body;
      (0, smithy_client_1.throwDefaultError)({
        output,
        parsedBody,
        exceptionCtor: S3ServiceException_1.S3ServiceException,
        errorCode
      });
    };
    var deserializeAws_restXmlPutBucketAclCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return deserializeAws_restXmlPutBucketAclCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output)
      });
      await collectBody(output.body, context);
      return contents;
    };
    exports.deserializeAws_restXmlPutBucketAclCommand = deserializeAws_restXmlPutBucketAclCommand;
    var deserializeAws_restXmlPutBucketAclCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      const parsedBody = parsedOutput.body;
      (0, smithy_client_1.throwDefaultError)({
        output,
        parsedBody,
        exceptionCtor: S3ServiceException_1.S3ServiceException,
        errorCode
      });
    };
    var deserializeAws_restXmlPutBucketAnalyticsConfigurationCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return deserializeAws_restXmlPutBucketAnalyticsConfigurationCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output)
      });
      await collectBody(output.body, context);
      return contents;
    };
    exports.deserializeAws_restXmlPutBucketAnalyticsConfigurationCommand = deserializeAws_restXmlPutBucketAnalyticsConfigurationCommand;
    var deserializeAws_restXmlPutBucketAnalyticsConfigurationCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      const parsedBody = parsedOutput.body;
      (0, smithy_client_1.throwDefaultError)({
        output,
        parsedBody,
        exceptionCtor: S3ServiceException_1.S3ServiceException,
        errorCode
      });
    };
    var deserializeAws_restXmlPutBucketCorsCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return deserializeAws_restXmlPutBucketCorsCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output)
      });
      await collectBody(output.body, context);
      return contents;
    };
    exports.deserializeAws_restXmlPutBucketCorsCommand = deserializeAws_restXmlPutBucketCorsCommand;
    var deserializeAws_restXmlPutBucketCorsCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      const parsedBody = parsedOutput.body;
      (0, smithy_client_1.throwDefaultError)({
        output,
        parsedBody,
        exceptionCtor: S3ServiceException_1.S3ServiceException,
        errorCode
      });
    };
    var deserializeAws_restXmlPutBucketEncryptionCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return deserializeAws_restXmlPutBucketEncryptionCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output)
      });
      await collectBody(output.body, context);
      return contents;
    };
    exports.deserializeAws_restXmlPutBucketEncryptionCommand = deserializeAws_restXmlPutBucketEncryptionCommand;
    var deserializeAws_restXmlPutBucketEncryptionCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      const parsedBody = parsedOutput.body;
      (0, smithy_client_1.throwDefaultError)({
        output,
        parsedBody,
        exceptionCtor: S3ServiceException_1.S3ServiceException,
        errorCode
      });
    };
    var deserializeAws_restXmlPutBucketIntelligentTieringConfigurationCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return deserializeAws_restXmlPutBucketIntelligentTieringConfigurationCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output)
      });
      await collectBody(output.body, context);
      return contents;
    };
    exports.deserializeAws_restXmlPutBucketIntelligentTieringConfigurationCommand = deserializeAws_restXmlPutBucketIntelligentTieringConfigurationCommand;
    var deserializeAws_restXmlPutBucketIntelligentTieringConfigurationCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      const parsedBody = parsedOutput.body;
      (0, smithy_client_1.throwDefaultError)({
        output,
        parsedBody,
        exceptionCtor: S3ServiceException_1.S3ServiceException,
        errorCode
      });
    };
    var deserializeAws_restXmlPutBucketInventoryConfigurationCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return deserializeAws_restXmlPutBucketInventoryConfigurationCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output)
      });
      await collectBody(output.body, context);
      return contents;
    };
    exports.deserializeAws_restXmlPutBucketInventoryConfigurationCommand = deserializeAws_restXmlPutBucketInventoryConfigurationCommand;
    var deserializeAws_restXmlPutBucketInventoryConfigurationCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      const parsedBody = parsedOutput.body;
      (0, smithy_client_1.throwDefaultError)({
        output,
        parsedBody,
        exceptionCtor: S3ServiceException_1.S3ServiceException,
        errorCode
      });
    };
    var deserializeAws_restXmlPutBucketLifecycleConfigurationCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return deserializeAws_restXmlPutBucketLifecycleConfigurationCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output)
      });
      await collectBody(output.body, context);
      return contents;
    };
    exports.deserializeAws_restXmlPutBucketLifecycleConfigurationCommand = deserializeAws_restXmlPutBucketLifecycleConfigurationCommand;
    var deserializeAws_restXmlPutBucketLifecycleConfigurationCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      const parsedBody = parsedOutput.body;
      (0, smithy_client_1.throwDefaultError)({
        output,
        parsedBody,
        exceptionCtor: S3ServiceException_1.S3ServiceException,
        errorCode
      });
    };
    var deserializeAws_restXmlPutBucketLoggingCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return deserializeAws_restXmlPutBucketLoggingCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output)
      });
      await collectBody(output.body, context);
      return contents;
    };
    exports.deserializeAws_restXmlPutBucketLoggingCommand = deserializeAws_restXmlPutBucketLoggingCommand;
    var deserializeAws_restXmlPutBucketLoggingCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      const parsedBody = parsedOutput.body;
      (0, smithy_client_1.throwDefaultError)({
        output,
        parsedBody,
        exceptionCtor: S3ServiceException_1.S3ServiceException,
        errorCode
      });
    };
    var deserializeAws_restXmlPutBucketMetricsConfigurationCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return deserializeAws_restXmlPutBucketMetricsConfigurationCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output)
      });
      await collectBody(output.body, context);
      return contents;
    };
    exports.deserializeAws_restXmlPutBucketMetricsConfigurationCommand = deserializeAws_restXmlPutBucketMetricsConfigurationCommand;
    var deserializeAws_restXmlPutBucketMetricsConfigurationCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      const parsedBody = parsedOutput.body;
      (0, smithy_client_1.throwDefaultError)({
        output,
        parsedBody,
        exceptionCtor: S3ServiceException_1.S3ServiceException,
        errorCode
      });
    };
    var deserializeAws_restXmlPutBucketNotificationConfigurationCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return deserializeAws_restXmlPutBucketNotificationConfigurationCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output)
      });
      await collectBody(output.body, context);
      return contents;
    };
    exports.deserializeAws_restXmlPutBucketNotificationConfigurationCommand = deserializeAws_restXmlPutBucketNotificationConfigurationCommand;
    var deserializeAws_restXmlPutBucketNotificationConfigurationCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      const parsedBody = parsedOutput.body;
      (0, smithy_client_1.throwDefaultError)({
        output,
        parsedBody,
        exceptionCtor: S3ServiceException_1.S3ServiceException,
        errorCode
      });
    };
    var deserializeAws_restXmlPutBucketOwnershipControlsCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return deserializeAws_restXmlPutBucketOwnershipControlsCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output)
      });
      await collectBody(output.body, context);
      return contents;
    };
    exports.deserializeAws_restXmlPutBucketOwnershipControlsCommand = deserializeAws_restXmlPutBucketOwnershipControlsCommand;
    var deserializeAws_restXmlPutBucketOwnershipControlsCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      const parsedBody = parsedOutput.body;
      (0, smithy_client_1.throwDefaultError)({
        output,
        parsedBody,
        exceptionCtor: S3ServiceException_1.S3ServiceException,
        errorCode
      });
    };
    var deserializeAws_restXmlPutBucketPolicyCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return deserializeAws_restXmlPutBucketPolicyCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output)
      });
      await collectBody(output.body, context);
      return contents;
    };
    exports.deserializeAws_restXmlPutBucketPolicyCommand = deserializeAws_restXmlPutBucketPolicyCommand;
    var deserializeAws_restXmlPutBucketPolicyCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      const parsedBody = parsedOutput.body;
      (0, smithy_client_1.throwDefaultError)({
        output,
        parsedBody,
        exceptionCtor: S3ServiceException_1.S3ServiceException,
        errorCode
      });
    };
    var deserializeAws_restXmlPutBucketReplicationCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return deserializeAws_restXmlPutBucketReplicationCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output)
      });
      await collectBody(output.body, context);
      return contents;
    };
    exports.deserializeAws_restXmlPutBucketReplicationCommand = deserializeAws_restXmlPutBucketReplicationCommand;
    var deserializeAws_restXmlPutBucketReplicationCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      const parsedBody = parsedOutput.body;
      (0, smithy_client_1.throwDefaultError)({
        output,
        parsedBody,
        exceptionCtor: S3ServiceException_1.S3ServiceException,
        errorCode
      });
    };
    var deserializeAws_restXmlPutBucketRequestPaymentCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return deserializeAws_restXmlPutBucketRequestPaymentCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output)
      });
      await collectBody(output.body, context);
      return contents;
    };
    exports.deserializeAws_restXmlPutBucketRequestPaymentCommand = deserializeAws_restXmlPutBucketRequestPaymentCommand;
    var deserializeAws_restXmlPutBucketRequestPaymentCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      const parsedBody = parsedOutput.body;
      (0, smithy_client_1.throwDefaultError)({
        output,
        parsedBody,
        exceptionCtor: S3ServiceException_1.S3ServiceException,
        errorCode
      });
    };
    var deserializeAws_restXmlPutBucketTaggingCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return deserializeAws_restXmlPutBucketTaggingCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output)
      });
      await collectBody(output.body, context);
      return contents;
    };
    exports.deserializeAws_restXmlPutBucketTaggingCommand = deserializeAws_restXmlPutBucketTaggingCommand;
    var deserializeAws_restXmlPutBucketTaggingCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      const parsedBody = parsedOutput.body;
      (0, smithy_client_1.throwDefaultError)({
        output,
        parsedBody,
        exceptionCtor: S3ServiceException_1.S3ServiceException,
        errorCode
      });
    };
    var deserializeAws_restXmlPutBucketVersioningCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return deserializeAws_restXmlPutBucketVersioningCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output)
      });
      await collectBody(output.body, context);
      return contents;
    };
    exports.deserializeAws_restXmlPutBucketVersioningCommand = deserializeAws_restXmlPutBucketVersioningCommand;
    var deserializeAws_restXmlPutBucketVersioningCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      const parsedBody = parsedOutput.body;
      (0, smithy_client_1.throwDefaultError)({
        output,
        parsedBody,
        exceptionCtor: S3ServiceException_1.S3ServiceException,
        errorCode
      });
    };
    var deserializeAws_restXmlPutBucketWebsiteCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return deserializeAws_restXmlPutBucketWebsiteCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output)
      });
      await collectBody(output.body, context);
      return contents;
    };
    exports.deserializeAws_restXmlPutBucketWebsiteCommand = deserializeAws_restXmlPutBucketWebsiteCommand;
    var deserializeAws_restXmlPutBucketWebsiteCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      const parsedBody = parsedOutput.body;
      (0, smithy_client_1.throwDefaultError)({
        output,
        parsedBody,
        exceptionCtor: S3ServiceException_1.S3ServiceException,
        errorCode
      });
    };
    var deserializeAws_restXmlPutObjectCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return deserializeAws_restXmlPutObjectCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output),
        Expiration: [, output.headers["x-amz-expiration"]],
        ETag: [, output.headers["etag"]],
        ChecksumCRC32: [, output.headers["x-amz-checksum-crc32"]],
        ChecksumCRC32C: [, output.headers["x-amz-checksum-crc32c"]],
        ChecksumSHA1: [, output.headers["x-amz-checksum-sha1"]],
        ChecksumSHA256: [, output.headers["x-amz-checksum-sha256"]],
        ServerSideEncryption: [, output.headers["x-amz-server-side-encryption"]],
        VersionId: [, output.headers["x-amz-version-id"]],
        SSECustomerAlgorithm: [, output.headers["x-amz-server-side-encryption-customer-algorithm"]],
        SSECustomerKeyMD5: [, output.headers["x-amz-server-side-encryption-customer-key-md5"]],
        SSEKMSKeyId: [, output.headers["x-amz-server-side-encryption-aws-kms-key-id"]],
        SSEKMSEncryptionContext: [, output.headers["x-amz-server-side-encryption-context"]],
        BucketKeyEnabled: [
          () => void 0 !== output.headers["x-amz-server-side-encryption-bucket-key-enabled"],
          () => (0, smithy_client_1.parseBoolean)(output.headers["x-amz-server-side-encryption-bucket-key-enabled"])
        ],
        RequestCharged: [, output.headers["x-amz-request-charged"]]
      });
      await collectBody(output.body, context);
      return contents;
    };
    exports.deserializeAws_restXmlPutObjectCommand = deserializeAws_restXmlPutObjectCommand;
    var deserializeAws_restXmlPutObjectCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      const parsedBody = parsedOutput.body;
      (0, smithy_client_1.throwDefaultError)({
        output,
        parsedBody,
        exceptionCtor: S3ServiceException_1.S3ServiceException,
        errorCode
      });
    };
    var deserializeAws_restXmlPutObjectAclCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return deserializeAws_restXmlPutObjectAclCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output),
        RequestCharged: [, output.headers["x-amz-request-charged"]]
      });
      await collectBody(output.body, context);
      return contents;
    };
    exports.deserializeAws_restXmlPutObjectAclCommand = deserializeAws_restXmlPutObjectAclCommand;
    var deserializeAws_restXmlPutObjectAclCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      switch (errorCode) {
        case "NoSuchKey":
        case "com.amazonaws.s3#NoSuchKey":
          throw await deserializeAws_restXmlNoSuchKeyResponse(parsedOutput, context);
        default:
          const parsedBody = parsedOutput.body;
          (0, smithy_client_1.throwDefaultError)({
            output,
            parsedBody,
            exceptionCtor: S3ServiceException_1.S3ServiceException,
            errorCode
          });
      }
    };
    var deserializeAws_restXmlPutObjectLegalHoldCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return deserializeAws_restXmlPutObjectLegalHoldCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output),
        RequestCharged: [, output.headers["x-amz-request-charged"]]
      });
      await collectBody(output.body, context);
      return contents;
    };
    exports.deserializeAws_restXmlPutObjectLegalHoldCommand = deserializeAws_restXmlPutObjectLegalHoldCommand;
    var deserializeAws_restXmlPutObjectLegalHoldCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      const parsedBody = parsedOutput.body;
      (0, smithy_client_1.throwDefaultError)({
        output,
        parsedBody,
        exceptionCtor: S3ServiceException_1.S3ServiceException,
        errorCode
      });
    };
    var deserializeAws_restXmlPutObjectLockConfigurationCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return deserializeAws_restXmlPutObjectLockConfigurationCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output),
        RequestCharged: [, output.headers["x-amz-request-charged"]]
      });
      await collectBody(output.body, context);
      return contents;
    };
    exports.deserializeAws_restXmlPutObjectLockConfigurationCommand = deserializeAws_restXmlPutObjectLockConfigurationCommand;
    var deserializeAws_restXmlPutObjectLockConfigurationCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      const parsedBody = parsedOutput.body;
      (0, smithy_client_1.throwDefaultError)({
        output,
        parsedBody,
        exceptionCtor: S3ServiceException_1.S3ServiceException,
        errorCode
      });
    };
    var deserializeAws_restXmlPutObjectRetentionCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return deserializeAws_restXmlPutObjectRetentionCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output),
        RequestCharged: [, output.headers["x-amz-request-charged"]]
      });
      await collectBody(output.body, context);
      return contents;
    };
    exports.deserializeAws_restXmlPutObjectRetentionCommand = deserializeAws_restXmlPutObjectRetentionCommand;
    var deserializeAws_restXmlPutObjectRetentionCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      const parsedBody = parsedOutput.body;
      (0, smithy_client_1.throwDefaultError)({
        output,
        parsedBody,
        exceptionCtor: S3ServiceException_1.S3ServiceException,
        errorCode
      });
    };
    var deserializeAws_restXmlPutObjectTaggingCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return deserializeAws_restXmlPutObjectTaggingCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output),
        VersionId: [, output.headers["x-amz-version-id"]]
      });
      await collectBody(output.body, context);
      return contents;
    };
    exports.deserializeAws_restXmlPutObjectTaggingCommand = deserializeAws_restXmlPutObjectTaggingCommand;
    var deserializeAws_restXmlPutObjectTaggingCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      const parsedBody = parsedOutput.body;
      (0, smithy_client_1.throwDefaultError)({
        output,
        parsedBody,
        exceptionCtor: S3ServiceException_1.S3ServiceException,
        errorCode
      });
    };
    var deserializeAws_restXmlPutPublicAccessBlockCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return deserializeAws_restXmlPutPublicAccessBlockCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output)
      });
      await collectBody(output.body, context);
      return contents;
    };
    exports.deserializeAws_restXmlPutPublicAccessBlockCommand = deserializeAws_restXmlPutPublicAccessBlockCommand;
    var deserializeAws_restXmlPutPublicAccessBlockCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      const parsedBody = parsedOutput.body;
      (0, smithy_client_1.throwDefaultError)({
        output,
        parsedBody,
        exceptionCtor: S3ServiceException_1.S3ServiceException,
        errorCode
      });
    };
    var deserializeAws_restXmlRestoreObjectCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return deserializeAws_restXmlRestoreObjectCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output),
        RequestCharged: [, output.headers["x-amz-request-charged"]],
        RestoreOutputPath: [, output.headers["x-amz-restore-output-path"]]
      });
      await collectBody(output.body, context);
      return contents;
    };
    exports.deserializeAws_restXmlRestoreObjectCommand = deserializeAws_restXmlRestoreObjectCommand;
    var deserializeAws_restXmlRestoreObjectCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      switch (errorCode) {
        case "ObjectAlreadyInActiveTierError":
        case "com.amazonaws.s3#ObjectAlreadyInActiveTierError":
          throw await deserializeAws_restXmlObjectAlreadyInActiveTierErrorResponse(parsedOutput, context);
        default:
          const parsedBody = parsedOutput.body;
          (0, smithy_client_1.throwDefaultError)({
            output,
            parsedBody,
            exceptionCtor: S3ServiceException_1.S3ServiceException,
            errorCode
          });
      }
    };
    var deserializeAws_restXmlSelectObjectContentCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return deserializeAws_restXmlSelectObjectContentCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output)
      });
      const data = output.body;
      contents.Payload = deserializeAws_restXmlSelectObjectContentEventStream(data, context);
      return contents;
    };
    exports.deserializeAws_restXmlSelectObjectContentCommand = deserializeAws_restXmlSelectObjectContentCommand;
    var deserializeAws_restXmlSelectObjectContentCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      const parsedBody = parsedOutput.body;
      (0, smithy_client_1.throwDefaultError)({
        output,
        parsedBody,
        exceptionCtor: S3ServiceException_1.S3ServiceException,
        errorCode
      });
    };
    var deserializeAws_restXmlUploadPartCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return deserializeAws_restXmlUploadPartCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output),
        ServerSideEncryption: [, output.headers["x-amz-server-side-encryption"]],
        ETag: [, output.headers["etag"]],
        ChecksumCRC32: [, output.headers["x-amz-checksum-crc32"]],
        ChecksumCRC32C: [, output.headers["x-amz-checksum-crc32c"]],
        ChecksumSHA1: [, output.headers["x-amz-checksum-sha1"]],
        ChecksumSHA256: [, output.headers["x-amz-checksum-sha256"]],
        SSECustomerAlgorithm: [, output.headers["x-amz-server-side-encryption-customer-algorithm"]],
        SSECustomerKeyMD5: [, output.headers["x-amz-server-side-encryption-customer-key-md5"]],
        SSEKMSKeyId: [, output.headers["x-amz-server-side-encryption-aws-kms-key-id"]],
        BucketKeyEnabled: [
          () => void 0 !== output.headers["x-amz-server-side-encryption-bucket-key-enabled"],
          () => (0, smithy_client_1.parseBoolean)(output.headers["x-amz-server-side-encryption-bucket-key-enabled"])
        ],
        RequestCharged: [, output.headers["x-amz-request-charged"]]
      });
      await collectBody(output.body, context);
      return contents;
    };
    exports.deserializeAws_restXmlUploadPartCommand = deserializeAws_restXmlUploadPartCommand;
    var deserializeAws_restXmlUploadPartCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      const parsedBody = parsedOutput.body;
      (0, smithy_client_1.throwDefaultError)({
        output,
        parsedBody,
        exceptionCtor: S3ServiceException_1.S3ServiceException,
        errorCode
      });
    };
    var deserializeAws_restXmlUploadPartCopyCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return deserializeAws_restXmlUploadPartCopyCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output),
        CopySourceVersionId: [, output.headers["x-amz-copy-source-version-id"]],
        ServerSideEncryption: [, output.headers["x-amz-server-side-encryption"]],
        SSECustomerAlgorithm: [, output.headers["x-amz-server-side-encryption-customer-algorithm"]],
        SSECustomerKeyMD5: [, output.headers["x-amz-server-side-encryption-customer-key-md5"]],
        SSEKMSKeyId: [, output.headers["x-amz-server-side-encryption-aws-kms-key-id"]],
        BucketKeyEnabled: [
          () => void 0 !== output.headers["x-amz-server-side-encryption-bucket-key-enabled"],
          () => (0, smithy_client_1.parseBoolean)(output.headers["x-amz-server-side-encryption-bucket-key-enabled"])
        ],
        RequestCharged: [, output.headers["x-amz-request-charged"]]
      });
      const data = (0, smithy_client_1.expectObject)(await parseBody(output.body, context));
      contents.CopyPartResult = deserializeAws_restXmlCopyPartResult(data, context);
      return contents;
    };
    exports.deserializeAws_restXmlUploadPartCopyCommand = deserializeAws_restXmlUploadPartCopyCommand;
    var deserializeAws_restXmlUploadPartCopyCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      const parsedBody = parsedOutput.body;
      (0, smithy_client_1.throwDefaultError)({
        output,
        parsedBody,
        exceptionCtor: S3ServiceException_1.S3ServiceException,
        errorCode
      });
    };
    var deserializeAws_restXmlWriteGetObjectResponseCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return deserializeAws_restXmlWriteGetObjectResponseCommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata(output)
      });
      await collectBody(output.body, context);
      return contents;
    };
    exports.deserializeAws_restXmlWriteGetObjectResponseCommand = deserializeAws_restXmlWriteGetObjectResponseCommand;
    var deserializeAws_restXmlWriteGetObjectResponseCommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context)
      };
      const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
      const parsedBody = parsedOutput.body;
      (0, smithy_client_1.throwDefaultError)({
        output,
        parsedBody,
        exceptionCtor: S3ServiceException_1.S3ServiceException,
        errorCode
      });
    };
    var map = smithy_client_1.map;
    var deserializeAws_restXmlBucketAlreadyExistsResponse = async (parsedOutput, context) => {
      const contents = map({});
      const data = parsedOutput.body;
      const exception = new models_0_1.BucketAlreadyExists({
        $metadata: deserializeMetadata(parsedOutput),
        ...contents
      });
      return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
    };
    var deserializeAws_restXmlBucketAlreadyOwnedByYouResponse = async (parsedOutput, context) => {
      const contents = map({});
      const data = parsedOutput.body;
      const exception = new models_0_1.BucketAlreadyOwnedByYou({
        $metadata: deserializeMetadata(parsedOutput),
        ...contents
      });
      return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
    };
    var deserializeAws_restXmlInvalidObjectStateResponse = async (parsedOutput, context) => {
      const contents = map({});
      const data = parsedOutput.body;
      if (data["AccessTier"] !== void 0) {
        contents.AccessTier = (0, smithy_client_1.expectString)(data["AccessTier"]);
      }
      if (data["StorageClass"] !== void 0) {
        contents.StorageClass = (0, smithy_client_1.expectString)(data["StorageClass"]);
      }
      const exception = new models_0_1.InvalidObjectState({
        $metadata: deserializeMetadata(parsedOutput),
        ...contents
      });
      return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
    };
    var deserializeAws_restXmlNoSuchBucketResponse = async (parsedOutput, context) => {
      const contents = map({});
      const data = parsedOutput.body;
      const exception = new models_0_1.NoSuchBucket({
        $metadata: deserializeMetadata(parsedOutput),
        ...contents
      });
      return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
    };
    var deserializeAws_restXmlNoSuchKeyResponse = async (parsedOutput, context) => {
      const contents = map({});
      const data = parsedOutput.body;
      const exception = new models_0_1.NoSuchKey({
        $metadata: deserializeMetadata(parsedOutput),
        ...contents
      });
      return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
    };
    var deserializeAws_restXmlNoSuchUploadResponse = async (parsedOutput, context) => {
      const contents = map({});
      const data = parsedOutput.body;
      const exception = new models_0_1.NoSuchUpload({
        $metadata: deserializeMetadata(parsedOutput),
        ...contents
      });
      return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
    };
    var deserializeAws_restXmlNotFoundResponse = async (parsedOutput, context) => {
      const contents = map({});
      const data = parsedOutput.body;
      const exception = new models_0_1.NotFound({
        $metadata: deserializeMetadata(parsedOutput),
        ...contents
      });
      return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
    };
    var deserializeAws_restXmlObjectAlreadyInActiveTierErrorResponse = async (parsedOutput, context) => {
      const contents = map({});
      const data = parsedOutput.body;
      const exception = new models_1_1.ObjectAlreadyInActiveTierError({
        $metadata: deserializeMetadata(parsedOutput),
        ...contents
      });
      return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
    };
    var deserializeAws_restXmlObjectNotInActiveTierErrorResponse = async (parsedOutput, context) => {
      const contents = map({});
      const data = parsedOutput.body;
      const exception = new models_0_1.ObjectNotInActiveTierError({
        $metadata: deserializeMetadata(parsedOutput),
        ...contents
      });
      return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
    };
    var deserializeAws_restXmlSelectObjectContentEventStream = (output, context) => {
      return context.eventStreamMarshaller.deserialize(output, async (event) => {
        if (event["Records"] != null) {
          return {
            Records: await deserializeAws_restXmlRecordsEvent_event(event["Records"], context)
          };
        }
        if (event["Stats"] != null) {
          return {
            Stats: await deserializeAws_restXmlStatsEvent_event(event["Stats"], context)
          };
        }
        if (event["Progress"] != null) {
          return {
            Progress: await deserializeAws_restXmlProgressEvent_event(event["Progress"], context)
          };
        }
        if (event["Cont"] != null) {
          return {
            Cont: await deserializeAws_restXmlContinuationEvent_event(event["Cont"], context)
          };
        }
        if (event["End"] != null) {
          return {
            End: await deserializeAws_restXmlEndEvent_event(event["End"], context)
          };
        }
        return { $unknown: output };
      });
    };
    var deserializeAws_restXmlContinuationEvent_event = async (output, context) => {
      const contents = {};
      const data = await parseBody(output.body, context);
      Object.assign(contents, deserializeAws_restXmlContinuationEvent(data, context));
      return contents;
    };
    var deserializeAws_restXmlEndEvent_event = async (output, context) => {
      const contents = {};
      const data = await parseBody(output.body, context);
      Object.assign(contents, deserializeAws_restXmlEndEvent(data, context));
      return contents;
    };
    var deserializeAws_restXmlProgressEvent_event = async (output, context) => {
      const contents = {};
      const data = await parseBody(output.body, context);
      contents.Details = deserializeAws_restXmlProgress(data, context);
      return contents;
    };
    var deserializeAws_restXmlRecordsEvent_event = async (output, context) => {
      const contents = {};
      contents.Payload = output.body;
      return contents;
    };
    var deserializeAws_restXmlStatsEvent_event = async (output, context) => {
      const contents = {};
      const data = await parseBody(output.body, context);
      contents.Details = deserializeAws_restXmlStats(data, context);
      return contents;
    };
    var serializeAws_restXmlAbortIncompleteMultipartUpload = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("AbortIncompleteMultipartUpload");
      if (input.DaysAfterInitiation != null) {
        const node = xml_builder_1.XmlNode.of("DaysAfterInitiation", String(input.DaysAfterInitiation)).withName("DaysAfterInitiation");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlAccelerateConfiguration = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("AccelerateConfiguration");
      if (input.Status != null) {
        const node = xml_builder_1.XmlNode.of("BucketAccelerateStatus", input.Status).withName("Status");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlAccessControlPolicy = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("AccessControlPolicy");
      if (input.Grants != null) {
        const nodes = serializeAws_restXmlGrants(input.Grants, context);
        const containerNode = new xml_builder_1.XmlNode("AccessControlList");
        nodes.map((node) => {
          containerNode.addChildNode(node);
        });
        bodyNode.addChildNode(containerNode);
      }
      if (input.Owner != null) {
        const node = serializeAws_restXmlOwner(input.Owner, context).withName("Owner");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlAccessControlTranslation = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("AccessControlTranslation");
      if (input.Owner != null) {
        const node = xml_builder_1.XmlNode.of("OwnerOverride", input.Owner).withName("Owner");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlAllowedHeaders = (input, context) => {
      return input.filter((e) => e != null).map((entry) => {
        const node = xml_builder_1.XmlNode.of("AllowedHeader", entry);
        return node.withName("member");
      });
    };
    var serializeAws_restXmlAllowedMethods = (input, context) => {
      return input.filter((e) => e != null).map((entry) => {
        const node = xml_builder_1.XmlNode.of("AllowedMethod", entry);
        return node.withName("member");
      });
    };
    var serializeAws_restXmlAllowedOrigins = (input, context) => {
      return input.filter((e) => e != null).map((entry) => {
        const node = xml_builder_1.XmlNode.of("AllowedOrigin", entry);
        return node.withName("member");
      });
    };
    var serializeAws_restXmlAnalyticsAndOperator = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("AnalyticsAndOperator");
      if (input.Prefix != null) {
        const node = xml_builder_1.XmlNode.of("Prefix", input.Prefix).withName("Prefix");
        bodyNode.addChildNode(node);
      }
      if (input.Tags != null) {
        const nodes = serializeAws_restXmlTagSet(input.Tags, context);
        nodes.map((node) => {
          node = node.withName("Tag");
          bodyNode.addChildNode(node);
        });
      }
      return bodyNode;
    };
    var serializeAws_restXmlAnalyticsConfiguration = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("AnalyticsConfiguration");
      if (input.Id != null) {
        const node = xml_builder_1.XmlNode.of("AnalyticsId", input.Id).withName("Id");
        bodyNode.addChildNode(node);
      }
      if (input.Filter != null) {
        const node = serializeAws_restXmlAnalyticsFilter(input.Filter, context).withName("Filter");
        bodyNode.addChildNode(node);
      }
      if (input.StorageClassAnalysis != null) {
        const node = serializeAws_restXmlStorageClassAnalysis(input.StorageClassAnalysis, context).withName("StorageClassAnalysis");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlAnalyticsExportDestination = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("AnalyticsExportDestination");
      if (input.S3BucketDestination != null) {
        const node = serializeAws_restXmlAnalyticsS3BucketDestination(input.S3BucketDestination, context).withName("S3BucketDestination");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlAnalyticsFilter = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("AnalyticsFilter");
      models_0_1.AnalyticsFilter.visit(input, {
        Prefix: (value) => {
          const node = xml_builder_1.XmlNode.of("Prefix", value).withName("Prefix");
          bodyNode.addChildNode(node);
        },
        Tag: (value) => {
          const node = serializeAws_restXmlTag(value, context).withName("Tag");
          bodyNode.addChildNode(node);
        },
        And: (value) => {
          const node = serializeAws_restXmlAnalyticsAndOperator(value, context).withName("And");
          bodyNode.addChildNode(node);
        },
        _: (name, value) => {
          if (!(value instanceof xml_builder_1.XmlNode || value instanceof xml_builder_1.XmlText)) {
            throw new Error("Unable to serialize unknown union members in XML.");
          }
          bodyNode.addChildNode(new xml_builder_1.XmlNode(name).addChildNode(value));
        }
      });
      return bodyNode;
    };
    var serializeAws_restXmlAnalyticsS3BucketDestination = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("AnalyticsS3BucketDestination");
      if (input.Format != null) {
        const node = xml_builder_1.XmlNode.of("AnalyticsS3ExportFileFormat", input.Format).withName("Format");
        bodyNode.addChildNode(node);
      }
      if (input.BucketAccountId != null) {
        const node = xml_builder_1.XmlNode.of("AccountId", input.BucketAccountId).withName("BucketAccountId");
        bodyNode.addChildNode(node);
      }
      if (input.Bucket != null) {
        const node = xml_builder_1.XmlNode.of("BucketName", input.Bucket).withName("Bucket");
        bodyNode.addChildNode(node);
      }
      if (input.Prefix != null) {
        const node = xml_builder_1.XmlNode.of("Prefix", input.Prefix).withName("Prefix");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlBucketLifecycleConfiguration = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("BucketLifecycleConfiguration");
      if (input.Rules != null) {
        const nodes = serializeAws_restXmlLifecycleRules(input.Rules, context);
        nodes.map((node) => {
          node = node.withName("Rule");
          bodyNode.addChildNode(node);
        });
      }
      return bodyNode;
    };
    var serializeAws_restXmlBucketLoggingStatus = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("BucketLoggingStatus");
      if (input.LoggingEnabled != null) {
        const node = serializeAws_restXmlLoggingEnabled(input.LoggingEnabled, context).withName("LoggingEnabled");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlCompletedMultipartUpload = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("CompletedMultipartUpload");
      if (input.Parts != null) {
        const nodes = serializeAws_restXmlCompletedPartList(input.Parts, context);
        nodes.map((node) => {
          node = node.withName("Part");
          bodyNode.addChildNode(node);
        });
      }
      return bodyNode;
    };
    var serializeAws_restXmlCompletedPart = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("CompletedPart");
      if (input.ETag != null) {
        const node = xml_builder_1.XmlNode.of("ETag", input.ETag).withName("ETag");
        bodyNode.addChildNode(node);
      }
      if (input.ChecksumCRC32 != null) {
        const node = xml_builder_1.XmlNode.of("ChecksumCRC32", input.ChecksumCRC32).withName("ChecksumCRC32");
        bodyNode.addChildNode(node);
      }
      if (input.ChecksumCRC32C != null) {
        const node = xml_builder_1.XmlNode.of("ChecksumCRC32C", input.ChecksumCRC32C).withName("ChecksumCRC32C");
        bodyNode.addChildNode(node);
      }
      if (input.ChecksumSHA1 != null) {
        const node = xml_builder_1.XmlNode.of("ChecksumSHA1", input.ChecksumSHA1).withName("ChecksumSHA1");
        bodyNode.addChildNode(node);
      }
      if (input.ChecksumSHA256 != null) {
        const node = xml_builder_1.XmlNode.of("ChecksumSHA256", input.ChecksumSHA256).withName("ChecksumSHA256");
        bodyNode.addChildNode(node);
      }
      if (input.PartNumber != null) {
        const node = xml_builder_1.XmlNode.of("PartNumber", String(input.PartNumber)).withName("PartNumber");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlCompletedPartList = (input, context) => {
      return input.filter((e) => e != null).map((entry) => {
        const node = serializeAws_restXmlCompletedPart(entry, context);
        return node.withName("member");
      });
    };
    var serializeAws_restXmlCondition = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("Condition");
      if (input.HttpErrorCodeReturnedEquals != null) {
        const node = xml_builder_1.XmlNode.of("HttpErrorCodeReturnedEquals", input.HttpErrorCodeReturnedEquals).withName("HttpErrorCodeReturnedEquals");
        bodyNode.addChildNode(node);
      }
      if (input.KeyPrefixEquals != null) {
        const node = xml_builder_1.XmlNode.of("KeyPrefixEquals", input.KeyPrefixEquals).withName("KeyPrefixEquals");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlCORSConfiguration = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("CORSConfiguration");
      if (input.CORSRules != null) {
        const nodes = serializeAws_restXmlCORSRules(input.CORSRules, context);
        nodes.map((node) => {
          node = node.withName("CORSRule");
          bodyNode.addChildNode(node);
        });
      }
      return bodyNode;
    };
    var serializeAws_restXmlCORSRule = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("CORSRule");
      if (input.ID != null) {
        const node = xml_builder_1.XmlNode.of("ID", input.ID).withName("ID");
        bodyNode.addChildNode(node);
      }
      if (input.AllowedHeaders != null) {
        const nodes = serializeAws_restXmlAllowedHeaders(input.AllowedHeaders, context);
        nodes.map((node) => {
          node = node.withName("AllowedHeader");
          bodyNode.addChildNode(node);
        });
      }
      if (input.AllowedMethods != null) {
        const nodes = serializeAws_restXmlAllowedMethods(input.AllowedMethods, context);
        nodes.map((node) => {
          node = node.withName("AllowedMethod");
          bodyNode.addChildNode(node);
        });
      }
      if (input.AllowedOrigins != null) {
        const nodes = serializeAws_restXmlAllowedOrigins(input.AllowedOrigins, context);
        nodes.map((node) => {
          node = node.withName("AllowedOrigin");
          bodyNode.addChildNode(node);
        });
      }
      if (input.ExposeHeaders != null) {
        const nodes = serializeAws_restXmlExposeHeaders(input.ExposeHeaders, context);
        nodes.map((node) => {
          node = node.withName("ExposeHeader");
          bodyNode.addChildNode(node);
        });
      }
      if (input.MaxAgeSeconds != null) {
        const node = xml_builder_1.XmlNode.of("MaxAgeSeconds", String(input.MaxAgeSeconds)).withName("MaxAgeSeconds");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlCORSRules = (input, context) => {
      return input.filter((e) => e != null).map((entry) => {
        const node = serializeAws_restXmlCORSRule(entry, context);
        return node.withName("member");
      });
    };
    var serializeAws_restXmlCreateBucketConfiguration = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("CreateBucketConfiguration");
      if (input.LocationConstraint != null) {
        const node = xml_builder_1.XmlNode.of("BucketLocationConstraint", input.LocationConstraint).withName("LocationConstraint");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlCSVInput = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("CSVInput");
      if (input.FileHeaderInfo != null) {
        const node = xml_builder_1.XmlNode.of("FileHeaderInfo", input.FileHeaderInfo).withName("FileHeaderInfo");
        bodyNode.addChildNode(node);
      }
      if (input.Comments != null) {
        const node = xml_builder_1.XmlNode.of("Comments", input.Comments).withName("Comments");
        bodyNode.addChildNode(node);
      }
      if (input.QuoteEscapeCharacter != null) {
        const node = xml_builder_1.XmlNode.of("QuoteEscapeCharacter", input.QuoteEscapeCharacter).withName("QuoteEscapeCharacter");
        bodyNode.addChildNode(node);
      }
      if (input.RecordDelimiter != null) {
        const node = xml_builder_1.XmlNode.of("RecordDelimiter", input.RecordDelimiter).withName("RecordDelimiter");
        bodyNode.addChildNode(node);
      }
      if (input.FieldDelimiter != null) {
        const node = xml_builder_1.XmlNode.of("FieldDelimiter", input.FieldDelimiter).withName("FieldDelimiter");
        bodyNode.addChildNode(node);
      }
      if (input.QuoteCharacter != null) {
        const node = xml_builder_1.XmlNode.of("QuoteCharacter", input.QuoteCharacter).withName("QuoteCharacter");
        bodyNode.addChildNode(node);
      }
      if (input.AllowQuotedRecordDelimiter != null) {
        const node = xml_builder_1.XmlNode.of("AllowQuotedRecordDelimiter", String(input.AllowQuotedRecordDelimiter)).withName("AllowQuotedRecordDelimiter");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlCSVOutput = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("CSVOutput");
      if (input.QuoteFields != null) {
        const node = xml_builder_1.XmlNode.of("QuoteFields", input.QuoteFields).withName("QuoteFields");
        bodyNode.addChildNode(node);
      }
      if (input.QuoteEscapeCharacter != null) {
        const node = xml_builder_1.XmlNode.of("QuoteEscapeCharacter", input.QuoteEscapeCharacter).withName("QuoteEscapeCharacter");
        bodyNode.addChildNode(node);
      }
      if (input.RecordDelimiter != null) {
        const node = xml_builder_1.XmlNode.of("RecordDelimiter", input.RecordDelimiter).withName("RecordDelimiter");
        bodyNode.addChildNode(node);
      }
      if (input.FieldDelimiter != null) {
        const node = xml_builder_1.XmlNode.of("FieldDelimiter", input.FieldDelimiter).withName("FieldDelimiter");
        bodyNode.addChildNode(node);
      }
      if (input.QuoteCharacter != null) {
        const node = xml_builder_1.XmlNode.of("QuoteCharacter", input.QuoteCharacter).withName("QuoteCharacter");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlDefaultRetention = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("DefaultRetention");
      if (input.Mode != null) {
        const node = xml_builder_1.XmlNode.of("ObjectLockRetentionMode", input.Mode).withName("Mode");
        bodyNode.addChildNode(node);
      }
      if (input.Days != null) {
        const node = xml_builder_1.XmlNode.of("Days", String(input.Days)).withName("Days");
        bodyNode.addChildNode(node);
      }
      if (input.Years != null) {
        const node = xml_builder_1.XmlNode.of("Years", String(input.Years)).withName("Years");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlDelete = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("Delete");
      if (input.Objects != null) {
        const nodes = serializeAws_restXmlObjectIdentifierList(input.Objects, context);
        nodes.map((node) => {
          node = node.withName("Object");
          bodyNode.addChildNode(node);
        });
      }
      if (input.Quiet != null) {
        const node = xml_builder_1.XmlNode.of("Quiet", String(input.Quiet)).withName("Quiet");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlDeleteMarkerReplication = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("DeleteMarkerReplication");
      if (input.Status != null) {
        const node = xml_builder_1.XmlNode.of("DeleteMarkerReplicationStatus", input.Status).withName("Status");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlDestination = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("Destination");
      if (input.Bucket != null) {
        const node = xml_builder_1.XmlNode.of("BucketName", input.Bucket).withName("Bucket");
        bodyNode.addChildNode(node);
      }
      if (input.Account != null) {
        const node = xml_builder_1.XmlNode.of("AccountId", input.Account).withName("Account");
        bodyNode.addChildNode(node);
      }
      if (input.StorageClass != null) {
        const node = xml_builder_1.XmlNode.of("StorageClass", input.StorageClass).withName("StorageClass");
        bodyNode.addChildNode(node);
      }
      if (input.AccessControlTranslation != null) {
        const node = serializeAws_restXmlAccessControlTranslation(input.AccessControlTranslation, context).withName("AccessControlTranslation");
        bodyNode.addChildNode(node);
      }
      if (input.EncryptionConfiguration != null) {
        const node = serializeAws_restXmlEncryptionConfiguration(input.EncryptionConfiguration, context).withName("EncryptionConfiguration");
        bodyNode.addChildNode(node);
      }
      if (input.ReplicationTime != null) {
        const node = serializeAws_restXmlReplicationTime(input.ReplicationTime, context).withName("ReplicationTime");
        bodyNode.addChildNode(node);
      }
      if (input.Metrics != null) {
        const node = serializeAws_restXmlMetrics(input.Metrics, context).withName("Metrics");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlEncryption = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("Encryption");
      if (input.EncryptionType != null) {
        const node = xml_builder_1.XmlNode.of("ServerSideEncryption", input.EncryptionType).withName("EncryptionType");
        bodyNode.addChildNode(node);
      }
      if (input.KMSKeyId != null) {
        const node = xml_builder_1.XmlNode.of("SSEKMSKeyId", input.KMSKeyId).withName("KMSKeyId");
        bodyNode.addChildNode(node);
      }
      if (input.KMSContext != null) {
        const node = xml_builder_1.XmlNode.of("KMSContext", input.KMSContext).withName("KMSContext");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlEncryptionConfiguration = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("EncryptionConfiguration");
      if (input.ReplicaKmsKeyID != null) {
        const node = xml_builder_1.XmlNode.of("ReplicaKmsKeyID", input.ReplicaKmsKeyID).withName("ReplicaKmsKeyID");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlErrorDocument = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("ErrorDocument");
      if (input.Key != null) {
        const node = xml_builder_1.XmlNode.of("ObjectKey", input.Key).withName("Key");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlEventBridgeConfiguration = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("EventBridgeConfiguration");
      return bodyNode;
    };
    var serializeAws_restXmlEventList = (input, context) => {
      return input.filter((e) => e != null).map((entry) => {
        const node = xml_builder_1.XmlNode.of("Event", entry);
        return node.withName("member");
      });
    };
    var serializeAws_restXmlExistingObjectReplication = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("ExistingObjectReplication");
      if (input.Status != null) {
        const node = xml_builder_1.XmlNode.of("ExistingObjectReplicationStatus", input.Status).withName("Status");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlExposeHeaders = (input, context) => {
      return input.filter((e) => e != null).map((entry) => {
        const node = xml_builder_1.XmlNode.of("ExposeHeader", entry);
        return node.withName("member");
      });
    };
    var serializeAws_restXmlFilterRule = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("FilterRule");
      if (input.Name != null) {
        const node = xml_builder_1.XmlNode.of("FilterRuleName", input.Name).withName("Name");
        bodyNode.addChildNode(node);
      }
      if (input.Value != null) {
        const node = xml_builder_1.XmlNode.of("FilterRuleValue", input.Value).withName("Value");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlFilterRuleList = (input, context) => {
      return input.filter((e) => e != null).map((entry) => {
        const node = serializeAws_restXmlFilterRule(entry, context);
        return node.withName("member");
      });
    };
    var serializeAws_restXmlGlacierJobParameters = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("GlacierJobParameters");
      if (input.Tier != null) {
        const node = xml_builder_1.XmlNode.of("Tier", input.Tier).withName("Tier");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlGrant = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("Grant");
      if (input.Grantee != null) {
        const node = serializeAws_restXmlGrantee(input.Grantee, context).withName("Grantee");
        node.addAttribute("xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance");
        bodyNode.addChildNode(node);
      }
      if (input.Permission != null) {
        const node = xml_builder_1.XmlNode.of("Permission", input.Permission).withName("Permission");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlGrantee = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("Grantee");
      if (input.DisplayName != null) {
        const node = xml_builder_1.XmlNode.of("DisplayName", input.DisplayName).withName("DisplayName");
        bodyNode.addChildNode(node);
      }
      if (input.EmailAddress != null) {
        const node = xml_builder_1.XmlNode.of("EmailAddress", input.EmailAddress).withName("EmailAddress");
        bodyNode.addChildNode(node);
      }
      if (input.ID != null) {
        const node = xml_builder_1.XmlNode.of("ID", input.ID).withName("ID");
        bodyNode.addChildNode(node);
      }
      if (input.URI != null) {
        const node = xml_builder_1.XmlNode.of("URI", input.URI).withName("URI");
        bodyNode.addChildNode(node);
      }
      if (input.Type != null) {
        bodyNode.addAttribute("xsi:type", input.Type);
      }
      return bodyNode;
    };
    var serializeAws_restXmlGrants = (input, context) => {
      return input.filter((e) => e != null).map((entry) => {
        const node = serializeAws_restXmlGrant(entry, context);
        return node.withName("Grant");
      });
    };
    var serializeAws_restXmlIndexDocument = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("IndexDocument");
      if (input.Suffix != null) {
        const node = xml_builder_1.XmlNode.of("Suffix", input.Suffix).withName("Suffix");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlInputSerialization = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("InputSerialization");
      if (input.CSV != null) {
        const node = serializeAws_restXmlCSVInput(input.CSV, context).withName("CSV");
        bodyNode.addChildNode(node);
      }
      if (input.CompressionType != null) {
        const node = xml_builder_1.XmlNode.of("CompressionType", input.CompressionType).withName("CompressionType");
        bodyNode.addChildNode(node);
      }
      if (input.JSON != null) {
        const node = serializeAws_restXmlJSONInput(input.JSON, context).withName("JSON");
        bodyNode.addChildNode(node);
      }
      if (input.Parquet != null) {
        const node = serializeAws_restXmlParquetInput(input.Parquet, context).withName("Parquet");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlIntelligentTieringAndOperator = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("IntelligentTieringAndOperator");
      if (input.Prefix != null) {
        const node = xml_builder_1.XmlNode.of("Prefix", input.Prefix).withName("Prefix");
        bodyNode.addChildNode(node);
      }
      if (input.Tags != null) {
        const nodes = serializeAws_restXmlTagSet(input.Tags, context);
        nodes.map((node) => {
          node = node.withName("Tag");
          bodyNode.addChildNode(node);
        });
      }
      return bodyNode;
    };
    var serializeAws_restXmlIntelligentTieringConfiguration = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("IntelligentTieringConfiguration");
      if (input.Id != null) {
        const node = xml_builder_1.XmlNode.of("IntelligentTieringId", input.Id).withName("Id");
        bodyNode.addChildNode(node);
      }
      if (input.Filter != null) {
        const node = serializeAws_restXmlIntelligentTieringFilter(input.Filter, context).withName("Filter");
        bodyNode.addChildNode(node);
      }
      if (input.Status != null) {
        const node = xml_builder_1.XmlNode.of("IntelligentTieringStatus", input.Status).withName("Status");
        bodyNode.addChildNode(node);
      }
      if (input.Tierings != null) {
        const nodes = serializeAws_restXmlTieringList(input.Tierings, context);
        nodes.map((node) => {
          node = node.withName("Tiering");
          bodyNode.addChildNode(node);
        });
      }
      return bodyNode;
    };
    var serializeAws_restXmlIntelligentTieringFilter = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("IntelligentTieringFilter");
      if (input.Prefix != null) {
        const node = xml_builder_1.XmlNode.of("Prefix", input.Prefix).withName("Prefix");
        bodyNode.addChildNode(node);
      }
      if (input.Tag != null) {
        const node = serializeAws_restXmlTag(input.Tag, context).withName("Tag");
        bodyNode.addChildNode(node);
      }
      if (input.And != null) {
        const node = serializeAws_restXmlIntelligentTieringAndOperator(input.And, context).withName("And");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlInventoryConfiguration = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("InventoryConfiguration");
      if (input.Destination != null) {
        const node = serializeAws_restXmlInventoryDestination(input.Destination, context).withName("Destination");
        bodyNode.addChildNode(node);
      }
      if (input.IsEnabled != null) {
        const node = xml_builder_1.XmlNode.of("IsEnabled", String(input.IsEnabled)).withName("IsEnabled");
        bodyNode.addChildNode(node);
      }
      if (input.Filter != null) {
        const node = serializeAws_restXmlInventoryFilter(input.Filter, context).withName("Filter");
        bodyNode.addChildNode(node);
      }
      if (input.Id != null) {
        const node = xml_builder_1.XmlNode.of("InventoryId", input.Id).withName("Id");
        bodyNode.addChildNode(node);
      }
      if (input.IncludedObjectVersions != null) {
        const node = xml_builder_1.XmlNode.of("InventoryIncludedObjectVersions", input.IncludedObjectVersions).withName("IncludedObjectVersions");
        bodyNode.addChildNode(node);
      }
      if (input.OptionalFields != null) {
        const nodes = serializeAws_restXmlInventoryOptionalFields(input.OptionalFields, context);
        const containerNode = new xml_builder_1.XmlNode("OptionalFields");
        nodes.map((node) => {
          containerNode.addChildNode(node);
        });
        bodyNode.addChildNode(containerNode);
      }
      if (input.Schedule != null) {
        const node = serializeAws_restXmlInventorySchedule(input.Schedule, context).withName("Schedule");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlInventoryDestination = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("InventoryDestination");
      if (input.S3BucketDestination != null) {
        const node = serializeAws_restXmlInventoryS3BucketDestination(input.S3BucketDestination, context).withName("S3BucketDestination");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlInventoryEncryption = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("InventoryEncryption");
      if (input.SSES3 != null) {
        const node = serializeAws_restXmlSSES3(input.SSES3, context).withName("SSE-S3");
        bodyNode.addChildNode(node);
      }
      if (input.SSEKMS != null) {
        const node = serializeAws_restXmlSSEKMS(input.SSEKMS, context).withName("SSE-KMS");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlInventoryFilter = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("InventoryFilter");
      if (input.Prefix != null) {
        const node = xml_builder_1.XmlNode.of("Prefix", input.Prefix).withName("Prefix");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlInventoryOptionalFields = (input, context) => {
      return input.filter((e) => e != null).map((entry) => {
        const node = xml_builder_1.XmlNode.of("InventoryOptionalField", entry);
        return node.withName("Field");
      });
    };
    var serializeAws_restXmlInventoryS3BucketDestination = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("InventoryS3BucketDestination");
      if (input.AccountId != null) {
        const node = xml_builder_1.XmlNode.of("AccountId", input.AccountId).withName("AccountId");
        bodyNode.addChildNode(node);
      }
      if (input.Bucket != null) {
        const node = xml_builder_1.XmlNode.of("BucketName", input.Bucket).withName("Bucket");
        bodyNode.addChildNode(node);
      }
      if (input.Format != null) {
        const node = xml_builder_1.XmlNode.of("InventoryFormat", input.Format).withName("Format");
        bodyNode.addChildNode(node);
      }
      if (input.Prefix != null) {
        const node = xml_builder_1.XmlNode.of("Prefix", input.Prefix).withName("Prefix");
        bodyNode.addChildNode(node);
      }
      if (input.Encryption != null) {
        const node = serializeAws_restXmlInventoryEncryption(input.Encryption, context).withName("Encryption");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlInventorySchedule = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("InventorySchedule");
      if (input.Frequency != null) {
        const node = xml_builder_1.XmlNode.of("InventoryFrequency", input.Frequency).withName("Frequency");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlJSONInput = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("JSONInput");
      if (input.Type != null) {
        const node = xml_builder_1.XmlNode.of("JSONType", input.Type).withName("Type");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlJSONOutput = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("JSONOutput");
      if (input.RecordDelimiter != null) {
        const node = xml_builder_1.XmlNode.of("RecordDelimiter", input.RecordDelimiter).withName("RecordDelimiter");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlLambdaFunctionConfiguration = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("LambdaFunctionConfiguration");
      if (input.Id != null) {
        const node = xml_builder_1.XmlNode.of("NotificationId", input.Id).withName("Id");
        bodyNode.addChildNode(node);
      }
      if (input.LambdaFunctionArn != null) {
        const node = xml_builder_1.XmlNode.of("LambdaFunctionArn", input.LambdaFunctionArn).withName("CloudFunction");
        bodyNode.addChildNode(node);
      }
      if (input.Events != null) {
        const nodes = serializeAws_restXmlEventList(input.Events, context);
        nodes.map((node) => {
          node = node.withName("Event");
          bodyNode.addChildNode(node);
        });
      }
      if (input.Filter != null) {
        const node = serializeAws_restXmlNotificationConfigurationFilter(input.Filter, context).withName("Filter");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlLambdaFunctionConfigurationList = (input, context) => {
      return input.filter((e) => e != null).map((entry) => {
        const node = serializeAws_restXmlLambdaFunctionConfiguration(entry, context);
        return node.withName("member");
      });
    };
    var serializeAws_restXmlLifecycleExpiration = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("LifecycleExpiration");
      if (input.Date != null) {
        const node = xml_builder_1.XmlNode.of("Date", (input.Date.toISOString().split(".")[0] + "Z").toString()).withName("Date");
        bodyNode.addChildNode(node);
      }
      if (input.Days != null) {
        const node = xml_builder_1.XmlNode.of("Days", String(input.Days)).withName("Days");
        bodyNode.addChildNode(node);
      }
      if (input.ExpiredObjectDeleteMarker != null) {
        const node = xml_builder_1.XmlNode.of("ExpiredObjectDeleteMarker", String(input.ExpiredObjectDeleteMarker)).withName("ExpiredObjectDeleteMarker");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlLifecycleRule = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("LifecycleRule");
      if (input.Expiration != null) {
        const node = serializeAws_restXmlLifecycleExpiration(input.Expiration, context).withName("Expiration");
        bodyNode.addChildNode(node);
      }
      if (input.ID != null) {
        const node = xml_builder_1.XmlNode.of("ID", input.ID).withName("ID");
        bodyNode.addChildNode(node);
      }
      if (input.Prefix != null) {
        const node = xml_builder_1.XmlNode.of("Prefix", input.Prefix).withName("Prefix");
        bodyNode.addChildNode(node);
      }
      if (input.Filter != null) {
        const node = serializeAws_restXmlLifecycleRuleFilter(input.Filter, context).withName("Filter");
        bodyNode.addChildNode(node);
      }
      if (input.Status != null) {
        const node = xml_builder_1.XmlNode.of("ExpirationStatus", input.Status).withName("Status");
        bodyNode.addChildNode(node);
      }
      if (input.Transitions != null) {
        const nodes = serializeAws_restXmlTransitionList(input.Transitions, context);
        nodes.map((node) => {
          node = node.withName("Transition");
          bodyNode.addChildNode(node);
        });
      }
      if (input.NoncurrentVersionTransitions != null) {
        const nodes = serializeAws_restXmlNoncurrentVersionTransitionList(input.NoncurrentVersionTransitions, context);
        nodes.map((node) => {
          node = node.withName("NoncurrentVersionTransition");
          bodyNode.addChildNode(node);
        });
      }
      if (input.NoncurrentVersionExpiration != null) {
        const node = serializeAws_restXmlNoncurrentVersionExpiration(input.NoncurrentVersionExpiration, context).withName("NoncurrentVersionExpiration");
        bodyNode.addChildNode(node);
      }
      if (input.AbortIncompleteMultipartUpload != null) {
        const node = serializeAws_restXmlAbortIncompleteMultipartUpload(input.AbortIncompleteMultipartUpload, context).withName("AbortIncompleteMultipartUpload");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlLifecycleRuleAndOperator = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("LifecycleRuleAndOperator");
      if (input.Prefix != null) {
        const node = xml_builder_1.XmlNode.of("Prefix", input.Prefix).withName("Prefix");
        bodyNode.addChildNode(node);
      }
      if (input.Tags != null) {
        const nodes = serializeAws_restXmlTagSet(input.Tags, context);
        nodes.map((node) => {
          node = node.withName("Tag");
          bodyNode.addChildNode(node);
        });
      }
      if (input.ObjectSizeGreaterThan != null) {
        const node = xml_builder_1.XmlNode.of("ObjectSizeGreaterThanBytes", String(input.ObjectSizeGreaterThan)).withName("ObjectSizeGreaterThan");
        bodyNode.addChildNode(node);
      }
      if (input.ObjectSizeLessThan != null) {
        const node = xml_builder_1.XmlNode.of("ObjectSizeLessThanBytes", String(input.ObjectSizeLessThan)).withName("ObjectSizeLessThan");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlLifecycleRuleFilter = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("LifecycleRuleFilter");
      models_0_1.LifecycleRuleFilter.visit(input, {
        Prefix: (value) => {
          const node = xml_builder_1.XmlNode.of("Prefix", value).withName("Prefix");
          bodyNode.addChildNode(node);
        },
        Tag: (value) => {
          const node = serializeAws_restXmlTag(value, context).withName("Tag");
          bodyNode.addChildNode(node);
        },
        ObjectSizeGreaterThan: (value) => {
          const node = xml_builder_1.XmlNode.of("ObjectSizeGreaterThanBytes", String(value)).withName("ObjectSizeGreaterThan");
          bodyNode.addChildNode(node);
        },
        ObjectSizeLessThan: (value) => {
          const node = xml_builder_1.XmlNode.of("ObjectSizeLessThanBytes", String(value)).withName("ObjectSizeLessThan");
          bodyNode.addChildNode(node);
        },
        And: (value) => {
          const node = serializeAws_restXmlLifecycleRuleAndOperator(value, context).withName("And");
          bodyNode.addChildNode(node);
        },
        _: (name, value) => {
          if (!(value instanceof xml_builder_1.XmlNode || value instanceof xml_builder_1.XmlText)) {
            throw new Error("Unable to serialize unknown union members in XML.");
          }
          bodyNode.addChildNode(new xml_builder_1.XmlNode(name).addChildNode(value));
        }
      });
      return bodyNode;
    };
    var serializeAws_restXmlLifecycleRules = (input, context) => {
      return input.filter((e) => e != null).map((entry) => {
        const node = serializeAws_restXmlLifecycleRule(entry, context);
        return node.withName("member");
      });
    };
    var serializeAws_restXmlLoggingEnabled = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("LoggingEnabled");
      if (input.TargetBucket != null) {
        const node = xml_builder_1.XmlNode.of("TargetBucket", input.TargetBucket).withName("TargetBucket");
        bodyNode.addChildNode(node);
      }
      if (input.TargetGrants != null) {
        const nodes = serializeAws_restXmlTargetGrants(input.TargetGrants, context);
        const containerNode = new xml_builder_1.XmlNode("TargetGrants");
        nodes.map((node) => {
          containerNode.addChildNode(node);
        });
        bodyNode.addChildNode(containerNode);
      }
      if (input.TargetPrefix != null) {
        const node = xml_builder_1.XmlNode.of("TargetPrefix", input.TargetPrefix).withName("TargetPrefix");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlMetadataEntry = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("MetadataEntry");
      if (input.Name != null) {
        const node = xml_builder_1.XmlNode.of("MetadataKey", input.Name).withName("Name");
        bodyNode.addChildNode(node);
      }
      if (input.Value != null) {
        const node = xml_builder_1.XmlNode.of("MetadataValue", input.Value).withName("Value");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlMetrics = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("Metrics");
      if (input.Status != null) {
        const node = xml_builder_1.XmlNode.of("MetricsStatus", input.Status).withName("Status");
        bodyNode.addChildNode(node);
      }
      if (input.EventThreshold != null) {
        const node = serializeAws_restXmlReplicationTimeValue(input.EventThreshold, context).withName("EventThreshold");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlMetricsAndOperator = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("MetricsAndOperator");
      if (input.Prefix != null) {
        const node = xml_builder_1.XmlNode.of("Prefix", input.Prefix).withName("Prefix");
        bodyNode.addChildNode(node);
      }
      if (input.Tags != null) {
        const nodes = serializeAws_restXmlTagSet(input.Tags, context);
        nodes.map((node) => {
          node = node.withName("Tag");
          bodyNode.addChildNode(node);
        });
      }
      if (input.AccessPointArn != null) {
        const node = xml_builder_1.XmlNode.of("AccessPointArn", input.AccessPointArn).withName("AccessPointArn");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlMetricsConfiguration = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("MetricsConfiguration");
      if (input.Id != null) {
        const node = xml_builder_1.XmlNode.of("MetricsId", input.Id).withName("Id");
        bodyNode.addChildNode(node);
      }
      if (input.Filter != null) {
        const node = serializeAws_restXmlMetricsFilter(input.Filter, context).withName("Filter");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlMetricsFilter = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("MetricsFilter");
      models_0_1.MetricsFilter.visit(input, {
        Prefix: (value) => {
          const node = xml_builder_1.XmlNode.of("Prefix", value).withName("Prefix");
          bodyNode.addChildNode(node);
        },
        Tag: (value) => {
          const node = serializeAws_restXmlTag(value, context).withName("Tag");
          bodyNode.addChildNode(node);
        },
        AccessPointArn: (value) => {
          const node = xml_builder_1.XmlNode.of("AccessPointArn", value).withName("AccessPointArn");
          bodyNode.addChildNode(node);
        },
        And: (value) => {
          const node = serializeAws_restXmlMetricsAndOperator(value, context).withName("And");
          bodyNode.addChildNode(node);
        },
        _: (name, value) => {
          if (!(value instanceof xml_builder_1.XmlNode || value instanceof xml_builder_1.XmlText)) {
            throw new Error("Unable to serialize unknown union members in XML.");
          }
          bodyNode.addChildNode(new xml_builder_1.XmlNode(name).addChildNode(value));
        }
      });
      return bodyNode;
    };
    var serializeAws_restXmlNoncurrentVersionExpiration = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("NoncurrentVersionExpiration");
      if (input.NoncurrentDays != null) {
        const node = xml_builder_1.XmlNode.of("Days", String(input.NoncurrentDays)).withName("NoncurrentDays");
        bodyNode.addChildNode(node);
      }
      if (input.NewerNoncurrentVersions != null) {
        const node = xml_builder_1.XmlNode.of("VersionCount", String(input.NewerNoncurrentVersions)).withName("NewerNoncurrentVersions");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlNoncurrentVersionTransition = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("NoncurrentVersionTransition");
      if (input.NoncurrentDays != null) {
        const node = xml_builder_1.XmlNode.of("Days", String(input.NoncurrentDays)).withName("NoncurrentDays");
        bodyNode.addChildNode(node);
      }
      if (input.StorageClass != null) {
        const node = xml_builder_1.XmlNode.of("TransitionStorageClass", input.StorageClass).withName("StorageClass");
        bodyNode.addChildNode(node);
      }
      if (input.NewerNoncurrentVersions != null) {
        const node = xml_builder_1.XmlNode.of("VersionCount", String(input.NewerNoncurrentVersions)).withName("NewerNoncurrentVersions");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlNoncurrentVersionTransitionList = (input, context) => {
      return input.filter((e) => e != null).map((entry) => {
        const node = serializeAws_restXmlNoncurrentVersionTransition(entry, context);
        return node.withName("member");
      });
    };
    var serializeAws_restXmlNotificationConfiguration = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("NotificationConfiguration");
      if (input.TopicConfigurations != null) {
        const nodes = serializeAws_restXmlTopicConfigurationList(input.TopicConfigurations, context);
        nodes.map((node) => {
          node = node.withName("TopicConfiguration");
          bodyNode.addChildNode(node);
        });
      }
      if (input.QueueConfigurations != null) {
        const nodes = serializeAws_restXmlQueueConfigurationList(input.QueueConfigurations, context);
        nodes.map((node) => {
          node = node.withName("QueueConfiguration");
          bodyNode.addChildNode(node);
        });
      }
      if (input.LambdaFunctionConfigurations != null) {
        const nodes = serializeAws_restXmlLambdaFunctionConfigurationList(input.LambdaFunctionConfigurations, context);
        nodes.map((node) => {
          node = node.withName("CloudFunctionConfiguration");
          bodyNode.addChildNode(node);
        });
      }
      if (input.EventBridgeConfiguration != null) {
        const node = serializeAws_restXmlEventBridgeConfiguration(input.EventBridgeConfiguration, context).withName("EventBridgeConfiguration");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlNotificationConfigurationFilter = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("NotificationConfigurationFilter");
      if (input.Key != null) {
        const node = serializeAws_restXmlS3KeyFilter(input.Key, context).withName("S3Key");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlObjectIdentifier = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("ObjectIdentifier");
      if (input.Key != null) {
        const node = xml_builder_1.XmlNode.of("ObjectKey", input.Key).withName("Key");
        bodyNode.addChildNode(node);
      }
      if (input.VersionId != null) {
        const node = xml_builder_1.XmlNode.of("ObjectVersionId", input.VersionId).withName("VersionId");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlObjectIdentifierList = (input, context) => {
      return input.filter((e) => e != null).map((entry) => {
        const node = serializeAws_restXmlObjectIdentifier(entry, context);
        return node.withName("member");
      });
    };
    var serializeAws_restXmlObjectLockConfiguration = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("ObjectLockConfiguration");
      if (input.ObjectLockEnabled != null) {
        const node = xml_builder_1.XmlNode.of("ObjectLockEnabled", input.ObjectLockEnabled).withName("ObjectLockEnabled");
        bodyNode.addChildNode(node);
      }
      if (input.Rule != null) {
        const node = serializeAws_restXmlObjectLockRule(input.Rule, context).withName("Rule");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlObjectLockLegalHold = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("ObjectLockLegalHold");
      if (input.Status != null) {
        const node = xml_builder_1.XmlNode.of("ObjectLockLegalHoldStatus", input.Status).withName("Status");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlObjectLockRetention = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("ObjectLockRetention");
      if (input.Mode != null) {
        const node = xml_builder_1.XmlNode.of("ObjectLockRetentionMode", input.Mode).withName("Mode");
        bodyNode.addChildNode(node);
      }
      if (input.RetainUntilDate != null) {
        const node = xml_builder_1.XmlNode.of("Date", (input.RetainUntilDate.toISOString().split(".")[0] + "Z").toString()).withName("RetainUntilDate");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlObjectLockRule = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("ObjectLockRule");
      if (input.DefaultRetention != null) {
        const node = serializeAws_restXmlDefaultRetention(input.DefaultRetention, context).withName("DefaultRetention");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlOutputLocation = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("OutputLocation");
      if (input.S3 != null) {
        const node = serializeAws_restXmlS3Location(input.S3, context).withName("S3");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlOutputSerialization = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("OutputSerialization");
      if (input.CSV != null) {
        const node = serializeAws_restXmlCSVOutput(input.CSV, context).withName("CSV");
        bodyNode.addChildNode(node);
      }
      if (input.JSON != null) {
        const node = serializeAws_restXmlJSONOutput(input.JSON, context).withName("JSON");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlOwner = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("Owner");
      if (input.DisplayName != null) {
        const node = xml_builder_1.XmlNode.of("DisplayName", input.DisplayName).withName("DisplayName");
        bodyNode.addChildNode(node);
      }
      if (input.ID != null) {
        const node = xml_builder_1.XmlNode.of("ID", input.ID).withName("ID");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlOwnershipControls = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("OwnershipControls");
      if (input.Rules != null) {
        const nodes = serializeAws_restXmlOwnershipControlsRules(input.Rules, context);
        nodes.map((node) => {
          node = node.withName("Rule");
          bodyNode.addChildNode(node);
        });
      }
      return bodyNode;
    };
    var serializeAws_restXmlOwnershipControlsRule = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("OwnershipControlsRule");
      if (input.ObjectOwnership != null) {
        const node = xml_builder_1.XmlNode.of("ObjectOwnership", input.ObjectOwnership).withName("ObjectOwnership");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlOwnershipControlsRules = (input, context) => {
      return input.filter((e) => e != null).map((entry) => {
        const node = serializeAws_restXmlOwnershipControlsRule(entry, context);
        return node.withName("member");
      });
    };
    var serializeAws_restXmlParquetInput = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("ParquetInput");
      return bodyNode;
    };
    var serializeAws_restXmlPublicAccessBlockConfiguration = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("PublicAccessBlockConfiguration");
      if (input.BlockPublicAcls != null) {
        const node = xml_builder_1.XmlNode.of("Setting", String(input.BlockPublicAcls)).withName("BlockPublicAcls");
        bodyNode.addChildNode(node);
      }
      if (input.IgnorePublicAcls != null) {
        const node = xml_builder_1.XmlNode.of("Setting", String(input.IgnorePublicAcls)).withName("IgnorePublicAcls");
        bodyNode.addChildNode(node);
      }
      if (input.BlockPublicPolicy != null) {
        const node = xml_builder_1.XmlNode.of("Setting", String(input.BlockPublicPolicy)).withName("BlockPublicPolicy");
        bodyNode.addChildNode(node);
      }
      if (input.RestrictPublicBuckets != null) {
        const node = xml_builder_1.XmlNode.of("Setting", String(input.RestrictPublicBuckets)).withName("RestrictPublicBuckets");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlQueueConfiguration = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("QueueConfiguration");
      if (input.Id != null) {
        const node = xml_builder_1.XmlNode.of("NotificationId", input.Id).withName("Id");
        bodyNode.addChildNode(node);
      }
      if (input.QueueArn != null) {
        const node = xml_builder_1.XmlNode.of("QueueArn", input.QueueArn).withName("Queue");
        bodyNode.addChildNode(node);
      }
      if (input.Events != null) {
        const nodes = serializeAws_restXmlEventList(input.Events, context);
        nodes.map((node) => {
          node = node.withName("Event");
          bodyNode.addChildNode(node);
        });
      }
      if (input.Filter != null) {
        const node = serializeAws_restXmlNotificationConfigurationFilter(input.Filter, context).withName("Filter");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlQueueConfigurationList = (input, context) => {
      return input.filter((e) => e != null).map((entry) => {
        const node = serializeAws_restXmlQueueConfiguration(entry, context);
        return node.withName("member");
      });
    };
    var serializeAws_restXmlRedirect = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("Redirect");
      if (input.HostName != null) {
        const node = xml_builder_1.XmlNode.of("HostName", input.HostName).withName("HostName");
        bodyNode.addChildNode(node);
      }
      if (input.HttpRedirectCode != null) {
        const node = xml_builder_1.XmlNode.of("HttpRedirectCode", input.HttpRedirectCode).withName("HttpRedirectCode");
        bodyNode.addChildNode(node);
      }
      if (input.Protocol != null) {
        const node = xml_builder_1.XmlNode.of("Protocol", input.Protocol).withName("Protocol");
        bodyNode.addChildNode(node);
      }
      if (input.ReplaceKeyPrefixWith != null) {
        const node = xml_builder_1.XmlNode.of("ReplaceKeyPrefixWith", input.ReplaceKeyPrefixWith).withName("ReplaceKeyPrefixWith");
        bodyNode.addChildNode(node);
      }
      if (input.ReplaceKeyWith != null) {
        const node = xml_builder_1.XmlNode.of("ReplaceKeyWith", input.ReplaceKeyWith).withName("ReplaceKeyWith");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlRedirectAllRequestsTo = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("RedirectAllRequestsTo");
      if (input.HostName != null) {
        const node = xml_builder_1.XmlNode.of("HostName", input.HostName).withName("HostName");
        bodyNode.addChildNode(node);
      }
      if (input.Protocol != null) {
        const node = xml_builder_1.XmlNode.of("Protocol", input.Protocol).withName("Protocol");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlReplicaModifications = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("ReplicaModifications");
      if (input.Status != null) {
        const node = xml_builder_1.XmlNode.of("ReplicaModificationsStatus", input.Status).withName("Status");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlReplicationConfiguration = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("ReplicationConfiguration");
      if (input.Role != null) {
        const node = xml_builder_1.XmlNode.of("Role", input.Role).withName("Role");
        bodyNode.addChildNode(node);
      }
      if (input.Rules != null) {
        const nodes = serializeAws_restXmlReplicationRules(input.Rules, context);
        nodes.map((node) => {
          node = node.withName("Rule");
          bodyNode.addChildNode(node);
        });
      }
      return bodyNode;
    };
    var serializeAws_restXmlReplicationRule = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("ReplicationRule");
      if (input.ID != null) {
        const node = xml_builder_1.XmlNode.of("ID", input.ID).withName("ID");
        bodyNode.addChildNode(node);
      }
      if (input.Priority != null) {
        const node = xml_builder_1.XmlNode.of("Priority", String(input.Priority)).withName("Priority");
        bodyNode.addChildNode(node);
      }
      if (input.Prefix != null) {
        const node = xml_builder_1.XmlNode.of("Prefix", input.Prefix).withName("Prefix");
        bodyNode.addChildNode(node);
      }
      if (input.Filter != null) {
        const node = serializeAws_restXmlReplicationRuleFilter(input.Filter, context).withName("Filter");
        bodyNode.addChildNode(node);
      }
      if (input.Status != null) {
        const node = xml_builder_1.XmlNode.of("ReplicationRuleStatus", input.Status).withName("Status");
        bodyNode.addChildNode(node);
      }
      if (input.SourceSelectionCriteria != null) {
        const node = serializeAws_restXmlSourceSelectionCriteria(input.SourceSelectionCriteria, context).withName("SourceSelectionCriteria");
        bodyNode.addChildNode(node);
      }
      if (input.ExistingObjectReplication != null) {
        const node = serializeAws_restXmlExistingObjectReplication(input.ExistingObjectReplication, context).withName("ExistingObjectReplication");
        bodyNode.addChildNode(node);
      }
      if (input.Destination != null) {
        const node = serializeAws_restXmlDestination(input.Destination, context).withName("Destination");
        bodyNode.addChildNode(node);
      }
      if (input.DeleteMarkerReplication != null) {
        const node = serializeAws_restXmlDeleteMarkerReplication(input.DeleteMarkerReplication, context).withName("DeleteMarkerReplication");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlReplicationRuleAndOperator = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("ReplicationRuleAndOperator");
      if (input.Prefix != null) {
        const node = xml_builder_1.XmlNode.of("Prefix", input.Prefix).withName("Prefix");
        bodyNode.addChildNode(node);
      }
      if (input.Tags != null) {
        const nodes = serializeAws_restXmlTagSet(input.Tags, context);
        nodes.map((node) => {
          node = node.withName("Tag");
          bodyNode.addChildNode(node);
        });
      }
      return bodyNode;
    };
    var serializeAws_restXmlReplicationRuleFilter = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("ReplicationRuleFilter");
      models_0_1.ReplicationRuleFilter.visit(input, {
        Prefix: (value) => {
          const node = xml_builder_1.XmlNode.of("Prefix", value).withName("Prefix");
          bodyNode.addChildNode(node);
        },
        Tag: (value) => {
          const node = serializeAws_restXmlTag(value, context).withName("Tag");
          bodyNode.addChildNode(node);
        },
        And: (value) => {
          const node = serializeAws_restXmlReplicationRuleAndOperator(value, context).withName("And");
          bodyNode.addChildNode(node);
        },
        _: (name, value) => {
          if (!(value instanceof xml_builder_1.XmlNode || value instanceof xml_builder_1.XmlText)) {
            throw new Error("Unable to serialize unknown union members in XML.");
          }
          bodyNode.addChildNode(new xml_builder_1.XmlNode(name).addChildNode(value));
        }
      });
      return bodyNode;
    };
    var serializeAws_restXmlReplicationRules = (input, context) => {
      return input.filter((e) => e != null).map((entry) => {
        const node = serializeAws_restXmlReplicationRule(entry, context);
        return node.withName("member");
      });
    };
    var serializeAws_restXmlReplicationTime = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("ReplicationTime");
      if (input.Status != null) {
        const node = xml_builder_1.XmlNode.of("ReplicationTimeStatus", input.Status).withName("Status");
        bodyNode.addChildNode(node);
      }
      if (input.Time != null) {
        const node = serializeAws_restXmlReplicationTimeValue(input.Time, context).withName("Time");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlReplicationTimeValue = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("ReplicationTimeValue");
      if (input.Minutes != null) {
        const node = xml_builder_1.XmlNode.of("Minutes", String(input.Minutes)).withName("Minutes");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlRequestPaymentConfiguration = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("RequestPaymentConfiguration");
      if (input.Payer != null) {
        const node = xml_builder_1.XmlNode.of("Payer", input.Payer).withName("Payer");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlRequestProgress = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("RequestProgress");
      if (input.Enabled != null) {
        const node = xml_builder_1.XmlNode.of("EnableRequestProgress", String(input.Enabled)).withName("Enabled");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlRestoreRequest = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("RestoreRequest");
      if (input.Days != null) {
        const node = xml_builder_1.XmlNode.of("Days", String(input.Days)).withName("Days");
        bodyNode.addChildNode(node);
      }
      if (input.GlacierJobParameters != null) {
        const node = serializeAws_restXmlGlacierJobParameters(input.GlacierJobParameters, context).withName("GlacierJobParameters");
        bodyNode.addChildNode(node);
      }
      if (input.Type != null) {
        const node = xml_builder_1.XmlNode.of("RestoreRequestType", input.Type).withName("Type");
        bodyNode.addChildNode(node);
      }
      if (input.Tier != null) {
        const node = xml_builder_1.XmlNode.of("Tier", input.Tier).withName("Tier");
        bodyNode.addChildNode(node);
      }
      if (input.Description != null) {
        const node = xml_builder_1.XmlNode.of("Description", input.Description).withName("Description");
        bodyNode.addChildNode(node);
      }
      if (input.SelectParameters != null) {
        const node = serializeAws_restXmlSelectParameters(input.SelectParameters, context).withName("SelectParameters");
        bodyNode.addChildNode(node);
      }
      if (input.OutputLocation != null) {
        const node = serializeAws_restXmlOutputLocation(input.OutputLocation, context).withName("OutputLocation");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlRoutingRule = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("RoutingRule");
      if (input.Condition != null) {
        const node = serializeAws_restXmlCondition(input.Condition, context).withName("Condition");
        bodyNode.addChildNode(node);
      }
      if (input.Redirect != null) {
        const node = serializeAws_restXmlRedirect(input.Redirect, context).withName("Redirect");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlRoutingRules = (input, context) => {
      return input.filter((e) => e != null).map((entry) => {
        const node = serializeAws_restXmlRoutingRule(entry, context);
        return node.withName("RoutingRule");
      });
    };
    var serializeAws_restXmlS3KeyFilter = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("S3KeyFilter");
      if (input.FilterRules != null) {
        const nodes = serializeAws_restXmlFilterRuleList(input.FilterRules, context);
        nodes.map((node) => {
          node = node.withName("FilterRule");
          bodyNode.addChildNode(node);
        });
      }
      return bodyNode;
    };
    var serializeAws_restXmlS3Location = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("S3Location");
      if (input.BucketName != null) {
        const node = xml_builder_1.XmlNode.of("BucketName", input.BucketName).withName("BucketName");
        bodyNode.addChildNode(node);
      }
      if (input.Prefix != null) {
        const node = xml_builder_1.XmlNode.of("LocationPrefix", input.Prefix).withName("Prefix");
        bodyNode.addChildNode(node);
      }
      if (input.Encryption != null) {
        const node = serializeAws_restXmlEncryption(input.Encryption, context).withName("Encryption");
        bodyNode.addChildNode(node);
      }
      if (input.CannedACL != null) {
        const node = xml_builder_1.XmlNode.of("ObjectCannedACL", input.CannedACL).withName("CannedACL");
        bodyNode.addChildNode(node);
      }
      if (input.AccessControlList != null) {
        const nodes = serializeAws_restXmlGrants(input.AccessControlList, context);
        const containerNode = new xml_builder_1.XmlNode("AccessControlList");
        nodes.map((node) => {
          containerNode.addChildNode(node);
        });
        bodyNode.addChildNode(containerNode);
      }
      if (input.Tagging != null) {
        const node = serializeAws_restXmlTagging(input.Tagging, context).withName("Tagging");
        bodyNode.addChildNode(node);
      }
      if (input.UserMetadata != null) {
        const nodes = serializeAws_restXmlUserMetadata(input.UserMetadata, context);
        const containerNode = new xml_builder_1.XmlNode("UserMetadata");
        nodes.map((node) => {
          containerNode.addChildNode(node);
        });
        bodyNode.addChildNode(containerNode);
      }
      if (input.StorageClass != null) {
        const node = xml_builder_1.XmlNode.of("StorageClass", input.StorageClass).withName("StorageClass");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlScanRange = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("ScanRange");
      if (input.Start != null) {
        const node = xml_builder_1.XmlNode.of("Start", String(input.Start)).withName("Start");
        bodyNode.addChildNode(node);
      }
      if (input.End != null) {
        const node = xml_builder_1.XmlNode.of("End", String(input.End)).withName("End");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlSelectParameters = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("SelectParameters");
      if (input.InputSerialization != null) {
        const node = serializeAws_restXmlInputSerialization(input.InputSerialization, context).withName("InputSerialization");
        bodyNode.addChildNode(node);
      }
      if (input.ExpressionType != null) {
        const node = xml_builder_1.XmlNode.of("ExpressionType", input.ExpressionType).withName("ExpressionType");
        bodyNode.addChildNode(node);
      }
      if (input.Expression != null) {
        const node = xml_builder_1.XmlNode.of("Expression", input.Expression).withName("Expression");
        bodyNode.addChildNode(node);
      }
      if (input.OutputSerialization != null) {
        const node = serializeAws_restXmlOutputSerialization(input.OutputSerialization, context).withName("OutputSerialization");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlServerSideEncryptionByDefault = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("ServerSideEncryptionByDefault");
      if (input.SSEAlgorithm != null) {
        const node = xml_builder_1.XmlNode.of("ServerSideEncryption", input.SSEAlgorithm).withName("SSEAlgorithm");
        bodyNode.addChildNode(node);
      }
      if (input.KMSMasterKeyID != null) {
        const node = xml_builder_1.XmlNode.of("SSEKMSKeyId", input.KMSMasterKeyID).withName("KMSMasterKeyID");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlServerSideEncryptionConfiguration = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("ServerSideEncryptionConfiguration");
      if (input.Rules != null) {
        const nodes = serializeAws_restXmlServerSideEncryptionRules(input.Rules, context);
        nodes.map((node) => {
          node = node.withName("Rule");
          bodyNode.addChildNode(node);
        });
      }
      return bodyNode;
    };
    var serializeAws_restXmlServerSideEncryptionRule = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("ServerSideEncryptionRule");
      if (input.ApplyServerSideEncryptionByDefault != null) {
        const node = serializeAws_restXmlServerSideEncryptionByDefault(input.ApplyServerSideEncryptionByDefault, context).withName("ApplyServerSideEncryptionByDefault");
        bodyNode.addChildNode(node);
      }
      if (input.BucketKeyEnabled != null) {
        const node = xml_builder_1.XmlNode.of("BucketKeyEnabled", String(input.BucketKeyEnabled)).withName("BucketKeyEnabled");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlServerSideEncryptionRules = (input, context) => {
      return input.filter((e) => e != null).map((entry) => {
        const node = serializeAws_restXmlServerSideEncryptionRule(entry, context);
        return node.withName("member");
      });
    };
    var serializeAws_restXmlSourceSelectionCriteria = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("SourceSelectionCriteria");
      if (input.SseKmsEncryptedObjects != null) {
        const node = serializeAws_restXmlSseKmsEncryptedObjects(input.SseKmsEncryptedObjects, context).withName("SseKmsEncryptedObjects");
        bodyNode.addChildNode(node);
      }
      if (input.ReplicaModifications != null) {
        const node = serializeAws_restXmlReplicaModifications(input.ReplicaModifications, context).withName("ReplicaModifications");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlSSEKMS = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("SSE-KMS");
      if (input.KeyId != null) {
        const node = xml_builder_1.XmlNode.of("SSEKMSKeyId", input.KeyId).withName("KeyId");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlSseKmsEncryptedObjects = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("SseKmsEncryptedObjects");
      if (input.Status != null) {
        const node = xml_builder_1.XmlNode.of("SseKmsEncryptedObjectsStatus", input.Status).withName("Status");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlSSES3 = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("SSE-S3");
      return bodyNode;
    };
    var serializeAws_restXmlStorageClassAnalysis = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("StorageClassAnalysis");
      if (input.DataExport != null) {
        const node = serializeAws_restXmlStorageClassAnalysisDataExport(input.DataExport, context).withName("DataExport");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlStorageClassAnalysisDataExport = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("StorageClassAnalysisDataExport");
      if (input.OutputSchemaVersion != null) {
        const node = xml_builder_1.XmlNode.of("StorageClassAnalysisSchemaVersion", input.OutputSchemaVersion).withName("OutputSchemaVersion");
        bodyNode.addChildNode(node);
      }
      if (input.Destination != null) {
        const node = serializeAws_restXmlAnalyticsExportDestination(input.Destination, context).withName("Destination");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlTag = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("Tag");
      if (input.Key != null) {
        const node = xml_builder_1.XmlNode.of("ObjectKey", input.Key).withName("Key");
        bodyNode.addChildNode(node);
      }
      if (input.Value != null) {
        const node = xml_builder_1.XmlNode.of("Value", input.Value).withName("Value");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlTagging = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("Tagging");
      if (input.TagSet != null) {
        const nodes = serializeAws_restXmlTagSet(input.TagSet, context);
        const containerNode = new xml_builder_1.XmlNode("TagSet");
        nodes.map((node) => {
          containerNode.addChildNode(node);
        });
        bodyNode.addChildNode(containerNode);
      }
      return bodyNode;
    };
    var serializeAws_restXmlTagSet = (input, context) => {
      return input.filter((e) => e != null).map((entry) => {
        const node = serializeAws_restXmlTag(entry, context);
        return node.withName("Tag");
      });
    };
    var serializeAws_restXmlTargetGrant = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("TargetGrant");
      if (input.Grantee != null) {
        const node = serializeAws_restXmlGrantee(input.Grantee, context).withName("Grantee");
        node.addAttribute("xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance");
        bodyNode.addChildNode(node);
      }
      if (input.Permission != null) {
        const node = xml_builder_1.XmlNode.of("BucketLogsPermission", input.Permission).withName("Permission");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlTargetGrants = (input, context) => {
      return input.filter((e) => e != null).map((entry) => {
        const node = serializeAws_restXmlTargetGrant(entry, context);
        return node.withName("Grant");
      });
    };
    var serializeAws_restXmlTiering = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("Tiering");
      if (input.Days != null) {
        const node = xml_builder_1.XmlNode.of("IntelligentTieringDays", String(input.Days)).withName("Days");
        bodyNode.addChildNode(node);
      }
      if (input.AccessTier != null) {
        const node = xml_builder_1.XmlNode.of("IntelligentTieringAccessTier", input.AccessTier).withName("AccessTier");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlTieringList = (input, context) => {
      return input.filter((e) => e != null).map((entry) => {
        const node = serializeAws_restXmlTiering(entry, context);
        return node.withName("member");
      });
    };
    var serializeAws_restXmlTopicConfiguration = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("TopicConfiguration");
      if (input.Id != null) {
        const node = xml_builder_1.XmlNode.of("NotificationId", input.Id).withName("Id");
        bodyNode.addChildNode(node);
      }
      if (input.TopicArn != null) {
        const node = xml_builder_1.XmlNode.of("TopicArn", input.TopicArn).withName("Topic");
        bodyNode.addChildNode(node);
      }
      if (input.Events != null) {
        const nodes = serializeAws_restXmlEventList(input.Events, context);
        nodes.map((node) => {
          node = node.withName("Event");
          bodyNode.addChildNode(node);
        });
      }
      if (input.Filter != null) {
        const node = serializeAws_restXmlNotificationConfigurationFilter(input.Filter, context).withName("Filter");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlTopicConfigurationList = (input, context) => {
      return input.filter((e) => e != null).map((entry) => {
        const node = serializeAws_restXmlTopicConfiguration(entry, context);
        return node.withName("member");
      });
    };
    var serializeAws_restXmlTransition = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("Transition");
      if (input.Date != null) {
        const node = xml_builder_1.XmlNode.of("Date", (input.Date.toISOString().split(".")[0] + "Z").toString()).withName("Date");
        bodyNode.addChildNode(node);
      }
      if (input.Days != null) {
        const node = xml_builder_1.XmlNode.of("Days", String(input.Days)).withName("Days");
        bodyNode.addChildNode(node);
      }
      if (input.StorageClass != null) {
        const node = xml_builder_1.XmlNode.of("TransitionStorageClass", input.StorageClass).withName("StorageClass");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlTransitionList = (input, context) => {
      return input.filter((e) => e != null).map((entry) => {
        const node = serializeAws_restXmlTransition(entry, context);
        return node.withName("member");
      });
    };
    var serializeAws_restXmlUserMetadata = (input, context) => {
      return input.filter((e) => e != null).map((entry) => {
        const node = serializeAws_restXmlMetadataEntry(entry, context);
        return node.withName("MetadataEntry");
      });
    };
    var serializeAws_restXmlVersioningConfiguration = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("VersioningConfiguration");
      if (input.MFADelete != null) {
        const node = xml_builder_1.XmlNode.of("MFADelete", input.MFADelete).withName("MfaDelete");
        bodyNode.addChildNode(node);
      }
      if (input.Status != null) {
        const node = xml_builder_1.XmlNode.of("BucketVersioningStatus", input.Status).withName("Status");
        bodyNode.addChildNode(node);
      }
      return bodyNode;
    };
    var serializeAws_restXmlWebsiteConfiguration = (input, context) => {
      const bodyNode = new xml_builder_1.XmlNode("WebsiteConfiguration");
      if (input.ErrorDocument != null) {
        const node = serializeAws_restXmlErrorDocument(input.ErrorDocument, context).withName("ErrorDocument");
        bodyNode.addChildNode(node);
      }
      if (input.IndexDocument != null) {
        const node = serializeAws_restXmlIndexDocument(input.IndexDocument, context).withName("IndexDocument");
        bodyNode.addChildNode(node);
      }
      if (input.RedirectAllRequestsTo != null) {
        const node = serializeAws_restXmlRedirectAllRequestsTo(input.RedirectAllRequestsTo, context).withName("RedirectAllRequestsTo");
        bodyNode.addChildNode(node);
      }
      if (input.RoutingRules != null) {
        const nodes = serializeAws_restXmlRoutingRules(input.RoutingRules, context);
        const containerNode = new xml_builder_1.XmlNode("RoutingRules");
        nodes.map((node) => {
          containerNode.addChildNode(node);
        });
        bodyNode.addChildNode(containerNode);
      }
      return bodyNode;
    };
    var deserializeAws_restXmlAbortIncompleteMultipartUpload = (output, context) => {
      const contents = {
        DaysAfterInitiation: void 0
      };
      if (output["DaysAfterInitiation"] !== void 0) {
        contents.DaysAfterInitiation = (0, smithy_client_1.strictParseInt32)(output["DaysAfterInitiation"]);
      }
      return contents;
    };
    var deserializeAws_restXmlAccessControlTranslation = (output, context) => {
      const contents = {
        Owner: void 0
      };
      if (output["Owner"] !== void 0) {
        contents.Owner = (0, smithy_client_1.expectString)(output["Owner"]);
      }
      return contents;
    };
    var deserializeAws_restXmlAllowedHeaders = (output, context) => {
      return (output || []).filter((e) => e != null).map((entry) => {
        return (0, smithy_client_1.expectString)(entry);
      });
    };
    var deserializeAws_restXmlAllowedMethods = (output, context) => {
      return (output || []).filter((e) => e != null).map((entry) => {
        return (0, smithy_client_1.expectString)(entry);
      });
    };
    var deserializeAws_restXmlAllowedOrigins = (output, context) => {
      return (output || []).filter((e) => e != null).map((entry) => {
        return (0, smithy_client_1.expectString)(entry);
      });
    };
    var deserializeAws_restXmlAnalyticsAndOperator = (output, context) => {
      const contents = {
        Prefix: void 0,
        Tags: void 0
      };
      if (output["Prefix"] !== void 0) {
        contents.Prefix = (0, smithy_client_1.expectString)(output["Prefix"]);
      }
      if (output.Tag === "") {
        contents.Tags = [];
      } else if (output["Tag"] !== void 0) {
        contents.Tags = deserializeAws_restXmlTagSet((0, smithy_client_1.getArrayIfSingleItem)(output["Tag"]), context);
      }
      return contents;
    };
    var deserializeAws_restXmlAnalyticsConfiguration = (output, context) => {
      const contents = {
        Id: void 0,
        Filter: void 0,
        StorageClassAnalysis: void 0
      };
      if (output["Id"] !== void 0) {
        contents.Id = (0, smithy_client_1.expectString)(output["Id"]);
      }
      if (output.Filter === "") {
      } else if (output["Filter"] !== void 0) {
        contents.Filter = deserializeAws_restXmlAnalyticsFilter((0, smithy_client_1.expectUnion)(output["Filter"]), context);
      }
      if (output["StorageClassAnalysis"] !== void 0) {
        contents.StorageClassAnalysis = deserializeAws_restXmlStorageClassAnalysis(output["StorageClassAnalysis"], context);
      }
      return contents;
    };
    var deserializeAws_restXmlAnalyticsConfigurationList = (output, context) => {
      return (output || []).filter((e) => e != null).map((entry) => {
        return deserializeAws_restXmlAnalyticsConfiguration(entry, context);
      });
    };
    var deserializeAws_restXmlAnalyticsExportDestination = (output, context) => {
      const contents = {
        S3BucketDestination: void 0
      };
      if (output["S3BucketDestination"] !== void 0) {
        contents.S3BucketDestination = deserializeAws_restXmlAnalyticsS3BucketDestination(output["S3BucketDestination"], context);
      }
      return contents;
    };
    var deserializeAws_restXmlAnalyticsFilter = (output, context) => {
      if (output["Prefix"] !== void 0) {
        return {
          Prefix: (0, smithy_client_1.expectString)(output["Prefix"])
        };
      }
      if (output["Tag"] !== void 0) {
        return {
          Tag: deserializeAws_restXmlTag(output["Tag"], context)
        };
      }
      if (output["And"] !== void 0) {
        return {
          And: deserializeAws_restXmlAnalyticsAndOperator(output["And"], context)
        };
      }
      return { $unknown: Object.entries(output)[0] };
    };
    var deserializeAws_restXmlAnalyticsS3BucketDestination = (output, context) => {
      const contents = {
        Format: void 0,
        BucketAccountId: void 0,
        Bucket: void 0,
        Prefix: void 0
      };
      if (output["Format"] !== void 0) {
        contents.Format = (0, smithy_client_1.expectString)(output["Format"]);
      }
      if (output["BucketAccountId"] !== void 0) {
        contents.BucketAccountId = (0, smithy_client_1.expectString)(output["BucketAccountId"]);
      }
      if (output["Bucket"] !== void 0) {
        contents.Bucket = (0, smithy_client_1.expectString)(output["Bucket"]);
      }
      if (output["Prefix"] !== void 0) {
        contents.Prefix = (0, smithy_client_1.expectString)(output["Prefix"]);
      }
      return contents;
    };
    var deserializeAws_restXmlBucket = (output, context) => {
      const contents = {
        Name: void 0,
        CreationDate: void 0
      };
      if (output["Name"] !== void 0) {
        contents.Name = (0, smithy_client_1.expectString)(output["Name"]);
      }
      if (output["CreationDate"] !== void 0) {
        contents.CreationDate = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.parseRfc3339DateTimeWithOffset)(output["CreationDate"]));
      }
      return contents;
    };
    var deserializeAws_restXmlBuckets = (output, context) => {
      return (output || []).filter((e) => e != null).map((entry) => {
        return deserializeAws_restXmlBucket(entry, context);
      });
    };
    var deserializeAws_restXmlChecksum = (output, context) => {
      const contents = {
        ChecksumCRC32: void 0,
        ChecksumCRC32C: void 0,
        ChecksumSHA1: void 0,
        ChecksumSHA256: void 0
      };
      if (output["ChecksumCRC32"] !== void 0) {
        contents.ChecksumCRC32 = (0, smithy_client_1.expectString)(output["ChecksumCRC32"]);
      }
      if (output["ChecksumCRC32C"] !== void 0) {
        contents.ChecksumCRC32C = (0, smithy_client_1.expectString)(output["ChecksumCRC32C"]);
      }
      if (output["ChecksumSHA1"] !== void 0) {
        contents.ChecksumSHA1 = (0, smithy_client_1.expectString)(output["ChecksumSHA1"]);
      }
      if (output["ChecksumSHA256"] !== void 0) {
        contents.ChecksumSHA256 = (0, smithy_client_1.expectString)(output["ChecksumSHA256"]);
      }
      return contents;
    };
    var deserializeAws_restXmlChecksumAlgorithmList = (output, context) => {
      return (output || []).filter((e) => e != null).map((entry) => {
        return (0, smithy_client_1.expectString)(entry);
      });
    };
    var deserializeAws_restXmlCommonPrefix = (output, context) => {
      const contents = {
        Prefix: void 0
      };
      if (output["Prefix"] !== void 0) {
        contents.Prefix = (0, smithy_client_1.expectString)(output["Prefix"]);
      }
      return contents;
    };
    var deserializeAws_restXmlCommonPrefixList = (output, context) => {
      return (output || []).filter((e) => e != null).map((entry) => {
        return deserializeAws_restXmlCommonPrefix(entry, context);
      });
    };
    var deserializeAws_restXmlCondition = (output, context) => {
      const contents = {
        HttpErrorCodeReturnedEquals: void 0,
        KeyPrefixEquals: void 0
      };
      if (output["HttpErrorCodeReturnedEquals"] !== void 0) {
        contents.HttpErrorCodeReturnedEquals = (0, smithy_client_1.expectString)(output["HttpErrorCodeReturnedEquals"]);
      }
      if (output["KeyPrefixEquals"] !== void 0) {
        contents.KeyPrefixEquals = (0, smithy_client_1.expectString)(output["KeyPrefixEquals"]);
      }
      return contents;
    };
    var deserializeAws_restXmlContinuationEvent = (output, context) => {
      const contents = {};
      return contents;
    };
    var deserializeAws_restXmlCopyObjectResult = (output, context) => {
      const contents = {
        ETag: void 0,
        LastModified: void 0,
        ChecksumCRC32: void 0,
        ChecksumCRC32C: void 0,
        ChecksumSHA1: void 0,
        ChecksumSHA256: void 0
      };
      if (output["ETag"] !== void 0) {
        contents.ETag = (0, smithy_client_1.expectString)(output["ETag"]);
      }
      if (output["LastModified"] !== void 0) {
        contents.LastModified = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.parseRfc3339DateTimeWithOffset)(output["LastModified"]));
      }
      if (output["ChecksumCRC32"] !== void 0) {
        contents.ChecksumCRC32 = (0, smithy_client_1.expectString)(output["ChecksumCRC32"]);
      }
      if (output["ChecksumCRC32C"] !== void 0) {
        contents.ChecksumCRC32C = (0, smithy_client_1.expectString)(output["ChecksumCRC32C"]);
      }
      if (output["ChecksumSHA1"] !== void 0) {
        contents.ChecksumSHA1 = (0, smithy_client_1.expectString)(output["ChecksumSHA1"]);
      }
      if (output["ChecksumSHA256"] !== void 0) {
        contents.ChecksumSHA256 = (0, smithy_client_1.expectString)(output["ChecksumSHA256"]);
      }
      return contents;
    };
    var deserializeAws_restXmlCopyPartResult = (output, context) => {
      const contents = {
        ETag: void 0,
        LastModified: void 0,
        ChecksumCRC32: void 0,
        ChecksumCRC32C: void 0,
        ChecksumSHA1: void 0,
        ChecksumSHA256: void 0
      };
      if (output["ETag"] !== void 0) {
        contents.ETag = (0, smithy_client_1.expectString)(output["ETag"]);
      }
      if (output["LastModified"] !== void 0) {
        contents.LastModified = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.parseRfc3339DateTimeWithOffset)(output["LastModified"]));
      }
      if (output["ChecksumCRC32"] !== void 0) {
        contents.ChecksumCRC32 = (0, smithy_client_1.expectString)(output["ChecksumCRC32"]);
      }
      if (output["ChecksumCRC32C"] !== void 0) {
        contents.ChecksumCRC32C = (0, smithy_client_1.expectString)(output["ChecksumCRC32C"]);
      }
      if (output["ChecksumSHA1"] !== void 0) {
        contents.ChecksumSHA1 = (0, smithy_client_1.expectString)(output["ChecksumSHA1"]);
      }
      if (output["ChecksumSHA256"] !== void 0) {
        contents.ChecksumSHA256 = (0, smithy_client_1.expectString)(output["ChecksumSHA256"]);
      }
      return contents;
    };
    var deserializeAws_restXmlCORSRule = (output, context) => {
      const contents = {
        ID: void 0,
        AllowedHeaders: void 0,
        AllowedMethods: void 0,
        AllowedOrigins: void 0,
        ExposeHeaders: void 0,
        MaxAgeSeconds: void 0
      };
      if (output["ID"] !== void 0) {
        contents.ID = (0, smithy_client_1.expectString)(output["ID"]);
      }
      if (output.AllowedHeader === "") {
        contents.AllowedHeaders = [];
      } else if (output["AllowedHeader"] !== void 0) {
        contents.AllowedHeaders = deserializeAws_restXmlAllowedHeaders((0, smithy_client_1.getArrayIfSingleItem)(output["AllowedHeader"]), context);
      }
      if (output.AllowedMethod === "") {
        contents.AllowedMethods = [];
      } else if (output["AllowedMethod"] !== void 0) {
        contents.AllowedMethods = deserializeAws_restXmlAllowedMethods((0, smithy_client_1.getArrayIfSingleItem)(output["AllowedMethod"]), context);
      }
      if (output.AllowedOrigin === "") {
        contents.AllowedOrigins = [];
      } else if (output["AllowedOrigin"] !== void 0) {
        contents.AllowedOrigins = deserializeAws_restXmlAllowedOrigins((0, smithy_client_1.getArrayIfSingleItem)(output["AllowedOrigin"]), context);
      }
      if (output.ExposeHeader === "") {
        contents.ExposeHeaders = [];
      } else if (output["ExposeHeader"] !== void 0) {
        contents.ExposeHeaders = deserializeAws_restXmlExposeHeaders((0, smithy_client_1.getArrayIfSingleItem)(output["ExposeHeader"]), context);
      }
      if (output["MaxAgeSeconds"] !== void 0) {
        contents.MaxAgeSeconds = (0, smithy_client_1.strictParseInt32)(output["MaxAgeSeconds"]);
      }
      return contents;
    };
    var deserializeAws_restXmlCORSRules = (output, context) => {
      return (output || []).filter((e) => e != null).map((entry) => {
        return deserializeAws_restXmlCORSRule(entry, context);
      });
    };
    var deserializeAws_restXmlDefaultRetention = (output, context) => {
      const contents = {
        Mode: void 0,
        Days: void 0,
        Years: void 0
      };
      if (output["Mode"] !== void 0) {
        contents.Mode = (0, smithy_client_1.expectString)(output["Mode"]);
      }
      if (output["Days"] !== void 0) {
        contents.Days = (0, smithy_client_1.strictParseInt32)(output["Days"]);
      }
      if (output["Years"] !== void 0) {
        contents.Years = (0, smithy_client_1.strictParseInt32)(output["Years"]);
      }
      return contents;
    };
    var deserializeAws_restXmlDeletedObject = (output, context) => {
      const contents = {
        Key: void 0,
        VersionId: void 0,
        DeleteMarker: void 0,
        DeleteMarkerVersionId: void 0
      };
      if (output["Key"] !== void 0) {
        contents.Key = (0, smithy_client_1.expectString)(output["Key"]);
      }
      if (output["VersionId"] !== void 0) {
        contents.VersionId = (0, smithy_client_1.expectString)(output["VersionId"]);
      }
      if (output["DeleteMarker"] !== void 0) {
        contents.DeleteMarker = (0, smithy_client_1.parseBoolean)(output["DeleteMarker"]);
      }
      if (output["DeleteMarkerVersionId"] !== void 0) {
        contents.DeleteMarkerVersionId = (0, smithy_client_1.expectString)(output["DeleteMarkerVersionId"]);
      }
      return contents;
    };
    var deserializeAws_restXmlDeletedObjects = (output, context) => {
      return (output || []).filter((e) => e != null).map((entry) => {
        return deserializeAws_restXmlDeletedObject(entry, context);
      });
    };
    var deserializeAws_restXmlDeleteMarkerEntry = (output, context) => {
      const contents = {
        Owner: void 0,
        Key: void 0,
        VersionId: void 0,
        IsLatest: void 0,
        LastModified: void 0
      };
      if (output["Owner"] !== void 0) {
        contents.Owner = deserializeAws_restXmlOwner(output["Owner"], context);
      }
      if (output["Key"] !== void 0) {
        contents.Key = (0, smithy_client_1.expectString)(output["Key"]);
      }
      if (output["VersionId"] !== void 0) {
        contents.VersionId = (0, smithy_client_1.expectString)(output["VersionId"]);
      }
      if (output["IsLatest"] !== void 0) {
        contents.IsLatest = (0, smithy_client_1.parseBoolean)(output["IsLatest"]);
      }
      if (output["LastModified"] !== void 0) {
        contents.LastModified = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.parseRfc3339DateTimeWithOffset)(output["LastModified"]));
      }
      return contents;
    };
    var deserializeAws_restXmlDeleteMarkerReplication = (output, context) => {
      const contents = {
        Status: void 0
      };
      if (output["Status"] !== void 0) {
        contents.Status = (0, smithy_client_1.expectString)(output["Status"]);
      }
      return contents;
    };
    var deserializeAws_restXmlDeleteMarkers = (output, context) => {
      return (output || []).filter((e) => e != null).map((entry) => {
        return deserializeAws_restXmlDeleteMarkerEntry(entry, context);
      });
    };
    var deserializeAws_restXmlDestination = (output, context) => {
      const contents = {
        Bucket: void 0,
        Account: void 0,
        StorageClass: void 0,
        AccessControlTranslation: void 0,
        EncryptionConfiguration: void 0,
        ReplicationTime: void 0,
        Metrics: void 0
      };
      if (output["Bucket"] !== void 0) {
        contents.Bucket = (0, smithy_client_1.expectString)(output["Bucket"]);
      }
      if (output["Account"] !== void 0) {
        contents.Account = (0, smithy_client_1.expectString)(output["Account"]);
      }
      if (output["StorageClass"] !== void 0) {
        contents.StorageClass = (0, smithy_client_1.expectString)(output["StorageClass"]);
      }
      if (output["AccessControlTranslation"] !== void 0) {
        contents.AccessControlTranslation = deserializeAws_restXmlAccessControlTranslation(output["AccessControlTranslation"], context);
      }
      if (output["EncryptionConfiguration"] !== void 0) {
        contents.EncryptionConfiguration = deserializeAws_restXmlEncryptionConfiguration(output["EncryptionConfiguration"], context);
      }
      if (output["ReplicationTime"] !== void 0) {
        contents.ReplicationTime = deserializeAws_restXmlReplicationTime(output["ReplicationTime"], context);
      }
      if (output["Metrics"] !== void 0) {
        contents.Metrics = deserializeAws_restXmlMetrics(output["Metrics"], context);
      }
      return contents;
    };
    var deserializeAws_restXmlEncryptionConfiguration = (output, context) => {
      const contents = {
        ReplicaKmsKeyID: void 0
      };
      if (output["ReplicaKmsKeyID"] !== void 0) {
        contents.ReplicaKmsKeyID = (0, smithy_client_1.expectString)(output["ReplicaKmsKeyID"]);
      }
      return contents;
    };
    var deserializeAws_restXmlEndEvent = (output, context) => {
      const contents = {};
      return contents;
    };
    var deserializeAws_restXml_Error = (output, context) => {
      const contents = {
        Key: void 0,
        VersionId: void 0,
        Code: void 0,
        Message: void 0
      };
      if (output["Key"] !== void 0) {
        contents.Key = (0, smithy_client_1.expectString)(output["Key"]);
      }
      if (output["VersionId"] !== void 0) {
        contents.VersionId = (0, smithy_client_1.expectString)(output["VersionId"]);
      }
      if (output["Code"] !== void 0) {
        contents.Code = (0, smithy_client_1.expectString)(output["Code"]);
      }
      if (output["Message"] !== void 0) {
        contents.Message = (0, smithy_client_1.expectString)(output["Message"]);
      }
      return contents;
    };
    var deserializeAws_restXmlErrorDocument = (output, context) => {
      const contents = {
        Key: void 0
      };
      if (output["Key"] !== void 0) {
        contents.Key = (0, smithy_client_1.expectString)(output["Key"]);
      }
      return contents;
    };
    var deserializeAws_restXmlErrors = (output, context) => {
      return (output || []).filter((e) => e != null).map((entry) => {
        return deserializeAws_restXml_Error(entry, context);
      });
    };
    var deserializeAws_restXmlEventBridgeConfiguration = (output, context) => {
      const contents = {};
      return contents;
    };
    var deserializeAws_restXmlEventList = (output, context) => {
      return (output || []).filter((e) => e != null).map((entry) => {
        return (0, smithy_client_1.expectString)(entry);
      });
    };
    var deserializeAws_restXmlExistingObjectReplication = (output, context) => {
      const contents = {
        Status: void 0
      };
      if (output["Status"] !== void 0) {
        contents.Status = (0, smithy_client_1.expectString)(output["Status"]);
      }
      return contents;
    };
    var deserializeAws_restXmlExposeHeaders = (output, context) => {
      return (output || []).filter((e) => e != null).map((entry) => {
        return (0, smithy_client_1.expectString)(entry);
      });
    };
    var deserializeAws_restXmlFilterRule = (output, context) => {
      const contents = {
        Name: void 0,
        Value: void 0
      };
      if (output["Name"] !== void 0) {
        contents.Name = (0, smithy_client_1.expectString)(output["Name"]);
      }
      if (output["Value"] !== void 0) {
        contents.Value = (0, smithy_client_1.expectString)(output["Value"]);
      }
      return contents;
    };
    var deserializeAws_restXmlFilterRuleList = (output, context) => {
      return (output || []).filter((e) => e != null).map((entry) => {
        return deserializeAws_restXmlFilterRule(entry, context);
      });
    };
    var deserializeAws_restXmlGetObjectAttributesParts = (output, context) => {
      const contents = {
        TotalPartsCount: void 0,
        PartNumberMarker: void 0,
        NextPartNumberMarker: void 0,
        MaxParts: void 0,
        IsTruncated: void 0,
        Parts: void 0
      };
      if (output["PartsCount"] !== void 0) {
        contents.TotalPartsCount = (0, smithy_client_1.strictParseInt32)(output["PartsCount"]);
      }
      if (output["PartNumberMarker"] !== void 0) {
        contents.PartNumberMarker = (0, smithy_client_1.expectString)(output["PartNumberMarker"]);
      }
      if (output["NextPartNumberMarker"] !== void 0) {
        contents.NextPartNumberMarker = (0, smithy_client_1.expectString)(output["NextPartNumberMarker"]);
      }
      if (output["MaxParts"] !== void 0) {
        contents.MaxParts = (0, smithy_client_1.strictParseInt32)(output["MaxParts"]);
      }
      if (output["IsTruncated"] !== void 0) {
        contents.IsTruncated = (0, smithy_client_1.parseBoolean)(output["IsTruncated"]);
      }
      if (output.Part === "") {
        contents.Parts = [];
      } else if (output["Part"] !== void 0) {
        contents.Parts = deserializeAws_restXmlPartsList((0, smithy_client_1.getArrayIfSingleItem)(output["Part"]), context);
      }
      return contents;
    };
    var deserializeAws_restXmlGrant = (output, context) => {
      const contents = {
        Grantee: void 0,
        Permission: void 0
      };
      if (output["Grantee"] !== void 0) {
        contents.Grantee = deserializeAws_restXmlGrantee(output["Grantee"], context);
      }
      if (output["Permission"] !== void 0) {
        contents.Permission = (0, smithy_client_1.expectString)(output["Permission"]);
      }
      return contents;
    };
    var deserializeAws_restXmlGrantee = (output, context) => {
      const contents = {
        DisplayName: void 0,
        EmailAddress: void 0,
        ID: void 0,
        URI: void 0,
        Type: void 0
      };
      if (output["DisplayName"] !== void 0) {
        contents.DisplayName = (0, smithy_client_1.expectString)(output["DisplayName"]);
      }
      if (output["EmailAddress"] !== void 0) {
        contents.EmailAddress = (0, smithy_client_1.expectString)(output["EmailAddress"]);
      }
      if (output["ID"] !== void 0) {
        contents.ID = (0, smithy_client_1.expectString)(output["ID"]);
      }
      if (output["URI"] !== void 0) {
        contents.URI = (0, smithy_client_1.expectString)(output["URI"]);
      }
      if (output["xsi:type"] !== void 0) {
        contents.Type = (0, smithy_client_1.expectString)(output["xsi:type"]);
      }
      return contents;
    };
    var deserializeAws_restXmlGrants = (output, context) => {
      return (output || []).filter((e) => e != null).map((entry) => {
        return deserializeAws_restXmlGrant(entry, context);
      });
    };
    var deserializeAws_restXmlIndexDocument = (output, context) => {
      const contents = {
        Suffix: void 0
      };
      if (output["Suffix"] !== void 0) {
        contents.Suffix = (0, smithy_client_1.expectString)(output["Suffix"]);
      }
      return contents;
    };
    var deserializeAws_restXmlInitiator = (output, context) => {
      const contents = {
        ID: void 0,
        DisplayName: void 0
      };
      if (output["ID"] !== void 0) {
        contents.ID = (0, smithy_client_1.expectString)(output["ID"]);
      }
      if (output["DisplayName"] !== void 0) {
        contents.DisplayName = (0, smithy_client_1.expectString)(output["DisplayName"]);
      }
      return contents;
    };
    var deserializeAws_restXmlIntelligentTieringAndOperator = (output, context) => {
      const contents = {
        Prefix: void 0,
        Tags: void 0
      };
      if (output["Prefix"] !== void 0) {
        contents.Prefix = (0, smithy_client_1.expectString)(output["Prefix"]);
      }
      if (output.Tag === "") {
        contents.Tags = [];
      } else if (output["Tag"] !== void 0) {
        contents.Tags = deserializeAws_restXmlTagSet((0, smithy_client_1.getArrayIfSingleItem)(output["Tag"]), context);
      }
      return contents;
    };
    var deserializeAws_restXmlIntelligentTieringConfiguration = (output, context) => {
      const contents = {
        Id: void 0,
        Filter: void 0,
        Status: void 0,
        Tierings: void 0
      };
      if (output["Id"] !== void 0) {
        contents.Id = (0, smithy_client_1.expectString)(output["Id"]);
      }
      if (output["Filter"] !== void 0) {
        contents.Filter = deserializeAws_restXmlIntelligentTieringFilter(output["Filter"], context);
      }
      if (output["Status"] !== void 0) {
        contents.Status = (0, smithy_client_1.expectString)(output["Status"]);
      }
      if (output.Tiering === "") {
        contents.Tierings = [];
      } else if (output["Tiering"] !== void 0) {
        contents.Tierings = deserializeAws_restXmlTieringList((0, smithy_client_1.getArrayIfSingleItem)(output["Tiering"]), context);
      }
      return contents;
    };
    var deserializeAws_restXmlIntelligentTieringConfigurationList = (output, context) => {
      return (output || []).filter((e) => e != null).map((entry) => {
        return deserializeAws_restXmlIntelligentTieringConfiguration(entry, context);
      });
    };
    var deserializeAws_restXmlIntelligentTieringFilter = (output, context) => {
      const contents = {
        Prefix: void 0,
        Tag: void 0,
        And: void 0
      };
      if (output["Prefix"] !== void 0) {
        contents.Prefix = (0, smithy_client_1.expectString)(output["Prefix"]);
      }
      if (output["Tag"] !== void 0) {
        contents.Tag = deserializeAws_restXmlTag(output["Tag"], context);
      }
      if (output["And"] !== void 0) {
        contents.And = deserializeAws_restXmlIntelligentTieringAndOperator(output["And"], context);
      }
      return contents;
    };
    var deserializeAws_restXmlInventoryConfiguration = (output, context) => {
      const contents = {
        Destination: void 0,
        IsEnabled: void 0,
        Filter: void 0,
        Id: void 0,
        IncludedObjectVersions: void 0,
        OptionalFields: void 0,
        Schedule: void 0
      };
      if (output["Destination"] !== void 0) {
        contents.Destination = deserializeAws_restXmlInventoryDestination(output["Destination"], context);
      }
      if (output["IsEnabled"] !== void 0) {
        contents.IsEnabled = (0, smithy_client_1.parseBoolean)(output["IsEnabled"]);
      }
      if (output["Filter"] !== void 0) {
        contents.Filter = deserializeAws_restXmlInventoryFilter(output["Filter"], context);
      }
      if (output["Id"] !== void 0) {
        contents.Id = (0, smithy_client_1.expectString)(output["Id"]);
      }
      if (output["IncludedObjectVersions"] !== void 0) {
        contents.IncludedObjectVersions = (0, smithy_client_1.expectString)(output["IncludedObjectVersions"]);
      }
      if (output.OptionalFields === "") {
        contents.OptionalFields = [];
      } else if (output["OptionalFields"] !== void 0 && output["OptionalFields"]["Field"] !== void 0) {
        contents.OptionalFields = deserializeAws_restXmlInventoryOptionalFields((0, smithy_client_1.getArrayIfSingleItem)(output["OptionalFields"]["Field"]), context);
      }
      if (output["Schedule"] !== void 0) {
        contents.Schedule = deserializeAws_restXmlInventorySchedule(output["Schedule"], context);
      }
      return contents;
    };
    var deserializeAws_restXmlInventoryConfigurationList = (output, context) => {
      return (output || []).filter((e) => e != null).map((entry) => {
        return deserializeAws_restXmlInventoryConfiguration(entry, context);
      });
    };
    var deserializeAws_restXmlInventoryDestination = (output, context) => {
      const contents = {
        S3BucketDestination: void 0
      };
      if (output["S3BucketDestination"] !== void 0) {
        contents.S3BucketDestination = deserializeAws_restXmlInventoryS3BucketDestination(output["S3BucketDestination"], context);
      }
      return contents;
    };
    var deserializeAws_restXmlInventoryEncryption = (output, context) => {
      const contents = {
        SSES3: void 0,
        SSEKMS: void 0
      };
      if (output["SSE-S3"] !== void 0) {
        contents.SSES3 = deserializeAws_restXmlSSES3(output["SSE-S3"], context);
      }
      if (output["SSE-KMS"] !== void 0) {
        contents.SSEKMS = deserializeAws_restXmlSSEKMS(output["SSE-KMS"], context);
      }
      return contents;
    };
    var deserializeAws_restXmlInventoryFilter = (output, context) => {
      const contents = {
        Prefix: void 0
      };
      if (output["Prefix"] !== void 0) {
        contents.Prefix = (0, smithy_client_1.expectString)(output["Prefix"]);
      }
      return contents;
    };
    var deserializeAws_restXmlInventoryOptionalFields = (output, context) => {
      return (output || []).filter((e) => e != null).map((entry) => {
        return (0, smithy_client_1.expectString)(entry);
      });
    };
    var deserializeAws_restXmlInventoryS3BucketDestination = (output, context) => {
      const contents = {
        AccountId: void 0,
        Bucket: void 0,
        Format: void 0,
        Prefix: void 0,
        Encryption: void 0
      };
      if (output["AccountId"] !== void 0) {
        contents.AccountId = (0, smithy_client_1.expectString)(output["AccountId"]);
      }
      if (output["Bucket"] !== void 0) {
        contents.Bucket = (0, smithy_client_1.expectString)(output["Bucket"]);
      }
      if (output["Format"] !== void 0) {
        contents.Format = (0, smithy_client_1.expectString)(output["Format"]);
      }
      if (output["Prefix"] !== void 0) {
        contents.Prefix = (0, smithy_client_1.expectString)(output["Prefix"]);
      }
      if (output["Encryption"] !== void 0) {
        contents.Encryption = deserializeAws_restXmlInventoryEncryption(output["Encryption"], context);
      }
      return contents;
    };
    var deserializeAws_restXmlInventorySchedule = (output, context) => {
      const contents = {
        Frequency: void 0
      };
      if (output["Frequency"] !== void 0) {
        contents.Frequency = (0, smithy_client_1.expectString)(output["Frequency"]);
      }
      return contents;
    };
    var deserializeAws_restXmlLambdaFunctionConfiguration = (output, context) => {
      const contents = {
        Id: void 0,
        LambdaFunctionArn: void 0,
        Events: void 0,
        Filter: void 0
      };
      if (output["Id"] !== void 0) {
        contents.Id = (0, smithy_client_1.expectString)(output["Id"]);
      }
      if (output["CloudFunction"] !== void 0) {
        contents.LambdaFunctionArn = (0, smithy_client_1.expectString)(output["CloudFunction"]);
      }
      if (output.Event === "") {
        contents.Events = [];
      } else if (output["Event"] !== void 0) {
        contents.Events = deserializeAws_restXmlEventList((0, smithy_client_1.getArrayIfSingleItem)(output["Event"]), context);
      }
      if (output["Filter"] !== void 0) {
        contents.Filter = deserializeAws_restXmlNotificationConfigurationFilter(output["Filter"], context);
      }
      return contents;
    };
    var deserializeAws_restXmlLambdaFunctionConfigurationList = (output, context) => {
      return (output || []).filter((e) => e != null).map((entry) => {
        return deserializeAws_restXmlLambdaFunctionConfiguration(entry, context);
      });
    };
    var deserializeAws_restXmlLifecycleExpiration = (output, context) => {
      const contents = {
        Date: void 0,
        Days: void 0,
        ExpiredObjectDeleteMarker: void 0
      };
      if (output["Date"] !== void 0) {
        contents.Date = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.parseRfc3339DateTimeWithOffset)(output["Date"]));
      }
      if (output["Days"] !== void 0) {
        contents.Days = (0, smithy_client_1.strictParseInt32)(output["Days"]);
      }
      if (output["ExpiredObjectDeleteMarker"] !== void 0) {
        contents.ExpiredObjectDeleteMarker = (0, smithy_client_1.parseBoolean)(output["ExpiredObjectDeleteMarker"]);
      }
      return contents;
    };
    var deserializeAws_restXmlLifecycleRule = (output, context) => {
      const contents = {
        Expiration: void 0,
        ID: void 0,
        Prefix: void 0,
        Filter: void 0,
        Status: void 0,
        Transitions: void 0,
        NoncurrentVersionTransitions: void 0,
        NoncurrentVersionExpiration: void 0,
        AbortIncompleteMultipartUpload: void 0
      };
      if (output["Expiration"] !== void 0) {
        contents.Expiration = deserializeAws_restXmlLifecycleExpiration(output["Expiration"], context);
      }
      if (output["ID"] !== void 0) {
        contents.ID = (0, smithy_client_1.expectString)(output["ID"]);
      }
      if (output["Prefix"] !== void 0) {
        contents.Prefix = (0, smithy_client_1.expectString)(output["Prefix"]);
      }
      if (output.Filter === "") {
      } else if (output["Filter"] !== void 0) {
        contents.Filter = deserializeAws_restXmlLifecycleRuleFilter((0, smithy_client_1.expectUnion)(output["Filter"]), context);
      }
      if (output["Status"] !== void 0) {
        contents.Status = (0, smithy_client_1.expectString)(output["Status"]);
      }
      if (output.Transition === "") {
        contents.Transitions = [];
      } else if (output["Transition"] !== void 0) {
        contents.Transitions = deserializeAws_restXmlTransitionList((0, smithy_client_1.getArrayIfSingleItem)(output["Transition"]), context);
      }
      if (output.NoncurrentVersionTransition === "") {
        contents.NoncurrentVersionTransitions = [];
      } else if (output["NoncurrentVersionTransition"] !== void 0) {
        contents.NoncurrentVersionTransitions = deserializeAws_restXmlNoncurrentVersionTransitionList((0, smithy_client_1.getArrayIfSingleItem)(output["NoncurrentVersionTransition"]), context);
      }
      if (output["NoncurrentVersionExpiration"] !== void 0) {
        contents.NoncurrentVersionExpiration = deserializeAws_restXmlNoncurrentVersionExpiration(output["NoncurrentVersionExpiration"], context);
      }
      if (output["AbortIncompleteMultipartUpload"] !== void 0) {
        contents.AbortIncompleteMultipartUpload = deserializeAws_restXmlAbortIncompleteMultipartUpload(output["AbortIncompleteMultipartUpload"], context);
      }
      return contents;
    };
    var deserializeAws_restXmlLifecycleRuleAndOperator = (output, context) => {
      const contents = {
        Prefix: void 0,
        Tags: void 0,
        ObjectSizeGreaterThan: void 0,
        ObjectSizeLessThan: void 0
      };
      if (output["Prefix"] !== void 0) {
        contents.Prefix = (0, smithy_client_1.expectString)(output["Prefix"]);
      }
      if (output.Tag === "") {
        contents.Tags = [];
      } else if (output["Tag"] !== void 0) {
        contents.Tags = deserializeAws_restXmlTagSet((0, smithy_client_1.getArrayIfSingleItem)(output["Tag"]), context);
      }
      if (output["ObjectSizeGreaterThan"] !== void 0) {
        contents.ObjectSizeGreaterThan = (0, smithy_client_1.strictParseLong)(output["ObjectSizeGreaterThan"]);
      }
      if (output["ObjectSizeLessThan"] !== void 0) {
        contents.ObjectSizeLessThan = (0, smithy_client_1.strictParseLong)(output["ObjectSizeLessThan"]);
      }
      return contents;
    };
    var deserializeAws_restXmlLifecycleRuleFilter = (output, context) => {
      if (output["Prefix"] !== void 0) {
        return {
          Prefix: (0, smithy_client_1.expectString)(output["Prefix"])
        };
      }
      if (output["Tag"] !== void 0) {
        return {
          Tag: deserializeAws_restXmlTag(output["Tag"], context)
        };
      }
      if (output["ObjectSizeGreaterThan"] !== void 0) {
        return {
          ObjectSizeGreaterThan: (0, smithy_client_1.strictParseLong)(output["ObjectSizeGreaterThan"])
        };
      }
      if (output["ObjectSizeLessThan"] !== void 0) {
        return {
          ObjectSizeLessThan: (0, smithy_client_1.strictParseLong)(output["ObjectSizeLessThan"])
        };
      }
      if (output["And"] !== void 0) {
        return {
          And: deserializeAws_restXmlLifecycleRuleAndOperator(output["And"], context)
        };
      }
      return { $unknown: Object.entries(output)[0] };
    };
    var deserializeAws_restXmlLifecycleRules = (output, context) => {
      return (output || []).filter((e) => e != null).map((entry) => {
        return deserializeAws_restXmlLifecycleRule(entry, context);
      });
    };
    var deserializeAws_restXmlLoggingEnabled = (output, context) => {
      const contents = {
        TargetBucket: void 0,
        TargetGrants: void 0,
        TargetPrefix: void 0
      };
      if (output["TargetBucket"] !== void 0) {
        contents.TargetBucket = (0, smithy_client_1.expectString)(output["TargetBucket"]);
      }
      if (output.TargetGrants === "") {
        contents.TargetGrants = [];
      } else if (output["TargetGrants"] !== void 0 && output["TargetGrants"]["Grant"] !== void 0) {
        contents.TargetGrants = deserializeAws_restXmlTargetGrants((0, smithy_client_1.getArrayIfSingleItem)(output["TargetGrants"]["Grant"]), context);
      }
      if (output["TargetPrefix"] !== void 0) {
        contents.TargetPrefix = (0, smithy_client_1.expectString)(output["TargetPrefix"]);
      }
      return contents;
    };
    var deserializeAws_restXmlMetrics = (output, context) => {
      const contents = {
        Status: void 0,
        EventThreshold: void 0
      };
      if (output["Status"] !== void 0) {
        contents.Status = (0, smithy_client_1.expectString)(output["Status"]);
      }
      if (output["EventThreshold"] !== void 0) {
        contents.EventThreshold = deserializeAws_restXmlReplicationTimeValue(output["EventThreshold"], context);
      }
      return contents;
    };
    var deserializeAws_restXmlMetricsAndOperator = (output, context) => {
      const contents = {
        Prefix: void 0,
        Tags: void 0,
        AccessPointArn: void 0
      };
      if (output["Prefix"] !== void 0) {
        contents.Prefix = (0, smithy_client_1.expectString)(output["Prefix"]);
      }
      if (output.Tag === "") {
        contents.Tags = [];
      } else if (output["Tag"] !== void 0) {
        contents.Tags = deserializeAws_restXmlTagSet((0, smithy_client_1.getArrayIfSingleItem)(output["Tag"]), context);
      }
      if (output["AccessPointArn"] !== void 0) {
        contents.AccessPointArn = (0, smithy_client_1.expectString)(output["AccessPointArn"]);
      }
      return contents;
    };
    var deserializeAws_restXmlMetricsConfiguration = (output, context) => {
      const contents = {
        Id: void 0,
        Filter: void 0
      };
      if (output["Id"] !== void 0) {
        contents.Id = (0, smithy_client_1.expectString)(output["Id"]);
      }
      if (output.Filter === "") {
      } else if (output["Filter"] !== void 0) {
        contents.Filter = deserializeAws_restXmlMetricsFilter((0, smithy_client_1.expectUnion)(output["Filter"]), context);
      }
      return contents;
    };
    var deserializeAws_restXmlMetricsConfigurationList = (output, context) => {
      return (output || []).filter((e) => e != null).map((entry) => {
        return deserializeAws_restXmlMetricsConfiguration(entry, context);
      });
    };
    var deserializeAws_restXmlMetricsFilter = (output, context) => {
      if (output["Prefix"] !== void 0) {
        return {
          Prefix: (0, smithy_client_1.expectString)(output["Prefix"])
        };
      }
      if (output["Tag"] !== void 0) {
        return {
          Tag: deserializeAws_restXmlTag(output["Tag"], context)
        };
      }
      if (output["AccessPointArn"] !== void 0) {
        return {
          AccessPointArn: (0, smithy_client_1.expectString)(output["AccessPointArn"])
        };
      }
      if (output["And"] !== void 0) {
        return {
          And: deserializeAws_restXmlMetricsAndOperator(output["And"], context)
        };
      }
      return { $unknown: Object.entries(output)[0] };
    };
    var deserializeAws_restXmlMultipartUpload = (output, context) => {
      const contents = {
        UploadId: void 0,
        Key: void 0,
        Initiated: void 0,
        StorageClass: void 0,
        Owner: void 0,
        Initiator: void 0,
        ChecksumAlgorithm: void 0
      };
      if (output["UploadId"] !== void 0) {
        contents.UploadId = (0, smithy_client_1.expectString)(output["UploadId"]);
      }
      if (output["Key"] !== void 0) {
        contents.Key = (0, smithy_client_1.expectString)(output["Key"]);
      }
      if (output["Initiated"] !== void 0) {
        contents.Initiated = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.parseRfc3339DateTimeWithOffset)(output["Initiated"]));
      }
      if (output["StorageClass"] !== void 0) {
        contents.StorageClass = (0, smithy_client_1.expectString)(output["StorageClass"]);
      }
      if (output["Owner"] !== void 0) {
        contents.Owner = deserializeAws_restXmlOwner(output["Owner"], context);
      }
      if (output["Initiator"] !== void 0) {
        contents.Initiator = deserializeAws_restXmlInitiator(output["Initiator"], context);
      }
      if (output["ChecksumAlgorithm"] !== void 0) {
        contents.ChecksumAlgorithm = (0, smithy_client_1.expectString)(output["ChecksumAlgorithm"]);
      }
      return contents;
    };
    var deserializeAws_restXmlMultipartUploadList = (output, context) => {
      return (output || []).filter((e) => e != null).map((entry) => {
        return deserializeAws_restXmlMultipartUpload(entry, context);
      });
    };
    var deserializeAws_restXmlNoncurrentVersionExpiration = (output, context) => {
      const contents = {
        NoncurrentDays: void 0,
        NewerNoncurrentVersions: void 0
      };
      if (output["NoncurrentDays"] !== void 0) {
        contents.NoncurrentDays = (0, smithy_client_1.strictParseInt32)(output["NoncurrentDays"]);
      }
      if (output["NewerNoncurrentVersions"] !== void 0) {
        contents.NewerNoncurrentVersions = (0, smithy_client_1.strictParseInt32)(output["NewerNoncurrentVersions"]);
      }
      return contents;
    };
    var deserializeAws_restXmlNoncurrentVersionTransition = (output, context) => {
      const contents = {
        NoncurrentDays: void 0,
        StorageClass: void 0,
        NewerNoncurrentVersions: void 0
      };
      if (output["NoncurrentDays"] !== void 0) {
        contents.NoncurrentDays = (0, smithy_client_1.strictParseInt32)(output["NoncurrentDays"]);
      }
      if (output["StorageClass"] !== void 0) {
        contents.StorageClass = (0, smithy_client_1.expectString)(output["StorageClass"]);
      }
      if (output["NewerNoncurrentVersions"] !== void 0) {
        contents.NewerNoncurrentVersions = (0, smithy_client_1.strictParseInt32)(output["NewerNoncurrentVersions"]);
      }
      return contents;
    };
    var deserializeAws_restXmlNoncurrentVersionTransitionList = (output, context) => {
      return (output || []).filter((e) => e != null).map((entry) => {
        return deserializeAws_restXmlNoncurrentVersionTransition(entry, context);
      });
    };
    var deserializeAws_restXmlNotificationConfigurationFilter = (output, context) => {
      const contents = {
        Key: void 0
      };
      if (output["S3Key"] !== void 0) {
        contents.Key = deserializeAws_restXmlS3KeyFilter(output["S3Key"], context);
      }
      return contents;
    };
    var deserializeAws_restXml_Object = (output, context) => {
      const contents = {
        Key: void 0,
        LastModified: void 0,
        ETag: void 0,
        ChecksumAlgorithm: void 0,
        Size: void 0,
        StorageClass: void 0,
        Owner: void 0
      };
      if (output["Key"] !== void 0) {
        contents.Key = (0, smithy_client_1.expectString)(output["Key"]);
      }
      if (output["LastModified"] !== void 0) {
        contents.LastModified = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.parseRfc3339DateTimeWithOffset)(output["LastModified"]));
      }
      if (output["ETag"] !== void 0) {
        contents.ETag = (0, smithy_client_1.expectString)(output["ETag"]);
      }
      if (output.ChecksumAlgorithm === "") {
        contents.ChecksumAlgorithm = [];
      } else if (output["ChecksumAlgorithm"] !== void 0) {
        contents.ChecksumAlgorithm = deserializeAws_restXmlChecksumAlgorithmList((0, smithy_client_1.getArrayIfSingleItem)(output["ChecksumAlgorithm"]), context);
      }
      if (output["Size"] !== void 0) {
        contents.Size = (0, smithy_client_1.strictParseLong)(output["Size"]);
      }
      if (output["StorageClass"] !== void 0) {
        contents.StorageClass = (0, smithy_client_1.expectString)(output["StorageClass"]);
      }
      if (output["Owner"] !== void 0) {
        contents.Owner = deserializeAws_restXmlOwner(output["Owner"], context);
      }
      return contents;
    };
    var deserializeAws_restXmlObjectList = (output, context) => {
      return (output || []).filter((e) => e != null).map((entry) => {
        return deserializeAws_restXml_Object(entry, context);
      });
    };
    var deserializeAws_restXmlObjectLockConfiguration = (output, context) => {
      const contents = {
        ObjectLockEnabled: void 0,
        Rule: void 0
      };
      if (output["ObjectLockEnabled"] !== void 0) {
        contents.ObjectLockEnabled = (0, smithy_client_1.expectString)(output["ObjectLockEnabled"]);
      }
      if (output["Rule"] !== void 0) {
        contents.Rule = deserializeAws_restXmlObjectLockRule(output["Rule"], context);
      }
      return contents;
    };
    var deserializeAws_restXmlObjectLockLegalHold = (output, context) => {
      const contents = {
        Status: void 0
      };
      if (output["Status"] !== void 0) {
        contents.Status = (0, smithy_client_1.expectString)(output["Status"]);
      }
      return contents;
    };
    var deserializeAws_restXmlObjectLockRetention = (output, context) => {
      const contents = {
        Mode: void 0,
        RetainUntilDate: void 0
      };
      if (output["Mode"] !== void 0) {
        contents.Mode = (0, smithy_client_1.expectString)(output["Mode"]);
      }
      if (output["RetainUntilDate"] !== void 0) {
        contents.RetainUntilDate = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.parseRfc3339DateTimeWithOffset)(output["RetainUntilDate"]));
      }
      return contents;
    };
    var deserializeAws_restXmlObjectLockRule = (output, context) => {
      const contents = {
        DefaultRetention: void 0
      };
      if (output["DefaultRetention"] !== void 0) {
        contents.DefaultRetention = deserializeAws_restXmlDefaultRetention(output["DefaultRetention"], context);
      }
      return contents;
    };
    var deserializeAws_restXmlObjectPart = (output, context) => {
      const contents = {
        PartNumber: void 0,
        Size: void 0,
        ChecksumCRC32: void 0,
        ChecksumCRC32C: void 0,
        ChecksumSHA1: void 0,
        ChecksumSHA256: void 0
      };
      if (output["PartNumber"] !== void 0) {
        contents.PartNumber = (0, smithy_client_1.strictParseInt32)(output["PartNumber"]);
      }
      if (output["Size"] !== void 0) {
        contents.Size = (0, smithy_client_1.strictParseLong)(output["Size"]);
      }
      if (output["ChecksumCRC32"] !== void 0) {
        contents.ChecksumCRC32 = (0, smithy_client_1.expectString)(output["ChecksumCRC32"]);
      }
      if (output["ChecksumCRC32C"] !== void 0) {
        contents.ChecksumCRC32C = (0, smithy_client_1.expectString)(output["ChecksumCRC32C"]);
      }
      if (output["ChecksumSHA1"] !== void 0) {
        contents.ChecksumSHA1 = (0, smithy_client_1.expectString)(output["ChecksumSHA1"]);
      }
      if (output["ChecksumSHA256"] !== void 0) {
        contents.ChecksumSHA256 = (0, smithy_client_1.expectString)(output["ChecksumSHA256"]);
      }
      return contents;
    };
    var deserializeAws_restXmlObjectVersion = (output, context) => {
      const contents = {
        ETag: void 0,
        ChecksumAlgorithm: void 0,
        Size: void 0,
        StorageClass: void 0,
        Key: void 0,
        VersionId: void 0,
        IsLatest: void 0,
        LastModified: void 0,
        Owner: void 0
      };
      if (output["ETag"] !== void 0) {
        contents.ETag = (0, smithy_client_1.expectString)(output["ETag"]);
      }
      if (output.ChecksumAlgorithm === "") {
        contents.ChecksumAlgorithm = [];
      } else if (output["ChecksumAlgorithm"] !== void 0) {
        contents.ChecksumAlgorithm = deserializeAws_restXmlChecksumAlgorithmList((0, smithy_client_1.getArrayIfSingleItem)(output["ChecksumAlgorithm"]), context);
      }
      if (output["Size"] !== void 0) {
        contents.Size = (0, smithy_client_1.strictParseLong)(output["Size"]);
      }
      if (output["StorageClass"] !== void 0) {
        contents.StorageClass = (0, smithy_client_1.expectString)(output["StorageClass"]);
      }
      if (output["Key"] !== void 0) {
        contents.Key = (0, smithy_client_1.expectString)(output["Key"]);
      }
      if (output["VersionId"] !== void 0) {
        contents.VersionId = (0, smithy_client_1.expectString)(output["VersionId"]);
      }
      if (output["IsLatest"] !== void 0) {
        contents.IsLatest = (0, smithy_client_1.parseBoolean)(output["IsLatest"]);
      }
      if (output["LastModified"] !== void 0) {
        contents.LastModified = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.parseRfc3339DateTimeWithOffset)(output["LastModified"]));
      }
      if (output["Owner"] !== void 0) {
        contents.Owner = deserializeAws_restXmlOwner(output["Owner"], context);
      }
      return contents;
    };
    var deserializeAws_restXmlObjectVersionList = (output, context) => {
      return (output || []).filter((e) => e != null).map((entry) => {
        return deserializeAws_restXmlObjectVersion(entry, context);
      });
    };
    var deserializeAws_restXmlOwner = (output, context) => {
      const contents = {
        DisplayName: void 0,
        ID: void 0
      };
      if (output["DisplayName"] !== void 0) {
        contents.DisplayName = (0, smithy_client_1.expectString)(output["DisplayName"]);
      }
      if (output["ID"] !== void 0) {
        contents.ID = (0, smithy_client_1.expectString)(output["ID"]);
      }
      return contents;
    };
    var deserializeAws_restXmlOwnershipControls = (output, context) => {
      const contents = {
        Rules: void 0
      };
      if (output.Rule === "") {
        contents.Rules = [];
      } else if (output["Rule"] !== void 0) {
        contents.Rules = deserializeAws_restXmlOwnershipControlsRules((0, smithy_client_1.getArrayIfSingleItem)(output["Rule"]), context);
      }
      return contents;
    };
    var deserializeAws_restXmlOwnershipControlsRule = (output, context) => {
      const contents = {
        ObjectOwnership: void 0
      };
      if (output["ObjectOwnership"] !== void 0) {
        contents.ObjectOwnership = (0, smithy_client_1.expectString)(output["ObjectOwnership"]);
      }
      return contents;
    };
    var deserializeAws_restXmlOwnershipControlsRules = (output, context) => {
      return (output || []).filter((e) => e != null).map((entry) => {
        return deserializeAws_restXmlOwnershipControlsRule(entry, context);
      });
    };
    var deserializeAws_restXmlPart = (output, context) => {
      const contents = {
        PartNumber: void 0,
        LastModified: void 0,
        ETag: void 0,
        Size: void 0,
        ChecksumCRC32: void 0,
        ChecksumCRC32C: void 0,
        ChecksumSHA1: void 0,
        ChecksumSHA256: void 0
      };
      if (output["PartNumber"] !== void 0) {
        contents.PartNumber = (0, smithy_client_1.strictParseInt32)(output["PartNumber"]);
      }
      if (output["LastModified"] !== void 0) {
        contents.LastModified = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.parseRfc3339DateTimeWithOffset)(output["LastModified"]));
      }
      if (output["ETag"] !== void 0) {
        contents.ETag = (0, smithy_client_1.expectString)(output["ETag"]);
      }
      if (output["Size"] !== void 0) {
        contents.Size = (0, smithy_client_1.strictParseLong)(output["Size"]);
      }
      if (output["ChecksumCRC32"] !== void 0) {
        contents.ChecksumCRC32 = (0, smithy_client_1.expectString)(output["ChecksumCRC32"]);
      }
      if (output["ChecksumCRC32C"] !== void 0) {
        contents.ChecksumCRC32C = (0, smithy_client_1.expectString)(output["ChecksumCRC32C"]);
      }
      if (output["ChecksumSHA1"] !== void 0) {
        contents.ChecksumSHA1 = (0, smithy_client_1.expectString)(output["ChecksumSHA1"]);
      }
      if (output["ChecksumSHA256"] !== void 0) {
        contents.ChecksumSHA256 = (0, smithy_client_1.expectString)(output["ChecksumSHA256"]);
      }
      return contents;
    };
    var deserializeAws_restXmlParts = (output, context) => {
      return (output || []).filter((e) => e != null).map((entry) => {
        return deserializeAws_restXmlPart(entry, context);
      });
    };
    var deserializeAws_restXmlPartsList = (output, context) => {
      return (output || []).filter((e) => e != null).map((entry) => {
        return deserializeAws_restXmlObjectPart(entry, context);
      });
    };
    var deserializeAws_restXmlPolicyStatus = (output, context) => {
      const contents = {
        IsPublic: void 0
      };
      if (output["IsPublic"] !== void 0) {
        contents.IsPublic = (0, smithy_client_1.parseBoolean)(output["IsPublic"]);
      }
      return contents;
    };
    var deserializeAws_restXmlProgress = (output, context) => {
      const contents = {
        BytesScanned: void 0,
        BytesProcessed: void 0,
        BytesReturned: void 0
      };
      if (output["BytesScanned"] !== void 0) {
        contents.BytesScanned = (0, smithy_client_1.strictParseLong)(output["BytesScanned"]);
      }
      if (output["BytesProcessed"] !== void 0) {
        contents.BytesProcessed = (0, smithy_client_1.strictParseLong)(output["BytesProcessed"]);
      }
      if (output["BytesReturned"] !== void 0) {
        contents.BytesReturned = (0, smithy_client_1.strictParseLong)(output["BytesReturned"]);
      }
      return contents;
    };
    var deserializeAws_restXmlPublicAccessBlockConfiguration = (output, context) => {
      const contents = {
        BlockPublicAcls: void 0,
        IgnorePublicAcls: void 0,
        BlockPublicPolicy: void 0,
        RestrictPublicBuckets: void 0
      };
      if (output["BlockPublicAcls"] !== void 0) {
        contents.BlockPublicAcls = (0, smithy_client_1.parseBoolean)(output["BlockPublicAcls"]);
      }
      if (output["IgnorePublicAcls"] !== void 0) {
        contents.IgnorePublicAcls = (0, smithy_client_1.parseBoolean)(output["IgnorePublicAcls"]);
      }
      if (output["BlockPublicPolicy"] !== void 0) {
        contents.BlockPublicPolicy = (0, smithy_client_1.parseBoolean)(output["BlockPublicPolicy"]);
      }
      if (output["RestrictPublicBuckets"] !== void 0) {
        contents.RestrictPublicBuckets = (0, smithy_client_1.parseBoolean)(output["RestrictPublicBuckets"]);
      }
      return contents;
    };
    var deserializeAws_restXmlQueueConfiguration = (output, context) => {
      const contents = {
        Id: void 0,
        QueueArn: void 0,
        Events: void 0,
        Filter: void 0
      };
      if (output["Id"] !== void 0) {
        contents.Id = (0, smithy_client_1.expectString)(output["Id"]);
      }
      if (output["Queue"] !== void 0) {
        contents.QueueArn = (0, smithy_client_1.expectString)(output["Queue"]);
      }
      if (output.Event === "") {
        contents.Events = [];
      } else if (output["Event"] !== void 0) {
        contents.Events = deserializeAws_restXmlEventList((0, smithy_client_1.getArrayIfSingleItem)(output["Event"]), context);
      }
      if (output["Filter"] !== void 0) {
        contents.Filter = deserializeAws_restXmlNotificationConfigurationFilter(output["Filter"], context);
      }
      return contents;
    };
    var deserializeAws_restXmlQueueConfigurationList = (output, context) => {
      return (output || []).filter((e) => e != null).map((entry) => {
        return deserializeAws_restXmlQueueConfiguration(entry, context);
      });
    };
    var deserializeAws_restXmlRedirect = (output, context) => {
      const contents = {
        HostName: void 0,
        HttpRedirectCode: void 0,
        Protocol: void 0,
        ReplaceKeyPrefixWith: void 0,
        ReplaceKeyWith: void 0
      };
      if (output["HostName"] !== void 0) {
        contents.HostName = (0, smithy_client_1.expectString)(output["HostName"]);
      }
      if (output["HttpRedirectCode"] !== void 0) {
        contents.HttpRedirectCode = (0, smithy_client_1.expectString)(output["HttpRedirectCode"]);
      }
      if (output["Protocol"] !== void 0) {
        contents.Protocol = (0, smithy_client_1.expectString)(output["Protocol"]);
      }
      if (output["ReplaceKeyPrefixWith"] !== void 0) {
        contents.ReplaceKeyPrefixWith = (0, smithy_client_1.expectString)(output["ReplaceKeyPrefixWith"]);
      }
      if (output["ReplaceKeyWith"] !== void 0) {
        contents.ReplaceKeyWith = (0, smithy_client_1.expectString)(output["ReplaceKeyWith"]);
      }
      return contents;
    };
    var deserializeAws_restXmlRedirectAllRequestsTo = (output, context) => {
      const contents = {
        HostName: void 0,
        Protocol: void 0
      };
      if (output["HostName"] !== void 0) {
        contents.HostName = (0, smithy_client_1.expectString)(output["HostName"]);
      }
      if (output["Protocol"] !== void 0) {
        contents.Protocol = (0, smithy_client_1.expectString)(output["Protocol"]);
      }
      return contents;
    };
    var deserializeAws_restXmlReplicaModifications = (output, context) => {
      const contents = {
        Status: void 0
      };
      if (output["Status"] !== void 0) {
        contents.Status = (0, smithy_client_1.expectString)(output["Status"]);
      }
      return contents;
    };
    var deserializeAws_restXmlReplicationConfiguration = (output, context) => {
      const contents = {
        Role: void 0,
        Rules: void 0
      };
      if (output["Role"] !== void 0) {
        contents.Role = (0, smithy_client_1.expectString)(output["Role"]);
      }
      if (output.Rule === "") {
        contents.Rules = [];
      } else if (output["Rule"] !== void 0) {
        contents.Rules = deserializeAws_restXmlReplicationRules((0, smithy_client_1.getArrayIfSingleItem)(output["Rule"]), context);
      }
      return contents;
    };
    var deserializeAws_restXmlReplicationRule = (output, context) => {
      const contents = {
        ID: void 0,
        Priority: void 0,
        Prefix: void 0,
        Filter: void 0,
        Status: void 0,
        SourceSelectionCriteria: void 0,
        ExistingObjectReplication: void 0,
        Destination: void 0,
        DeleteMarkerReplication: void 0
      };
      if (output["ID"] !== void 0) {
        contents.ID = (0, smithy_client_1.expectString)(output["ID"]);
      }
      if (output["Priority"] !== void 0) {
        contents.Priority = (0, smithy_client_1.strictParseInt32)(output["Priority"]);
      }
      if (output["Prefix"] !== void 0) {
        contents.Prefix = (0, smithy_client_1.expectString)(output["Prefix"]);
      }
      if (output.Filter === "") {
      } else if (output["Filter"] !== void 0) {
        contents.Filter = deserializeAws_restXmlReplicationRuleFilter((0, smithy_client_1.expectUnion)(output["Filter"]), context);
      }
      if (output["Status"] !== void 0) {
        contents.Status = (0, smithy_client_1.expectString)(output["Status"]);
      }
      if (output["SourceSelectionCriteria"] !== void 0) {
        contents.SourceSelectionCriteria = deserializeAws_restXmlSourceSelectionCriteria(output["SourceSelectionCriteria"], context);
      }
      if (output["ExistingObjectReplication"] !== void 0) {
        contents.ExistingObjectReplication = deserializeAws_restXmlExistingObjectReplication(output["ExistingObjectReplication"], context);
      }
      if (output["Destination"] !== void 0) {
        contents.Destination = deserializeAws_restXmlDestination(output["Destination"], context);
      }
      if (output["DeleteMarkerReplication"] !== void 0) {
        contents.DeleteMarkerReplication = deserializeAws_restXmlDeleteMarkerReplication(output["DeleteMarkerReplication"], context);
      }
      return contents;
    };
    var deserializeAws_restXmlReplicationRuleAndOperator = (output, context) => {
      const contents = {
        Prefix: void 0,
        Tags: void 0
      };
      if (output["Prefix"] !== void 0) {
        contents.Prefix = (0, smithy_client_1.expectString)(output["Prefix"]);
      }
      if (output.Tag === "") {
        contents.Tags = [];
      } else if (output["Tag"] !== void 0) {
        contents.Tags = deserializeAws_restXmlTagSet((0, smithy_client_1.getArrayIfSingleItem)(output["Tag"]), context);
      }
      return contents;
    };
    var deserializeAws_restXmlReplicationRuleFilter = (output, context) => {
      if (output["Prefix"] !== void 0) {
        return {
          Prefix: (0, smithy_client_1.expectString)(output["Prefix"])
        };
      }
      if (output["Tag"] !== void 0) {
        return {
          Tag: deserializeAws_restXmlTag(output["Tag"], context)
        };
      }
      if (output["And"] !== void 0) {
        return {
          And: deserializeAws_restXmlReplicationRuleAndOperator(output["And"], context)
        };
      }
      return { $unknown: Object.entries(output)[0] };
    };
    var deserializeAws_restXmlReplicationRules = (output, context) => {
      return (output || []).filter((e) => e != null).map((entry) => {
        return deserializeAws_restXmlReplicationRule(entry, context);
      });
    };
    var deserializeAws_restXmlReplicationTime = (output, context) => {
      const contents = {
        Status: void 0,
        Time: void 0
      };
      if (output["Status"] !== void 0) {
        contents.Status = (0, smithy_client_1.expectString)(output["Status"]);
      }
      if (output["Time"] !== void 0) {
        contents.Time = deserializeAws_restXmlReplicationTimeValue(output["Time"], context);
      }
      return contents;
    };
    var deserializeAws_restXmlReplicationTimeValue = (output, context) => {
      const contents = {
        Minutes: void 0
      };
      if (output["Minutes"] !== void 0) {
        contents.Minutes = (0, smithy_client_1.strictParseInt32)(output["Minutes"]);
      }
      return contents;
    };
    var deserializeAws_restXmlRoutingRule = (output, context) => {
      const contents = {
        Condition: void 0,
        Redirect: void 0
      };
      if (output["Condition"] !== void 0) {
        contents.Condition = deserializeAws_restXmlCondition(output["Condition"], context);
      }
      if (output["Redirect"] !== void 0) {
        contents.Redirect = deserializeAws_restXmlRedirect(output["Redirect"], context);
      }
      return contents;
    };
    var deserializeAws_restXmlRoutingRules = (output, context) => {
      return (output || []).filter((e) => e != null).map((entry) => {
        return deserializeAws_restXmlRoutingRule(entry, context);
      });
    };
    var deserializeAws_restXmlS3KeyFilter = (output, context) => {
      const contents = {
        FilterRules: void 0
      };
      if (output.FilterRule === "") {
        contents.FilterRules = [];
      } else if (output["FilterRule"] !== void 0) {
        contents.FilterRules = deserializeAws_restXmlFilterRuleList((0, smithy_client_1.getArrayIfSingleItem)(output["FilterRule"]), context);
      }
      return contents;
    };
    var deserializeAws_restXmlServerSideEncryptionByDefault = (output, context) => {
      const contents = {
        SSEAlgorithm: void 0,
        KMSMasterKeyID: void 0
      };
      if (output["SSEAlgorithm"] !== void 0) {
        contents.SSEAlgorithm = (0, smithy_client_1.expectString)(output["SSEAlgorithm"]);
      }
      if (output["KMSMasterKeyID"] !== void 0) {
        contents.KMSMasterKeyID = (0, smithy_client_1.expectString)(output["KMSMasterKeyID"]);
      }
      return contents;
    };
    var deserializeAws_restXmlServerSideEncryptionConfiguration = (output, context) => {
      const contents = {
        Rules: void 0
      };
      if (output.Rule === "") {
        contents.Rules = [];
      } else if (output["Rule"] !== void 0) {
        contents.Rules = deserializeAws_restXmlServerSideEncryptionRules((0, smithy_client_1.getArrayIfSingleItem)(output["Rule"]), context);
      }
      return contents;
    };
    var deserializeAws_restXmlServerSideEncryptionRule = (output, context) => {
      const contents = {
        ApplyServerSideEncryptionByDefault: void 0,
        BucketKeyEnabled: void 0
      };
      if (output["ApplyServerSideEncryptionByDefault"] !== void 0) {
        contents.ApplyServerSideEncryptionByDefault = deserializeAws_restXmlServerSideEncryptionByDefault(output["ApplyServerSideEncryptionByDefault"], context);
      }
      if (output["BucketKeyEnabled"] !== void 0) {
        contents.BucketKeyEnabled = (0, smithy_client_1.parseBoolean)(output["BucketKeyEnabled"]);
      }
      return contents;
    };
    var deserializeAws_restXmlServerSideEncryptionRules = (output, context) => {
      return (output || []).filter((e) => e != null).map((entry) => {
        return deserializeAws_restXmlServerSideEncryptionRule(entry, context);
      });
    };
    var deserializeAws_restXmlSourceSelectionCriteria = (output, context) => {
      const contents = {
        SseKmsEncryptedObjects: void 0,
        ReplicaModifications: void 0
      };
      if (output["SseKmsEncryptedObjects"] !== void 0) {
        contents.SseKmsEncryptedObjects = deserializeAws_restXmlSseKmsEncryptedObjects(output["SseKmsEncryptedObjects"], context);
      }
      if (output["ReplicaModifications"] !== void 0) {
        contents.ReplicaModifications = deserializeAws_restXmlReplicaModifications(output["ReplicaModifications"], context);
      }
      return contents;
    };
    var deserializeAws_restXmlSSEKMS = (output, context) => {
      const contents = {
        KeyId: void 0
      };
      if (output["KeyId"] !== void 0) {
        contents.KeyId = (0, smithy_client_1.expectString)(output["KeyId"]);
      }
      return contents;
    };
    var deserializeAws_restXmlSseKmsEncryptedObjects = (output, context) => {
      const contents = {
        Status: void 0
      };
      if (output["Status"] !== void 0) {
        contents.Status = (0, smithy_client_1.expectString)(output["Status"]);
      }
      return contents;
    };
    var deserializeAws_restXmlSSES3 = (output, context) => {
      const contents = {};
      return contents;
    };
    var deserializeAws_restXmlStats = (output, context) => {
      const contents = {
        BytesScanned: void 0,
        BytesProcessed: void 0,
        BytesReturned: void 0
      };
      if (output["BytesScanned"] !== void 0) {
        contents.BytesScanned = (0, smithy_client_1.strictParseLong)(output["BytesScanned"]);
      }
      if (output["BytesProcessed"] !== void 0) {
        contents.BytesProcessed = (0, smithy_client_1.strictParseLong)(output["BytesProcessed"]);
      }
      if (output["BytesReturned"] !== void 0) {
        contents.BytesReturned = (0, smithy_client_1.strictParseLong)(output["BytesReturned"]);
      }
      return contents;
    };
    var deserializeAws_restXmlStorageClassAnalysis = (output, context) => {
      const contents = {
        DataExport: void 0
      };
      if (output["DataExport"] !== void 0) {
        contents.DataExport = deserializeAws_restXmlStorageClassAnalysisDataExport(output["DataExport"], context);
      }
      return contents;
    };
    var deserializeAws_restXmlStorageClassAnalysisDataExport = (output, context) => {
      const contents = {
        OutputSchemaVersion: void 0,
        Destination: void 0
      };
      if (output["OutputSchemaVersion"] !== void 0) {
        contents.OutputSchemaVersion = (0, smithy_client_1.expectString)(output["OutputSchemaVersion"]);
      }
      if (output["Destination"] !== void 0) {
        contents.Destination = deserializeAws_restXmlAnalyticsExportDestination(output["Destination"], context);
      }
      return contents;
    };
    var deserializeAws_restXmlTag = (output, context) => {
      const contents = {
        Key: void 0,
        Value: void 0
      };
      if (output["Key"] !== void 0) {
        contents.Key = (0, smithy_client_1.expectString)(output["Key"]);
      }
      if (output["Value"] !== void 0) {
        contents.Value = (0, smithy_client_1.expectString)(output["Value"]);
      }
      return contents;
    };
    var deserializeAws_restXmlTagSet = (output, context) => {
      return (output || []).filter((e) => e != null).map((entry) => {
        return deserializeAws_restXmlTag(entry, context);
      });
    };
    var deserializeAws_restXmlTargetGrant = (output, context) => {
      const contents = {
        Grantee: void 0,
        Permission: void 0
      };
      if (output["Grantee"] !== void 0) {
        contents.Grantee = deserializeAws_restXmlGrantee(output["Grantee"], context);
      }
      if (output["Permission"] !== void 0) {
        contents.Permission = (0, smithy_client_1.expectString)(output["Permission"]);
      }
      return contents;
    };
    var deserializeAws_restXmlTargetGrants = (output, context) => {
      return (output || []).filter((e) => e != null).map((entry) => {
        return deserializeAws_restXmlTargetGrant(entry, context);
      });
    };
    var deserializeAws_restXmlTiering = (output, context) => {
      const contents = {
        Days: void 0,
        AccessTier: void 0
      };
      if (output["Days"] !== void 0) {
        contents.Days = (0, smithy_client_1.strictParseInt32)(output["Days"]);
      }
      if (output["AccessTier"] !== void 0) {
        contents.AccessTier = (0, smithy_client_1.expectString)(output["AccessTier"]);
      }
      return contents;
    };
    var deserializeAws_restXmlTieringList = (output, context) => {
      return (output || []).filter((e) => e != null).map((entry) => {
        return deserializeAws_restXmlTiering(entry, context);
      });
    };
    var deserializeAws_restXmlTopicConfiguration = (output, context) => {
      const contents = {
        Id: void 0,
        TopicArn: void 0,
        Events: void 0,
        Filter: void 0
      };
      if (output["Id"] !== void 0) {
        contents.Id = (0, smithy_client_1.expectString)(output["Id"]);
      }
      if (output["Topic"] !== void 0) {
        contents.TopicArn = (0, smithy_client_1.expectString)(output["Topic"]);
      }
      if (output.Event === "") {
        contents.Events = [];
      } else if (output["Event"] !== void 0) {
        contents.Events = deserializeAws_restXmlEventList((0, smithy_client_1.getArrayIfSingleItem)(output["Event"]), context);
      }
      if (output["Filter"] !== void 0) {
        contents.Filter = deserializeAws_restXmlNotificationConfigurationFilter(output["Filter"], context);
      }
      return contents;
    };
    var deserializeAws_restXmlTopicConfigurationList = (output, context) => {
      return (output || []).filter((e) => e != null).map((entry) => {
        return deserializeAws_restXmlTopicConfiguration(entry, context);
      });
    };
    var deserializeAws_restXmlTransition = (output, context) => {
      const contents = {
        Date: void 0,
        Days: void 0,
        StorageClass: void 0
      };
      if (output["Date"] !== void 0) {
        contents.Date = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.parseRfc3339DateTimeWithOffset)(output["Date"]));
      }
      if (output["Days"] !== void 0) {
        contents.Days = (0, smithy_client_1.strictParseInt32)(output["Days"]);
      }
      if (output["StorageClass"] !== void 0) {
        contents.StorageClass = (0, smithy_client_1.expectString)(output["StorageClass"]);
      }
      return contents;
    };
    var deserializeAws_restXmlTransitionList = (output, context) => {
      return (output || []).filter((e) => e != null).map((entry) => {
        return deserializeAws_restXmlTransition(entry, context);
      });
    };
    var deserializeMetadata = (output) => ({
      httpStatusCode: output.statusCode,
      requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
      extendedRequestId: output.headers["x-amz-id-2"],
      cfId: output.headers["x-amz-cf-id"]
    });
    var collectBody = (streamBody = new Uint8Array(), context) => {
      if (streamBody instanceof Uint8Array) {
        return Promise.resolve(streamBody);
      }
      return context.streamCollector(streamBody) || Promise.resolve(new Uint8Array());
    };
    var collectBodyString = (streamBody, context) => collectBody(streamBody, context).then((body) => context.utf8Encoder(body));
    var isSerializableHeaderValue = (value) => value !== void 0 && value !== null && value !== "" && (!Object.getOwnPropertyNames(value).includes("length") || value.length != 0) && (!Object.getOwnPropertyNames(value).includes("size") || value.size != 0);
    var parseBody = (streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
      if (encoded.length) {
        const parser = new fast_xml_parser_1.XMLParser({
          attributeNamePrefix: "",
          htmlEntities: true,
          ignoreAttributes: false,
          ignoreDeclaration: true,
          parseTagValue: false,
          trimValues: false,
          tagValueProcessor: (_, val) => val.trim() === "" && val.includes("\n") ? "" : void 0
        });
        parser.addEntity("#xD", "\r");
        parser.addEntity("#10", "\n");
        const parsedObj = parser.parse(encoded);
        const textNodeName = "#text";
        const key = Object.keys(parsedObj)[0];
        const parsedObjToReturn = parsedObj[key];
        if (parsedObjToReturn[textNodeName]) {
          parsedObjToReturn[key] = parsedObjToReturn[textNodeName];
          delete parsedObjToReturn[textNodeName];
        }
        return (0, smithy_client_1.getValueFromTextNode)(parsedObjToReturn);
      }
      return {};
    });
    var parseErrorBody = async (errorBody, context) => {
      const value = await parseBody(errorBody, context);
      if (value.Error) {
        value.Error.message = value.Error.message ?? value.Error.Message;
      }
      return value;
    };
    var loadRestXmlErrorCode = (output, data) => {
      if ((data == null ? void 0 : data.Code) !== void 0) {
        return data.Code;
      }
      if (output.statusCode == 404) {
        return "NotFound";
      }
    };
  }
});

// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/AbortMultipartUploadCommand.js
var require_AbortMultipartUploadCommand = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/AbortMultipartUploadCommand.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.AbortMultipartUploadCommand = void 0;
    var middleware_endpoint_1 = require_dist_cjs5();
    var middleware_serde_1 = require_dist_cjs3();
    var smithy_client_1 = require_dist_cjs7();
    var models_0_1 = require_models_0();
    var Aws_restXml_1 = require_Aws_restXml();
    var AbortMultipartUploadCommand = class extends smithy_client_1.Command {
      constructor(input) {
        super();
        this.input = input;
      }
      static getEndpointParameterInstructions() {
        return {
          Bucket: { type: "contextParams", name: "Bucket" },
          ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" },
          UseArnRegion: { type: "clientContextParams", name: "useArnRegion" },
          DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" },
          Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" },
          UseGlobalEndpoint: { type: "builtInParams", name: "useGlobalEndpoint" },
          UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
          Endpoint: { type: "builtInParams", name: "endpoint" },
          Region: { type: "builtInParams", name: "region" },
          UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
        };
      }
      resolveMiddleware(clientStack, configuration, options) {
        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, AbortMultipartUploadCommand.getEndpointParameterInstructions()));
        const stack = clientStack.concat(this.middlewareStack);
        const { logger } = configuration;
        const clientName = "S3Client";
        const commandName = "AbortMultipartUploadCommand";
        const handlerExecutionContext = {
          logger,
          clientName,
          commandName,
          inputFilterSensitiveLog: models_0_1.AbortMultipartUploadRequestFilterSensitiveLog,
          outputFilterSensitiveLog: models_0_1.AbortMultipartUploadOutputFilterSensitiveLog
        };
        const { requestHandler } = configuration;
        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
      }
      serialize(input, context) {
        return (0, Aws_restXml_1.serializeAws_restXmlAbortMultipartUploadCommand)(input, context);
      }
      deserialize(output, context) {
        return (0, Aws_restXml_1.deserializeAws_restXmlAbortMultipartUploadCommand)(output, context);
      }
    };
    exports.AbortMultipartUploadCommand = AbortMultipartUploadCommand;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+middleware-sdk-s3@3.272.0/node_modules/@aws-sdk/middleware-sdk-s3/dist-cjs/check-content-length-header.js
var require_check_content_length_header = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+middleware-sdk-s3@3.272.0/node_modules/@aws-sdk/middleware-sdk-s3/dist-cjs/check-content-length-header.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.getCheckContentLengthHeaderPlugin = exports.checkContentLengthHeaderMiddlewareOptions = exports.checkContentLengthHeader = void 0;
    var protocol_http_1 = require_dist_cjs8();
    var CONTENT_LENGTH_HEADER = "content-length";
    function checkContentLengthHeader() {
      return (next, context) => async (args) => {
        var _a;
        const { request } = args;
        if (protocol_http_1.HttpRequest.isInstance(request)) {
          if (!request.headers[CONTENT_LENGTH_HEADER]) {
            const message = `Are you using a Stream of unknown length as the Body of a PutObject request? Consider using Upload instead from @aws-sdk/lib-storage.`;
            if (typeof ((_a = context === null || context === void 0 ? void 0 : context.logger) === null || _a === void 0 ? void 0 : _a.warn) === "function") {
              context.logger.warn(message);
            } else {
              console.warn(message);
            }
          }
        }
        return next({ ...args });
      };
    }
    exports.checkContentLengthHeader = checkContentLengthHeader;
    exports.checkContentLengthHeaderMiddlewareOptions = {
      step: "finalizeRequest",
      tags: ["CHECK_CONTENT_LENGTH_HEADER"],
      name: "getCheckContentLengthHeaderPlugin",
      override: true
    };
    var getCheckContentLengthHeaderPlugin = (unused) => ({
      applyToStack: (clientStack) => {
        clientStack.add(checkContentLengthHeader(), exports.checkContentLengthHeaderMiddlewareOptions);
      }
    });
    exports.getCheckContentLengthHeaderPlugin = getCheckContentLengthHeaderPlugin;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+middleware-sdk-s3@3.272.0/node_modules/@aws-sdk/middleware-sdk-s3/dist-cjs/configuration.js
var require_configuration = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+middleware-sdk-s3@3.272.0/node_modules/@aws-sdk/middleware-sdk-s3/dist-cjs/configuration.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.resolveS3Config = void 0;
    var resolveS3Config = (input) => {
      var _a, _b, _c;
      return {
        ...input,
        forcePathStyle: (_a = input.forcePathStyle) !== null && _a !== void 0 ? _a : false,
        useAccelerateEndpoint: (_b = input.useAccelerateEndpoint) !== null && _b !== void 0 ? _b : false,
        disableMultiregionAccessPoints: (_c = input.disableMultiregionAccessPoints) !== null && _c !== void 0 ? _c : false
      };
    };
    exports.resolveS3Config = resolveS3Config;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+middleware-sdk-s3@3.272.0/node_modules/@aws-sdk/middleware-sdk-s3/dist-cjs/throw-200-exceptions.js
var require_throw_200_exceptions = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+middleware-sdk-s3@3.272.0/node_modules/@aws-sdk/middleware-sdk-s3/dist-cjs/throw-200-exceptions.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.getThrow200ExceptionsPlugin = exports.throw200ExceptionsMiddlewareOptions = exports.throw200ExceptionsMiddleware = void 0;
    var protocol_http_1 = require_dist_cjs8();
    var throw200ExceptionsMiddleware = (config) => (next) => async (args) => {
      const result = await next(args);
      const { response } = result;
      if (!protocol_http_1.HttpResponse.isInstance(response))
        return result;
      const { statusCode, body } = response;
      if (statusCode < 200 || statusCode >= 300)
        return result;
      const bodyBytes = await collectBody(body, config);
      const bodyString = await collectBodyString(bodyBytes, config);
      if (bodyBytes.length === 0) {
        const err = new Error("S3 aborted request");
        err.name = "InternalError";
        throw err;
      }
      if (bodyString && bodyString.match("<Error>")) {
        response.statusCode = 400;
      }
      response.body = bodyBytes;
      return result;
    };
    exports.throw200ExceptionsMiddleware = throw200ExceptionsMiddleware;
    var collectBody = (streamBody = new Uint8Array(), context) => {
      if (streamBody instanceof Uint8Array) {
        return Promise.resolve(streamBody);
      }
      return context.streamCollector(streamBody) || Promise.resolve(new Uint8Array());
    };
    var collectBodyString = (streamBody, context) => collectBody(streamBody, context).then((body) => context.utf8Encoder(body));
    exports.throw200ExceptionsMiddlewareOptions = {
      relation: "after",
      toMiddleware: "deserializerMiddleware",
      tags: ["THROW_200_EXCEPTIONS", "S3"],
      name: "throw200ExceptionsMiddleware",
      override: true
    };
    var getThrow200ExceptionsPlugin = (config) => ({
      applyToStack: (clientStack) => {
        clientStack.addRelativeTo((0, exports.throw200ExceptionsMiddleware)(config), exports.throw200ExceptionsMiddlewareOptions);
      }
    });
    exports.getThrow200ExceptionsPlugin = getThrow200ExceptionsPlugin;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+util-arn-parser@3.208.0/node_modules/@aws-sdk/util-arn-parser/dist-cjs/index.js
var require_dist_cjs10 = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+util-arn-parser@3.208.0/node_modules/@aws-sdk/util-arn-parser/dist-cjs/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.build = exports.parse = exports.validate = void 0;
    var validate2 = (str) => typeof str === "string" && str.indexOf("arn:") === 0 && str.split(":").length >= 6;
    exports.validate = validate2;
    var parse2 = (arn) => {
      const segments = arn.split(":");
      if (segments.length < 6 || segments[0] !== "arn")
        throw new Error("Malformed ARN");
      const [, partition, service, region, accountId, ...resource] = segments;
      return {
        partition,
        service,
        region,
        accountId,
        resource: resource.join(":")
      };
    };
    exports.parse = parse2;
    var build = (arnObject) => {
      const { partition = "aws", service, region, accountId, resource } = arnObject;
      if ([service, region, accountId, resource].some((segment) => typeof segment !== "string")) {
        throw new Error("Input ARN object is invalid");
      }
      return `arn:${partition}:${service}:${region}:${accountId}:${resource}`;
    };
    exports.build = build;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+middleware-sdk-s3@3.272.0/node_modules/@aws-sdk/middleware-sdk-s3/dist-cjs/validate-bucket-name.js
var require_validate_bucket_name = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+middleware-sdk-s3@3.272.0/node_modules/@aws-sdk/middleware-sdk-s3/dist-cjs/validate-bucket-name.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.getValidateBucketNamePlugin = exports.validateBucketNameMiddlewareOptions = exports.validateBucketNameMiddleware = void 0;
    var util_arn_parser_1 = require_dist_cjs10();
    function validateBucketNameMiddleware() {
      return (next) => async (args) => {
        const { input: { Bucket } } = args;
        if (typeof Bucket === "string" && !(0, util_arn_parser_1.validate)(Bucket) && Bucket.indexOf("/") >= 0) {
          const err = new Error(`Bucket name shouldn't contain '/', received '${Bucket}'`);
          err.name = "InvalidBucketName";
          throw err;
        }
        return next({ ...args });
      };
    }
    exports.validateBucketNameMiddleware = validateBucketNameMiddleware;
    exports.validateBucketNameMiddlewareOptions = {
      step: "initialize",
      tags: ["VALIDATE_BUCKET_NAME"],
      name: "validateBucketNameMiddleware",
      override: true
    };
    var getValidateBucketNamePlugin = (unused) => ({
      applyToStack: (clientStack) => {
        clientStack.add(validateBucketNameMiddleware(), exports.validateBucketNameMiddlewareOptions);
      }
    });
    exports.getValidateBucketNamePlugin = getValidateBucketNamePlugin;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+middleware-sdk-s3@3.272.0/node_modules/@aws-sdk/middleware-sdk-s3/dist-cjs/index.js
var require_dist_cjs11 = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+middleware-sdk-s3@3.272.0/node_modules/@aws-sdk/middleware-sdk-s3/dist-cjs/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    var tslib_1 = (init_tslib_es6(), __toCommonJS(tslib_es6_exports));
    tslib_1.__exportStar(require_check_content_length_header(), exports);
    tslib_1.__exportStar(require_configuration(), exports);
    tslib_1.__exportStar(require_throw_200_exceptions(), exports);
    tslib_1.__exportStar(require_validate_bucket_name(), exports);
  }
});

// ../../node_modules/.pnpm/@aws-sdk+middleware-ssec@3.272.0/node_modules/@aws-sdk/middleware-ssec/dist-cjs/index.js
var require_dist_cjs12 = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+middleware-ssec@3.272.0/node_modules/@aws-sdk/middleware-ssec/dist-cjs/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.getSsecPlugin = exports.ssecMiddlewareOptions = exports.ssecMiddleware = void 0;
    function ssecMiddleware(options) {
      return (next) => async (args) => {
        let input = { ...args.input };
        const properties = [
          {
            target: "SSECustomerKey",
            hash: "SSECustomerKeyMD5"
          },
          {
            target: "CopySourceSSECustomerKey",
            hash: "CopySourceSSECustomerKeyMD5"
          }
        ];
        for (const prop of properties) {
          const value = input[prop.target];
          if (value) {
            const valueView = ArrayBuffer.isView(value) ? new Uint8Array(value.buffer, value.byteOffset, value.byteLength) : typeof value === "string" ? options.utf8Decoder(value) : new Uint8Array(value);
            const encoded = options.base64Encoder(valueView);
            const hash = new options.md5();
            hash.update(valueView);
            input = {
              ...input,
              [prop.target]: encoded,
              [prop.hash]: options.base64Encoder(await hash.digest())
            };
          }
        }
        return next({
          ...args,
          input
        });
      };
    }
    exports.ssecMiddleware = ssecMiddleware;
    exports.ssecMiddlewareOptions = {
      name: "ssecMiddleware",
      step: "initialize",
      tags: ["SSE"],
      override: true
    };
    var getSsecPlugin = (config) => ({
      applyToStack: (clientStack) => {
        clientStack.add(ssecMiddleware(config), exports.ssecMiddlewareOptions);
      }
    });
    exports.getSsecPlugin = getSsecPlugin;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/CompleteMultipartUploadCommand.js
var require_CompleteMultipartUploadCommand = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/CompleteMultipartUploadCommand.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.CompleteMultipartUploadCommand = void 0;
    var middleware_endpoint_1 = require_dist_cjs5();
    var middleware_sdk_s3_1 = require_dist_cjs11();
    var middleware_serde_1 = require_dist_cjs3();
    var middleware_ssec_1 = require_dist_cjs12();
    var smithy_client_1 = require_dist_cjs7();
    var models_0_1 = require_models_0();
    var Aws_restXml_1 = require_Aws_restXml();
    var CompleteMultipartUploadCommand = class extends smithy_client_1.Command {
      constructor(input) {
        super();
        this.input = input;
      }
      static getEndpointParameterInstructions() {
        return {
          Bucket: { type: "contextParams", name: "Bucket" },
          ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" },
          UseArnRegion: { type: "clientContextParams", name: "useArnRegion" },
          DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" },
          Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" },
          UseGlobalEndpoint: { type: "builtInParams", name: "useGlobalEndpoint" },
          UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
          Endpoint: { type: "builtInParams", name: "endpoint" },
          Region: { type: "builtInParams", name: "region" },
          UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
        };
      }
      resolveMiddleware(clientStack, configuration, options) {
        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, CompleteMultipartUploadCommand.getEndpointParameterInstructions()));
        this.middlewareStack.use((0, middleware_sdk_s3_1.getThrow200ExceptionsPlugin)(configuration));
        this.middlewareStack.use((0, middleware_ssec_1.getSsecPlugin)(configuration));
        const stack = clientStack.concat(this.middlewareStack);
        const { logger } = configuration;
        const clientName = "S3Client";
        const commandName = "CompleteMultipartUploadCommand";
        const handlerExecutionContext = {
          logger,
          clientName,
          commandName,
          inputFilterSensitiveLog: models_0_1.CompleteMultipartUploadRequestFilterSensitiveLog,
          outputFilterSensitiveLog: models_0_1.CompleteMultipartUploadOutputFilterSensitiveLog
        };
        const { requestHandler } = configuration;
        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
      }
      serialize(input, context) {
        return (0, Aws_restXml_1.serializeAws_restXmlCompleteMultipartUploadCommand)(input, context);
      }
      deserialize(output, context) {
        return (0, Aws_restXml_1.deserializeAws_restXmlCompleteMultipartUploadCommand)(output, context);
      }
    };
    exports.CompleteMultipartUploadCommand = CompleteMultipartUploadCommand;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/CopyObjectCommand.js
var require_CopyObjectCommand = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/CopyObjectCommand.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.CopyObjectCommand = void 0;
    var middleware_endpoint_1 = require_dist_cjs5();
    var middleware_sdk_s3_1 = require_dist_cjs11();
    var middleware_serde_1 = require_dist_cjs3();
    var middleware_ssec_1 = require_dist_cjs12();
    var smithy_client_1 = require_dist_cjs7();
    var models_0_1 = require_models_0();
    var Aws_restXml_1 = require_Aws_restXml();
    var CopyObjectCommand = class extends smithy_client_1.Command {
      constructor(input) {
        super();
        this.input = input;
      }
      static getEndpointParameterInstructions() {
        return {
          Bucket: { type: "contextParams", name: "Bucket" },
          ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" },
          UseArnRegion: { type: "clientContextParams", name: "useArnRegion" },
          DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" },
          Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" },
          UseGlobalEndpoint: { type: "builtInParams", name: "useGlobalEndpoint" },
          UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
          Endpoint: { type: "builtInParams", name: "endpoint" },
          Region: { type: "builtInParams", name: "region" },
          UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
        };
      }
      resolveMiddleware(clientStack, configuration, options) {
        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, CopyObjectCommand.getEndpointParameterInstructions()));
        this.middlewareStack.use((0, middleware_sdk_s3_1.getThrow200ExceptionsPlugin)(configuration));
        this.middlewareStack.use((0, middleware_ssec_1.getSsecPlugin)(configuration));
        const stack = clientStack.concat(this.middlewareStack);
        const { logger } = configuration;
        const clientName = "S3Client";
        const commandName = "CopyObjectCommand";
        const handlerExecutionContext = {
          logger,
          clientName,
          commandName,
          inputFilterSensitiveLog: models_0_1.CopyObjectRequestFilterSensitiveLog,
          outputFilterSensitiveLog: models_0_1.CopyObjectOutputFilterSensitiveLog
        };
        const { requestHandler } = configuration;
        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
      }
      serialize(input, context) {
        return (0, Aws_restXml_1.serializeAws_restXmlCopyObjectCommand)(input, context);
      }
      deserialize(output, context) {
        return (0, Aws_restXml_1.deserializeAws_restXmlCopyObjectCommand)(output, context);
      }
    };
    exports.CopyObjectCommand = CopyObjectCommand;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+middleware-location-constraint@3.272.0/node_modules/@aws-sdk/middleware-location-constraint/dist-cjs/index.js
var require_dist_cjs13 = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+middleware-location-constraint@3.272.0/node_modules/@aws-sdk/middleware-location-constraint/dist-cjs/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.getLocationConstraintPlugin = exports.locationConstraintMiddlewareOptions = exports.locationConstraintMiddleware = void 0;
    function locationConstraintMiddleware(options) {
      return (next) => async (args) => {
        const { CreateBucketConfiguration } = args.input;
        const region = await options.region();
        if (!CreateBucketConfiguration || !CreateBucketConfiguration.LocationConstraint) {
          args = {
            ...args,
            input: {
              ...args.input,
              CreateBucketConfiguration: region === "us-east-1" ? void 0 : { LocationConstraint: region }
            }
          };
        }
        return next(args);
      };
    }
    exports.locationConstraintMiddleware = locationConstraintMiddleware;
    exports.locationConstraintMiddlewareOptions = {
      step: "initialize",
      tags: ["LOCATION_CONSTRAINT", "CREATE_BUCKET_CONFIGURATION"],
      name: "locationConstraintMiddleware",
      override: true
    };
    var getLocationConstraintPlugin = (config) => ({
      applyToStack: (clientStack) => {
        clientStack.add(locationConstraintMiddleware(config), exports.locationConstraintMiddlewareOptions);
      }
    });
    exports.getLocationConstraintPlugin = getLocationConstraintPlugin;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/CreateBucketCommand.js
var require_CreateBucketCommand = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/CreateBucketCommand.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.CreateBucketCommand = void 0;
    var middleware_endpoint_1 = require_dist_cjs5();
    var middleware_location_constraint_1 = require_dist_cjs13();
    var middleware_serde_1 = require_dist_cjs3();
    var smithy_client_1 = require_dist_cjs7();
    var models_0_1 = require_models_0();
    var Aws_restXml_1 = require_Aws_restXml();
    var CreateBucketCommand = class extends smithy_client_1.Command {
      constructor(input) {
        super();
        this.input = input;
      }
      static getEndpointParameterInstructions() {
        return {
          DisableAccessPoints: { type: "staticContextParams", value: true },
          Bucket: { type: "contextParams", name: "Bucket" },
          ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" },
          UseArnRegion: { type: "clientContextParams", name: "useArnRegion" },
          DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" },
          Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" },
          UseGlobalEndpoint: { type: "builtInParams", name: "useGlobalEndpoint" },
          UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
          Endpoint: { type: "builtInParams", name: "endpoint" },
          Region: { type: "builtInParams", name: "region" },
          UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
        };
      }
      resolveMiddleware(clientStack, configuration, options) {
        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, CreateBucketCommand.getEndpointParameterInstructions()));
        this.middlewareStack.use((0, middleware_location_constraint_1.getLocationConstraintPlugin)(configuration));
        const stack = clientStack.concat(this.middlewareStack);
        const { logger } = configuration;
        const clientName = "S3Client";
        const commandName = "CreateBucketCommand";
        const handlerExecutionContext = {
          logger,
          clientName,
          commandName,
          inputFilterSensitiveLog: models_0_1.CreateBucketRequestFilterSensitiveLog,
          outputFilterSensitiveLog: models_0_1.CreateBucketOutputFilterSensitiveLog
        };
        const { requestHandler } = configuration;
        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
      }
      serialize(input, context) {
        return (0, Aws_restXml_1.serializeAws_restXmlCreateBucketCommand)(input, context);
      }
      deserialize(output, context) {
        return (0, Aws_restXml_1.deserializeAws_restXmlCreateBucketCommand)(output, context);
      }
    };
    exports.CreateBucketCommand = CreateBucketCommand;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/CreateMultipartUploadCommand.js
var require_CreateMultipartUploadCommand = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/CreateMultipartUploadCommand.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.CreateMultipartUploadCommand = void 0;
    var middleware_endpoint_1 = require_dist_cjs5();
    var middleware_serde_1 = require_dist_cjs3();
    var middleware_ssec_1 = require_dist_cjs12();
    var smithy_client_1 = require_dist_cjs7();
    var models_0_1 = require_models_0();
    var Aws_restXml_1 = require_Aws_restXml();
    var CreateMultipartUploadCommand = class extends smithy_client_1.Command {
      constructor(input) {
        super();
        this.input = input;
      }
      static getEndpointParameterInstructions() {
        return {
          Bucket: { type: "contextParams", name: "Bucket" },
          ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" },
          UseArnRegion: { type: "clientContextParams", name: "useArnRegion" },
          DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" },
          Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" },
          UseGlobalEndpoint: { type: "builtInParams", name: "useGlobalEndpoint" },
          UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
          Endpoint: { type: "builtInParams", name: "endpoint" },
          Region: { type: "builtInParams", name: "region" },
          UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
        };
      }
      resolveMiddleware(clientStack, configuration, options) {
        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, CreateMultipartUploadCommand.getEndpointParameterInstructions()));
        this.middlewareStack.use((0, middleware_ssec_1.getSsecPlugin)(configuration));
        const stack = clientStack.concat(this.middlewareStack);
        const { logger } = configuration;
        const clientName = "S3Client";
        const commandName = "CreateMultipartUploadCommand";
        const handlerExecutionContext = {
          logger,
          clientName,
          commandName,
          inputFilterSensitiveLog: models_0_1.CreateMultipartUploadRequestFilterSensitiveLog,
          outputFilterSensitiveLog: models_0_1.CreateMultipartUploadOutputFilterSensitiveLog
        };
        const { requestHandler } = configuration;
        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
      }
      serialize(input, context) {
        return (0, Aws_restXml_1.serializeAws_restXmlCreateMultipartUploadCommand)(input, context);
      }
      deserialize(output, context) {
        return (0, Aws_restXml_1.deserializeAws_restXmlCreateMultipartUploadCommand)(output, context);
      }
    };
    exports.CreateMultipartUploadCommand = CreateMultipartUploadCommand;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/DeleteBucketAnalyticsConfigurationCommand.js
var require_DeleteBucketAnalyticsConfigurationCommand = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/DeleteBucketAnalyticsConfigurationCommand.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.DeleteBucketAnalyticsConfigurationCommand = void 0;
    var middleware_endpoint_1 = require_dist_cjs5();
    var middleware_serde_1 = require_dist_cjs3();
    var smithy_client_1 = require_dist_cjs7();
    var models_0_1 = require_models_0();
    var Aws_restXml_1 = require_Aws_restXml();
    var DeleteBucketAnalyticsConfigurationCommand = class extends smithy_client_1.Command {
      constructor(input) {
        super();
        this.input = input;
      }
      static getEndpointParameterInstructions() {
        return {
          Bucket: { type: "contextParams", name: "Bucket" },
          ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" },
          UseArnRegion: { type: "clientContextParams", name: "useArnRegion" },
          DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" },
          Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" },
          UseGlobalEndpoint: { type: "builtInParams", name: "useGlobalEndpoint" },
          UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
          Endpoint: { type: "builtInParams", name: "endpoint" },
          Region: { type: "builtInParams", name: "region" },
          UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
        };
      }
      resolveMiddleware(clientStack, configuration, options) {
        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DeleteBucketAnalyticsConfigurationCommand.getEndpointParameterInstructions()));
        const stack = clientStack.concat(this.middlewareStack);
        const { logger } = configuration;
        const clientName = "S3Client";
        const commandName = "DeleteBucketAnalyticsConfigurationCommand";
        const handlerExecutionContext = {
          logger,
          clientName,
          commandName,
          inputFilterSensitiveLog: models_0_1.DeleteBucketAnalyticsConfigurationRequestFilterSensitiveLog,
          outputFilterSensitiveLog: (output) => output
        };
        const { requestHandler } = configuration;
        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
      }
      serialize(input, context) {
        return (0, Aws_restXml_1.serializeAws_restXmlDeleteBucketAnalyticsConfigurationCommand)(input, context);
      }
      deserialize(output, context) {
        return (0, Aws_restXml_1.deserializeAws_restXmlDeleteBucketAnalyticsConfigurationCommand)(output, context);
      }
    };
    exports.DeleteBucketAnalyticsConfigurationCommand = DeleteBucketAnalyticsConfigurationCommand;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/DeleteBucketCommand.js
var require_DeleteBucketCommand = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/DeleteBucketCommand.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.DeleteBucketCommand = void 0;
    var middleware_endpoint_1 = require_dist_cjs5();
    var middleware_serde_1 = require_dist_cjs3();
    var smithy_client_1 = require_dist_cjs7();
    var models_0_1 = require_models_0();
    var Aws_restXml_1 = require_Aws_restXml();
    var DeleteBucketCommand = class extends smithy_client_1.Command {
      constructor(input) {
        super();
        this.input = input;
      }
      static getEndpointParameterInstructions() {
        return {
          Bucket: { type: "contextParams", name: "Bucket" },
          ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" },
          UseArnRegion: { type: "clientContextParams", name: "useArnRegion" },
          DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" },
          Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" },
          UseGlobalEndpoint: { type: "builtInParams", name: "useGlobalEndpoint" },
          UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
          Endpoint: { type: "builtInParams", name: "endpoint" },
          Region: { type: "builtInParams", name: "region" },
          UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
        };
      }
      resolveMiddleware(clientStack, configuration, options) {
        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DeleteBucketCommand.getEndpointParameterInstructions()));
        const stack = clientStack.concat(this.middlewareStack);
        const { logger } = configuration;
        const clientName = "S3Client";
        const commandName = "DeleteBucketCommand";
        const handlerExecutionContext = {
          logger,
          clientName,
          commandName,
          inputFilterSensitiveLog: models_0_1.DeleteBucketRequestFilterSensitiveLog,
          outputFilterSensitiveLog: (output) => output
        };
        const { requestHandler } = configuration;
        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
      }
      serialize(input, context) {
        return (0, Aws_restXml_1.serializeAws_restXmlDeleteBucketCommand)(input, context);
      }
      deserialize(output, context) {
        return (0, Aws_restXml_1.deserializeAws_restXmlDeleteBucketCommand)(output, context);
      }
    };
    exports.DeleteBucketCommand = DeleteBucketCommand;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/DeleteBucketCorsCommand.js
var require_DeleteBucketCorsCommand = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/DeleteBucketCorsCommand.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.DeleteBucketCorsCommand = void 0;
    var middleware_endpoint_1 = require_dist_cjs5();
    var middleware_serde_1 = require_dist_cjs3();
    var smithy_client_1 = require_dist_cjs7();
    var models_0_1 = require_models_0();
    var Aws_restXml_1 = require_Aws_restXml();
    var DeleteBucketCorsCommand = class extends smithy_client_1.Command {
      constructor(input) {
        super();
        this.input = input;
      }
      static getEndpointParameterInstructions() {
        return {
          Bucket: { type: "contextParams", name: "Bucket" },
          ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" },
          UseArnRegion: { type: "clientContextParams", name: "useArnRegion" },
          DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" },
          Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" },
          UseGlobalEndpoint: { type: "builtInParams", name: "useGlobalEndpoint" },
          UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
          Endpoint: { type: "builtInParams", name: "endpoint" },
          Region: { type: "builtInParams", name: "region" },
          UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
        };
      }
      resolveMiddleware(clientStack, configuration, options) {
        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DeleteBucketCorsCommand.getEndpointParameterInstructions()));
        const stack = clientStack.concat(this.middlewareStack);
        const { logger } = configuration;
        const clientName = "S3Client";
        const commandName = "DeleteBucketCorsCommand";
        const handlerExecutionContext = {
          logger,
          clientName,
          commandName,
          inputFilterSensitiveLog: models_0_1.DeleteBucketCorsRequestFilterSensitiveLog,
          outputFilterSensitiveLog: (output) => output
        };
        const { requestHandler } = configuration;
        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
      }
      serialize(input, context) {
        return (0, Aws_restXml_1.serializeAws_restXmlDeleteBucketCorsCommand)(input, context);
      }
      deserialize(output, context) {
        return (0, Aws_restXml_1.deserializeAws_restXmlDeleteBucketCorsCommand)(output, context);
      }
    };
    exports.DeleteBucketCorsCommand = DeleteBucketCorsCommand;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/DeleteBucketEncryptionCommand.js
var require_DeleteBucketEncryptionCommand = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/DeleteBucketEncryptionCommand.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.DeleteBucketEncryptionCommand = void 0;
    var middleware_endpoint_1 = require_dist_cjs5();
    var middleware_serde_1 = require_dist_cjs3();
    var smithy_client_1 = require_dist_cjs7();
    var models_0_1 = require_models_0();
    var Aws_restXml_1 = require_Aws_restXml();
    var DeleteBucketEncryptionCommand = class extends smithy_client_1.Command {
      constructor(input) {
        super();
        this.input = input;
      }
      static getEndpointParameterInstructions() {
        return {
          Bucket: { type: "contextParams", name: "Bucket" },
          ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" },
          UseArnRegion: { type: "clientContextParams", name: "useArnRegion" },
          DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" },
          Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" },
          UseGlobalEndpoint: { type: "builtInParams", name: "useGlobalEndpoint" },
          UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
          Endpoint: { type: "builtInParams", name: "endpoint" },
          Region: { type: "builtInParams", name: "region" },
          UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
        };
      }
      resolveMiddleware(clientStack, configuration, options) {
        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DeleteBucketEncryptionCommand.getEndpointParameterInstructions()));
        const stack = clientStack.concat(this.middlewareStack);
        const { logger } = configuration;
        const clientName = "S3Client";
        const commandName = "DeleteBucketEncryptionCommand";
        const handlerExecutionContext = {
          logger,
          clientName,
          commandName,
          inputFilterSensitiveLog: models_0_1.DeleteBucketEncryptionRequestFilterSensitiveLog,
          outputFilterSensitiveLog: (output) => output
        };
        const { requestHandler } = configuration;
        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
      }
      serialize(input, context) {
        return (0, Aws_restXml_1.serializeAws_restXmlDeleteBucketEncryptionCommand)(input, context);
      }
      deserialize(output, context) {
        return (0, Aws_restXml_1.deserializeAws_restXmlDeleteBucketEncryptionCommand)(output, context);
      }
    };
    exports.DeleteBucketEncryptionCommand = DeleteBucketEncryptionCommand;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/DeleteBucketIntelligentTieringConfigurationCommand.js
var require_DeleteBucketIntelligentTieringConfigurationCommand = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/DeleteBucketIntelligentTieringConfigurationCommand.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.DeleteBucketIntelligentTieringConfigurationCommand = void 0;
    var middleware_endpoint_1 = require_dist_cjs5();
    var middleware_serde_1 = require_dist_cjs3();
    var smithy_client_1 = require_dist_cjs7();
    var models_0_1 = require_models_0();
    var Aws_restXml_1 = require_Aws_restXml();
    var DeleteBucketIntelligentTieringConfigurationCommand = class extends smithy_client_1.Command {
      constructor(input) {
        super();
        this.input = input;
      }
      static getEndpointParameterInstructions() {
        return {
          Bucket: { type: "contextParams", name: "Bucket" },
          ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" },
          UseArnRegion: { type: "clientContextParams", name: "useArnRegion" },
          DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" },
          Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" },
          UseGlobalEndpoint: { type: "builtInParams", name: "useGlobalEndpoint" },
          UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
          Endpoint: { type: "builtInParams", name: "endpoint" },
          Region: { type: "builtInParams", name: "region" },
          UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
        };
      }
      resolveMiddleware(clientStack, configuration, options) {
        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DeleteBucketIntelligentTieringConfigurationCommand.getEndpointParameterInstructions()));
        const stack = clientStack.concat(this.middlewareStack);
        const { logger } = configuration;
        const clientName = "S3Client";
        const commandName = "DeleteBucketIntelligentTieringConfigurationCommand";
        const handlerExecutionContext = {
          logger,
          clientName,
          commandName,
          inputFilterSensitiveLog: models_0_1.DeleteBucketIntelligentTieringConfigurationRequestFilterSensitiveLog,
          outputFilterSensitiveLog: (output) => output
        };
        const { requestHandler } = configuration;
        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
      }
      serialize(input, context) {
        return (0, Aws_restXml_1.serializeAws_restXmlDeleteBucketIntelligentTieringConfigurationCommand)(input, context);
      }
      deserialize(output, context) {
        return (0, Aws_restXml_1.deserializeAws_restXmlDeleteBucketIntelligentTieringConfigurationCommand)(output, context);
      }
    };
    exports.DeleteBucketIntelligentTieringConfigurationCommand = DeleteBucketIntelligentTieringConfigurationCommand;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/DeleteBucketInventoryConfigurationCommand.js
var require_DeleteBucketInventoryConfigurationCommand = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/DeleteBucketInventoryConfigurationCommand.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.DeleteBucketInventoryConfigurationCommand = void 0;
    var middleware_endpoint_1 = require_dist_cjs5();
    var middleware_serde_1 = require_dist_cjs3();
    var smithy_client_1 = require_dist_cjs7();
    var models_0_1 = require_models_0();
    var Aws_restXml_1 = require_Aws_restXml();
    var DeleteBucketInventoryConfigurationCommand = class extends smithy_client_1.Command {
      constructor(input) {
        super();
        this.input = input;
      }
      static getEndpointParameterInstructions() {
        return {
          Bucket: { type: "contextParams", name: "Bucket" },
          ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" },
          UseArnRegion: { type: "clientContextParams", name: "useArnRegion" },
          DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" },
          Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" },
          UseGlobalEndpoint: { type: "builtInParams", name: "useGlobalEndpoint" },
          UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
          Endpoint: { type: "builtInParams", name: "endpoint" },
          Region: { type: "builtInParams", name: "region" },
          UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
        };
      }
      resolveMiddleware(clientStack, configuration, options) {
        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DeleteBucketInventoryConfigurationCommand.getEndpointParameterInstructions()));
        const stack = clientStack.concat(this.middlewareStack);
        const { logger } = configuration;
        const clientName = "S3Client";
        const commandName = "DeleteBucketInventoryConfigurationCommand";
        const handlerExecutionContext = {
          logger,
          clientName,
          commandName,
          inputFilterSensitiveLog: models_0_1.DeleteBucketInventoryConfigurationRequestFilterSensitiveLog,
          outputFilterSensitiveLog: (output) => output
        };
        const { requestHandler } = configuration;
        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
      }
      serialize(input, context) {
        return (0, Aws_restXml_1.serializeAws_restXmlDeleteBucketInventoryConfigurationCommand)(input, context);
      }
      deserialize(output, context) {
        return (0, Aws_restXml_1.deserializeAws_restXmlDeleteBucketInventoryConfigurationCommand)(output, context);
      }
    };
    exports.DeleteBucketInventoryConfigurationCommand = DeleteBucketInventoryConfigurationCommand;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/DeleteBucketLifecycleCommand.js
var require_DeleteBucketLifecycleCommand = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/DeleteBucketLifecycleCommand.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.DeleteBucketLifecycleCommand = void 0;
    var middleware_endpoint_1 = require_dist_cjs5();
    var middleware_serde_1 = require_dist_cjs3();
    var smithy_client_1 = require_dist_cjs7();
    var models_0_1 = require_models_0();
    var Aws_restXml_1 = require_Aws_restXml();
    var DeleteBucketLifecycleCommand = class extends smithy_client_1.Command {
      constructor(input) {
        super();
        this.input = input;
      }
      static getEndpointParameterInstructions() {
        return {
          Bucket: { type: "contextParams", name: "Bucket" },
          ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" },
          UseArnRegion: { type: "clientContextParams", name: "useArnRegion" },
          DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" },
          Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" },
          UseGlobalEndpoint: { type: "builtInParams", name: "useGlobalEndpoint" },
          UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
          Endpoint: { type: "builtInParams", name: "endpoint" },
          Region: { type: "builtInParams", name: "region" },
          UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
        };
      }
      resolveMiddleware(clientStack, configuration, options) {
        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DeleteBucketLifecycleCommand.getEndpointParameterInstructions()));
        const stack = clientStack.concat(this.middlewareStack);
        const { logger } = configuration;
        const clientName = "S3Client";
        const commandName = "DeleteBucketLifecycleCommand";
        const handlerExecutionContext = {
          logger,
          clientName,
          commandName,
          inputFilterSensitiveLog: models_0_1.DeleteBucketLifecycleRequestFilterSensitiveLog,
          outputFilterSensitiveLog: (output) => output
        };
        const { requestHandler } = configuration;
        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
      }
      serialize(input, context) {
        return (0, Aws_restXml_1.serializeAws_restXmlDeleteBucketLifecycleCommand)(input, context);
      }
      deserialize(output, context) {
        return (0, Aws_restXml_1.deserializeAws_restXmlDeleteBucketLifecycleCommand)(output, context);
      }
    };
    exports.DeleteBucketLifecycleCommand = DeleteBucketLifecycleCommand;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/DeleteBucketMetricsConfigurationCommand.js
var require_DeleteBucketMetricsConfigurationCommand = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/DeleteBucketMetricsConfigurationCommand.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.DeleteBucketMetricsConfigurationCommand = void 0;
    var middleware_endpoint_1 = require_dist_cjs5();
    var middleware_serde_1 = require_dist_cjs3();
    var smithy_client_1 = require_dist_cjs7();
    var models_0_1 = require_models_0();
    var Aws_restXml_1 = require_Aws_restXml();
    var DeleteBucketMetricsConfigurationCommand = class extends smithy_client_1.Command {
      constructor(input) {
        super();
        this.input = input;
      }
      static getEndpointParameterInstructions() {
        return {
          Bucket: { type: "contextParams", name: "Bucket" },
          ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" },
          UseArnRegion: { type: "clientContextParams", name: "useArnRegion" },
          DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" },
          Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" },
          UseGlobalEndpoint: { type: "builtInParams", name: "useGlobalEndpoint" },
          UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
          Endpoint: { type: "builtInParams", name: "endpoint" },
          Region: { type: "builtInParams", name: "region" },
          UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
        };
      }
      resolveMiddleware(clientStack, configuration, options) {
        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DeleteBucketMetricsConfigurationCommand.getEndpointParameterInstructions()));
        const stack = clientStack.concat(this.middlewareStack);
        const { logger } = configuration;
        const clientName = "S3Client";
        const commandName = "DeleteBucketMetricsConfigurationCommand";
        const handlerExecutionContext = {
          logger,
          clientName,
          commandName,
          inputFilterSensitiveLog: models_0_1.DeleteBucketMetricsConfigurationRequestFilterSensitiveLog,
          outputFilterSensitiveLog: (output) => output
        };
        const { requestHandler } = configuration;
        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
      }
      serialize(input, context) {
        return (0, Aws_restXml_1.serializeAws_restXmlDeleteBucketMetricsConfigurationCommand)(input, context);
      }
      deserialize(output, context) {
        return (0, Aws_restXml_1.deserializeAws_restXmlDeleteBucketMetricsConfigurationCommand)(output, context);
      }
    };
    exports.DeleteBucketMetricsConfigurationCommand = DeleteBucketMetricsConfigurationCommand;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/DeleteBucketOwnershipControlsCommand.js
var require_DeleteBucketOwnershipControlsCommand = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/DeleteBucketOwnershipControlsCommand.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.DeleteBucketOwnershipControlsCommand = void 0;
    var middleware_endpoint_1 = require_dist_cjs5();
    var middleware_serde_1 = require_dist_cjs3();
    var smithy_client_1 = require_dist_cjs7();
    var models_0_1 = require_models_0();
    var Aws_restXml_1 = require_Aws_restXml();
    var DeleteBucketOwnershipControlsCommand = class extends smithy_client_1.Command {
      constructor(input) {
        super();
        this.input = input;
      }
      static getEndpointParameterInstructions() {
        return {
          Bucket: { type: "contextParams", name: "Bucket" },
          ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" },
          UseArnRegion: { type: "clientContextParams", name: "useArnRegion" },
          DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" },
          Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" },
          UseGlobalEndpoint: { type: "builtInParams", name: "useGlobalEndpoint" },
          UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
          Endpoint: { type: "builtInParams", name: "endpoint" },
          Region: { type: "builtInParams", name: "region" },
          UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
        };
      }
      resolveMiddleware(clientStack, configuration, options) {
        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DeleteBucketOwnershipControlsCommand.getEndpointParameterInstructions()));
        const stack = clientStack.concat(this.middlewareStack);
        const { logger } = configuration;
        const clientName = "S3Client";
        const commandName = "DeleteBucketOwnershipControlsCommand";
        const handlerExecutionContext = {
          logger,
          clientName,
          commandName,
          inputFilterSensitiveLog: models_0_1.DeleteBucketOwnershipControlsRequestFilterSensitiveLog,
          outputFilterSensitiveLog: (output) => output
        };
        const { requestHandler } = configuration;
        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
      }
      serialize(input, context) {
        return (0, Aws_restXml_1.serializeAws_restXmlDeleteBucketOwnershipControlsCommand)(input, context);
      }
      deserialize(output, context) {
        return (0, Aws_restXml_1.deserializeAws_restXmlDeleteBucketOwnershipControlsCommand)(output, context);
      }
    };
    exports.DeleteBucketOwnershipControlsCommand = DeleteBucketOwnershipControlsCommand;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/DeleteBucketPolicyCommand.js
var require_DeleteBucketPolicyCommand = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/DeleteBucketPolicyCommand.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.DeleteBucketPolicyCommand = void 0;
    var middleware_endpoint_1 = require_dist_cjs5();
    var middleware_serde_1 = require_dist_cjs3();
    var smithy_client_1 = require_dist_cjs7();
    var models_0_1 = require_models_0();
    var Aws_restXml_1 = require_Aws_restXml();
    var DeleteBucketPolicyCommand = class extends smithy_client_1.Command {
      constructor(input) {
        super();
        this.input = input;
      }
      static getEndpointParameterInstructions() {
        return {
          Bucket: { type: "contextParams", name: "Bucket" },
          ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" },
          UseArnRegion: { type: "clientContextParams", name: "useArnRegion" },
          DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" },
          Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" },
          UseGlobalEndpoint: { type: "builtInParams", name: "useGlobalEndpoint" },
          UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
          Endpoint: { type: "builtInParams", name: "endpoint" },
          Region: { type: "builtInParams", name: "region" },
          UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
        };
      }
      resolveMiddleware(clientStack, configuration, options) {
        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DeleteBucketPolicyCommand.getEndpointParameterInstructions()));
        const stack = clientStack.concat(this.middlewareStack);
        const { logger } = configuration;
        const clientName = "S3Client";
        const commandName = "DeleteBucketPolicyCommand";
        const handlerExecutionContext = {
          logger,
          clientName,
          commandName,
          inputFilterSensitiveLog: models_0_1.DeleteBucketPolicyRequestFilterSensitiveLog,
          outputFilterSensitiveLog: (output) => output
        };
        const { requestHandler } = configuration;
        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
      }
      serialize(input, context) {
        return (0, Aws_restXml_1.serializeAws_restXmlDeleteBucketPolicyCommand)(input, context);
      }
      deserialize(output, context) {
        return (0, Aws_restXml_1.deserializeAws_restXmlDeleteBucketPolicyCommand)(output, context);
      }
    };
    exports.DeleteBucketPolicyCommand = DeleteBucketPolicyCommand;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/DeleteBucketReplicationCommand.js
var require_DeleteBucketReplicationCommand = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/DeleteBucketReplicationCommand.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.DeleteBucketReplicationCommand = void 0;
    var middleware_endpoint_1 = require_dist_cjs5();
    var middleware_serde_1 = require_dist_cjs3();
    var smithy_client_1 = require_dist_cjs7();
    var models_0_1 = require_models_0();
    var Aws_restXml_1 = require_Aws_restXml();
    var DeleteBucketReplicationCommand = class extends smithy_client_1.Command {
      constructor(input) {
        super();
        this.input = input;
      }
      static getEndpointParameterInstructions() {
        return {
          Bucket: { type: "contextParams", name: "Bucket" },
          ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" },
          UseArnRegion: { type: "clientContextParams", name: "useArnRegion" },
          DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" },
          Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" },
          UseGlobalEndpoint: { type: "builtInParams", name: "useGlobalEndpoint" },
          UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
          Endpoint: { type: "builtInParams", name: "endpoint" },
          Region: { type: "builtInParams", name: "region" },
          UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
        };
      }
      resolveMiddleware(clientStack, configuration, options) {
        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DeleteBucketReplicationCommand.getEndpointParameterInstructions()));
        const stack = clientStack.concat(this.middlewareStack);
        const { logger } = configuration;
        const clientName = "S3Client";
        const commandName = "DeleteBucketReplicationCommand";
        const handlerExecutionContext = {
          logger,
          clientName,
          commandName,
          inputFilterSensitiveLog: models_0_1.DeleteBucketReplicationRequestFilterSensitiveLog,
          outputFilterSensitiveLog: (output) => output
        };
        const { requestHandler } = configuration;
        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
      }
      serialize(input, context) {
        return (0, Aws_restXml_1.serializeAws_restXmlDeleteBucketReplicationCommand)(input, context);
      }
      deserialize(output, context) {
        return (0, Aws_restXml_1.deserializeAws_restXmlDeleteBucketReplicationCommand)(output, context);
      }
    };
    exports.DeleteBucketReplicationCommand = DeleteBucketReplicationCommand;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/DeleteBucketTaggingCommand.js
var require_DeleteBucketTaggingCommand = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/DeleteBucketTaggingCommand.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.DeleteBucketTaggingCommand = void 0;
    var middleware_endpoint_1 = require_dist_cjs5();
    var middleware_serde_1 = require_dist_cjs3();
    var smithy_client_1 = require_dist_cjs7();
    var models_0_1 = require_models_0();
    var Aws_restXml_1 = require_Aws_restXml();
    var DeleteBucketTaggingCommand = class extends smithy_client_1.Command {
      constructor(input) {
        super();
        this.input = input;
      }
      static getEndpointParameterInstructions() {
        return {
          Bucket: { type: "contextParams", name: "Bucket" },
          ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" },
          UseArnRegion: { type: "clientContextParams", name: "useArnRegion" },
          DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" },
          Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" },
          UseGlobalEndpoint: { type: "builtInParams", name: "useGlobalEndpoint" },
          UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
          Endpoint: { type: "builtInParams", name: "endpoint" },
          Region: { type: "builtInParams", name: "region" },
          UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
        };
      }
      resolveMiddleware(clientStack, configuration, options) {
        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DeleteBucketTaggingCommand.getEndpointParameterInstructions()));
        const stack = clientStack.concat(this.middlewareStack);
        const { logger } = configuration;
        const clientName = "S3Client";
        const commandName = "DeleteBucketTaggingCommand";
        const handlerExecutionContext = {
          logger,
          clientName,
          commandName,
          inputFilterSensitiveLog: models_0_1.DeleteBucketTaggingRequestFilterSensitiveLog,
          outputFilterSensitiveLog: (output) => output
        };
        const { requestHandler } = configuration;
        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
      }
      serialize(input, context) {
        return (0, Aws_restXml_1.serializeAws_restXmlDeleteBucketTaggingCommand)(input, context);
      }
      deserialize(output, context) {
        return (0, Aws_restXml_1.deserializeAws_restXmlDeleteBucketTaggingCommand)(output, context);
      }
    };
    exports.DeleteBucketTaggingCommand = DeleteBucketTaggingCommand;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/DeleteBucketWebsiteCommand.js
var require_DeleteBucketWebsiteCommand = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/DeleteBucketWebsiteCommand.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.DeleteBucketWebsiteCommand = void 0;
    var middleware_endpoint_1 = require_dist_cjs5();
    var middleware_serde_1 = require_dist_cjs3();
    var smithy_client_1 = require_dist_cjs7();
    var models_0_1 = require_models_0();
    var Aws_restXml_1 = require_Aws_restXml();
    var DeleteBucketWebsiteCommand = class extends smithy_client_1.Command {
      constructor(input) {
        super();
        this.input = input;
      }
      static getEndpointParameterInstructions() {
        return {
          Bucket: { type: "contextParams", name: "Bucket" },
          ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" },
          UseArnRegion: { type: "clientContextParams", name: "useArnRegion" },
          DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" },
          Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" },
          UseGlobalEndpoint: { type: "builtInParams", name: "useGlobalEndpoint" },
          UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
          Endpoint: { type: "builtInParams", name: "endpoint" },
          Region: { type: "builtInParams", name: "region" },
          UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
        };
      }
      resolveMiddleware(clientStack, configuration, options) {
        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DeleteBucketWebsiteCommand.getEndpointParameterInstructions()));
        const stack = clientStack.concat(this.middlewareStack);
        const { logger } = configuration;
        const clientName = "S3Client";
        const commandName = "DeleteBucketWebsiteCommand";
        const handlerExecutionContext = {
          logger,
          clientName,
          commandName,
          inputFilterSensitiveLog: models_0_1.DeleteBucketWebsiteRequestFilterSensitiveLog,
          outputFilterSensitiveLog: (output) => output
        };
        const { requestHandler } = configuration;
        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
      }
      serialize(input, context) {
        return (0, Aws_restXml_1.serializeAws_restXmlDeleteBucketWebsiteCommand)(input, context);
      }
      deserialize(output, context) {
        return (0, Aws_restXml_1.deserializeAws_restXmlDeleteBucketWebsiteCommand)(output, context);
      }
    };
    exports.DeleteBucketWebsiteCommand = DeleteBucketWebsiteCommand;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/DeleteObjectCommand.js
var require_DeleteObjectCommand = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/DeleteObjectCommand.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.DeleteObjectCommand = void 0;
    var middleware_endpoint_1 = require_dist_cjs5();
    var middleware_serde_1 = require_dist_cjs3();
    var smithy_client_1 = require_dist_cjs7();
    var models_0_1 = require_models_0();
    var Aws_restXml_1 = require_Aws_restXml();
    var DeleteObjectCommand = class extends smithy_client_1.Command {
      constructor(input) {
        super();
        this.input = input;
      }
      static getEndpointParameterInstructions() {
        return {
          Bucket: { type: "contextParams", name: "Bucket" },
          ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" },
          UseArnRegion: { type: "clientContextParams", name: "useArnRegion" },
          DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" },
          Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" },
          UseGlobalEndpoint: { type: "builtInParams", name: "useGlobalEndpoint" },
          UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
          Endpoint: { type: "builtInParams", name: "endpoint" },
          Region: { type: "builtInParams", name: "region" },
          UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
        };
      }
      resolveMiddleware(clientStack, configuration, options) {
        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DeleteObjectCommand.getEndpointParameterInstructions()));
        const stack = clientStack.concat(this.middlewareStack);
        const { logger } = configuration;
        const clientName = "S3Client";
        const commandName = "DeleteObjectCommand";
        const handlerExecutionContext = {
          logger,
          clientName,
          commandName,
          inputFilterSensitiveLog: models_0_1.DeleteObjectRequestFilterSensitiveLog,
          outputFilterSensitiveLog: models_0_1.DeleteObjectOutputFilterSensitiveLog
        };
        const { requestHandler } = configuration;
        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
      }
      serialize(input, context) {
        return (0, Aws_restXml_1.serializeAws_restXmlDeleteObjectCommand)(input, context);
      }
      deserialize(output, context) {
        return (0, Aws_restXml_1.deserializeAws_restXmlDeleteObjectCommand)(output, context);
      }
    };
    exports.DeleteObjectCommand = DeleteObjectCommand;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+middleware-flexible-checksums@3.272.0/node_modules/@aws-sdk/middleware-flexible-checksums/dist-cjs/constants.js
var require_constants2 = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+middleware-flexible-checksums@3.272.0/node_modules/@aws-sdk/middleware-flexible-checksums/dist-cjs/constants.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.ChecksumLocation = exports.ChecksumAlgorithm = void 0;
    var ChecksumAlgorithm;
    (function(ChecksumAlgorithm2) {
      ChecksumAlgorithm2["MD5"] = "MD5";
      ChecksumAlgorithm2["CRC32"] = "CRC32";
      ChecksumAlgorithm2["CRC32C"] = "CRC32C";
      ChecksumAlgorithm2["SHA1"] = "SHA1";
      ChecksumAlgorithm2["SHA256"] = "SHA256";
    })(ChecksumAlgorithm = exports.ChecksumAlgorithm || (exports.ChecksumAlgorithm = {}));
    var ChecksumLocation;
    (function(ChecksumLocation2) {
      ChecksumLocation2["HEADER"] = "header";
      ChecksumLocation2["TRAILER"] = "trailer";
    })(ChecksumLocation = exports.ChecksumLocation || (exports.ChecksumLocation = {}));
  }
});

// ../../node_modules/.pnpm/@aws-sdk+middleware-flexible-checksums@3.272.0/node_modules/@aws-sdk/middleware-flexible-checksums/dist-cjs/types.js
var require_types2 = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+middleware-flexible-checksums@3.272.0/node_modules/@aws-sdk/middleware-flexible-checksums/dist-cjs/types.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.PRIORITY_ORDER_ALGORITHMS = exports.CLIENT_SUPPORTED_ALGORITHMS = void 0;
    var constants_1 = require_constants2();
    exports.CLIENT_SUPPORTED_ALGORITHMS = [
      constants_1.ChecksumAlgorithm.CRC32,
      constants_1.ChecksumAlgorithm.CRC32C,
      constants_1.ChecksumAlgorithm.SHA1,
      constants_1.ChecksumAlgorithm.SHA256
    ];
    exports.PRIORITY_ORDER_ALGORITHMS = [
      constants_1.ChecksumAlgorithm.CRC32,
      constants_1.ChecksumAlgorithm.CRC32C,
      constants_1.ChecksumAlgorithm.SHA1,
      constants_1.ChecksumAlgorithm.SHA256
    ];
  }
});

// ../../node_modules/.pnpm/@aws-sdk+middleware-flexible-checksums@3.272.0/node_modules/@aws-sdk/middleware-flexible-checksums/dist-cjs/getChecksumAlgorithmForRequest.js
var require_getChecksumAlgorithmForRequest = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+middleware-flexible-checksums@3.272.0/node_modules/@aws-sdk/middleware-flexible-checksums/dist-cjs/getChecksumAlgorithmForRequest.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.getChecksumAlgorithmForRequest = void 0;
    var constants_1 = require_constants2();
    var types_1 = require_types2();
    var getChecksumAlgorithmForRequest = (input, { requestChecksumRequired, requestAlgorithmMember }) => {
      if (!requestAlgorithmMember || !input[requestAlgorithmMember]) {
        return requestChecksumRequired ? constants_1.ChecksumAlgorithm.MD5 : void 0;
      }
      const checksumAlgorithm = input[requestAlgorithmMember];
      if (!types_1.CLIENT_SUPPORTED_ALGORITHMS.includes(checksumAlgorithm)) {
        throw new Error(`The checksum algorithm "${checksumAlgorithm}" is not supported by the client. Select one of ${types_1.CLIENT_SUPPORTED_ALGORITHMS}.`);
      }
      return checksumAlgorithm;
    };
    exports.getChecksumAlgorithmForRequest = getChecksumAlgorithmForRequest;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+middleware-flexible-checksums@3.272.0/node_modules/@aws-sdk/middleware-flexible-checksums/dist-cjs/getChecksumLocationName.js
var require_getChecksumLocationName = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+middleware-flexible-checksums@3.272.0/node_modules/@aws-sdk/middleware-flexible-checksums/dist-cjs/getChecksumLocationName.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.getChecksumLocationName = void 0;
    var constants_1 = require_constants2();
    var getChecksumLocationName = (algorithm) => algorithm === constants_1.ChecksumAlgorithm.MD5 ? "content-md5" : `x-amz-checksum-${algorithm.toLowerCase()}`;
    exports.getChecksumLocationName = getChecksumLocationName;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+middleware-flexible-checksums@3.272.0/node_modules/@aws-sdk/middleware-flexible-checksums/dist-cjs/hasHeader.js
var require_hasHeader = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+middleware-flexible-checksums@3.272.0/node_modules/@aws-sdk/middleware-flexible-checksums/dist-cjs/hasHeader.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.hasHeader = void 0;
    var hasHeader = (header, headers) => {
      const soughtHeader = header.toLowerCase();
      for (const headerName of Object.keys(headers)) {
        if (soughtHeader === headerName.toLowerCase()) {
          return true;
        }
      }
      return false;
    };
    exports.hasHeader = hasHeader;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+is-array-buffer@3.201.0/node_modules/@aws-sdk/is-array-buffer/dist-cjs/index.js
var require_dist_cjs14 = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+is-array-buffer@3.201.0/node_modules/@aws-sdk/is-array-buffer/dist-cjs/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.isArrayBuffer = void 0;
    var isArrayBuffer2 = (arg) => typeof ArrayBuffer === "function" && arg instanceof ArrayBuffer || Object.prototype.toString.call(arg) === "[object ArrayBuffer]";
    exports.isArrayBuffer = isArrayBuffer2;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+middleware-flexible-checksums@3.272.0/node_modules/@aws-sdk/middleware-flexible-checksums/dist-cjs/isStreaming.js
var require_isStreaming = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+middleware-flexible-checksums@3.272.0/node_modules/@aws-sdk/middleware-flexible-checksums/dist-cjs/isStreaming.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.isStreaming = void 0;
    var is_array_buffer_1 = require_dist_cjs14();
    var isStreaming = (body) => body !== void 0 && typeof body !== "string" && !ArrayBuffer.isView(body) && !(0, is_array_buffer_1.isArrayBuffer)(body);
    exports.isStreaming = isStreaming;
  }
});

// ../../node_modules/.pnpm/tslib@1.14.1/node_modules/tslib/tslib.es6.js
var tslib_es6_exports2 = {};
__export(tslib_es6_exports2, {
  __assign: () => __assign2,
  __asyncDelegator: () => __asyncDelegator2,
  __asyncGenerator: () => __asyncGenerator2,
  __asyncValues: () => __asyncValues2,
  __await: () => __await2,
  __awaiter: () => __awaiter2,
  __classPrivateFieldGet: () => __classPrivateFieldGet2,
  __classPrivateFieldSet: () => __classPrivateFieldSet2,
  __createBinding: () => __createBinding2,
  __decorate: () => __decorate2,
  __exportStar: () => __exportStar2,
  __extends: () => __extends2,
  __generator: () => __generator2,
  __importDefault: () => __importDefault2,
  __importStar: () => __importStar2,
  __makeTemplateObject: () => __makeTemplateObject2,
  __metadata: () => __metadata2,
  __param: () => __param2,
  __read: () => __read2,
  __rest: () => __rest2,
  __spread: () => __spread2,
  __spreadArrays: () => __spreadArrays2,
  __values: () => __values2
});
function __extends2(d, b) {
  extendStatics2(d, b);
  function __() {
    this.constructor = d;
  }
  d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
}
function __rest2(s, e) {
  var t = {};
  for (var p in s)
    if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
      t[p] = s[p];
  if (s != null && typeof Object.getOwnPropertySymbols === "function")
    for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
      if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
        t[p[i]] = s[p[i]];
    }
  return t;
}
function __decorate2(decorators, target, key, desc) {
  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
    r = Reflect.decorate(decorators, target, key, desc);
  else
    for (var i = decorators.length - 1; i >= 0; i--)
      if (d = decorators[i])
        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
  return c > 3 && r && Object.defineProperty(target, key, r), r;
}
function __param2(paramIndex, decorator) {
  return function(target, key) {
    decorator(target, key, paramIndex);
  };
}
function __metadata2(metadataKey, metadataValue) {
  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
    return Reflect.metadata(metadataKey, metadataValue);
}
function __awaiter2(thisArg, _arguments, P, generator) {
  function adopt(value) {
    return value instanceof P ? value : new P(function(resolve) {
      resolve(value);
    });
  }
  return new (P || (P = Promise))(function(resolve, reject) {
    function fulfilled(value) {
      try {
        step(generator.next(value));
      } catch (e) {
        reject(e);
      }
    }
    function rejected(value) {
      try {
        step(generator["throw"](value));
      } catch (e) {
        reject(e);
      }
    }
    function step(result) {
      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
    }
    step((generator = generator.apply(thisArg, _arguments || [])).next());
  });
}
function __generator2(thisArg, body) {
  var _ = { label: 0, sent: function() {
    if (t[0] & 1)
      throw t[1];
    return t[1];
  }, trys: [], ops: [] }, f, y, t, g;
  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 __createBinding2(o, m, k, k2) {
  if (k2 === void 0)
    k2 = k;
  o[k2] = m[k];
}
function __exportStar2(m, exports) {
  for (var p in m)
    if (p !== "default" && !exports.hasOwnProperty(p))
      exports[p] = m[p];
}
function __values2(o) {
  var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
  if (m)
    return m.call(o);
  if (o && typeof o.length === "number")
    return {
      next: function() {
        if (o && i >= o.length)
          o = void 0;
        return { value: o && o[i++], done: !o };
      }
    };
  throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
}
function __read2(o, n) {
  var m = typeof Symbol === "function" && o[Symbol.iterator];
  if (!m)
    return o;
  var i = m.call(o), r, ar = [], e;
  try {
    while ((n === void 0 || n-- > 0) && !(r = i.next()).done)
      ar.push(r.value);
  } catch (error) {
    e = { error };
  } finally {
    try {
      if (r && !r.done && (m = i["return"]))
        m.call(i);
    } finally {
      if (e)
        throw e.error;
    }
  }
  return ar;
}
function __spread2() {
  for (var ar = [], i = 0; i < arguments.length; i++)
    ar = ar.concat(__read2(arguments[i]));
  return ar;
}
function __spreadArrays2() {
  for (var s = 0, i = 0, il = arguments.length; i < il; i++)
    s += arguments[i].length;
  for (var r = Array(s), k = 0, i = 0; i < il; i++)
    for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
      r[k] = a[j];
  return r;
}
function __await2(v) {
  return this instanceof __await2 ? (this.v = v, this) : new __await2(v);
}
function __asyncGenerator2(thisArg, _arguments, generator) {
  if (!Symbol.asyncIterator)
    throw new TypeError("Symbol.asyncIterator is not defined.");
  var g = generator.apply(thisArg, _arguments || []), i, q = [];
  return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() {
    return this;
  }, i;
  function verb(n) {
    if (g[n])
      i[n] = function(v) {
        return new Promise(function(a, b) {
          q.push([n, v, a, b]) > 1 || resume(n, v);
        });
      };
  }
  function resume(n, v) {
    try {
      step(g[n](v));
    } catch (e) {
      settle2(q[0][3], e);
    }
  }
  function step(r) {
    r.value instanceof __await2 ? Promise.resolve(r.value.v).then(fulfill, reject) : settle2(q[0][2], r);
  }
  function fulfill(value) {
    resume("next", value);
  }
  function reject(value) {
    resume("throw", value);
  }
  function settle2(f, v) {
    if (f(v), q.shift(), q.length)
      resume(q[0][0], q[0][1]);
  }
}
function __asyncDelegator2(o) {
  var i, p;
  return i = {}, verb("next"), verb("throw", function(e) {
    throw e;
  }), verb("return"), i[Symbol.iterator] = function() {
    return this;
  }, i;
  function verb(n, f) {
    i[n] = o[n] ? function(v) {
      return (p = !p) ? { value: __await2(o[n](v)), done: n === "return" } : f ? f(v) : v;
    } : f;
  }
}
function __asyncValues2(o) {
  if (!Symbol.asyncIterator)
    throw new TypeError("Symbol.asyncIterator is not defined.");
  var m = o[Symbol.asyncIterator], i;
  return m ? m.call(o) : (o = typeof __values2 === "function" ? __values2(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() {
    return this;
  }, i);
  function verb(n) {
    i[n] = o[n] && function(v) {
      return new Promise(function(resolve, reject) {
        v = o[n](v), settle2(resolve, reject, v.done, v.value);
      });
    };
  }
  function settle2(resolve, reject, d, v) {
    Promise.resolve(v).then(function(v2) {
      resolve({ value: v2, done: d });
    }, reject);
  }
}
function __makeTemplateObject2(cooked, raw) {
  if (Object.defineProperty) {
    Object.defineProperty(cooked, "raw", { value: raw });
  } else {
    cooked.raw = raw;
  }
  return cooked;
}
function __importStar2(mod) {
  if (mod && mod.__esModule)
    return mod;
  var result = {};
  if (mod != null) {
    for (var k in mod)
      if (Object.hasOwnProperty.call(mod, k))
        result[k] = mod[k];
  }
  result.default = mod;
  return result;
}
function __importDefault2(mod) {
  return mod && mod.__esModule ? mod : { default: mod };
}
function __classPrivateFieldGet2(receiver, privateMap) {
  if (!privateMap.has(receiver)) {
    throw new TypeError("attempted to get private field on non-instance");
  }
  return privateMap.get(receiver);
}
function __classPrivateFieldSet2(receiver, privateMap, value) {
  if (!privateMap.has(receiver)) {
    throw new TypeError("attempted to set private field on non-instance");
  }
  privateMap.set(receiver, value);
  return value;
}
var extendStatics2, __assign2;
var init_tslib_es62 = __esm({
  "../../node_modules/.pnpm/tslib@1.14.1/node_modules/tslib/tslib.es6.js"() {
    extendStatics2 = function(d, b) {
      extendStatics2 = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
        d2.__proto__ = b2;
      } || function(d2, b2) {
        for (var p in b2)
          if (b2.hasOwnProperty(p))
            d2[p] = b2[p];
      };
      return extendStatics2(d, b);
    };
    __assign2 = function() {
      __assign2 = Object.assign || function __assign3(t) {
        for (var s, i = 1, n = arguments.length; i < n; i++) {
          s = arguments[i];
          for (var p in s)
            if (Object.prototype.hasOwnProperty.call(s, p))
              t[p] = s[p];
        }
        return t;
      };
      return __assign2.apply(this, arguments);
    };
  }
});

// ../../node_modules/.pnpm/@aws-sdk+util-utf8-browser@3.188.0/node_modules/@aws-sdk/util-utf8-browser/dist-cjs/pureJs.js
var require_pureJs = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+util-utf8-browser@3.188.0/node_modules/@aws-sdk/util-utf8-browser/dist-cjs/pureJs.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.toUtf8 = exports.fromUtf8 = void 0;
    var fromUtf8 = (input) => {
      const bytes = [];
      for (let i = 0, len = input.length; i < len; i++) {
        const value = input.charCodeAt(i);
        if (value < 128) {
          bytes.push(value);
        } else if (value < 2048) {
          bytes.push(value >> 6 | 192, value & 63 | 128);
        } else if (i + 1 < input.length && (value & 64512) === 55296 && (input.charCodeAt(i + 1) & 64512) === 56320) {
          const surrogatePair = 65536 + ((value & 1023) << 10) + (input.charCodeAt(++i) & 1023);
          bytes.push(surrogatePair >> 18 | 240, surrogatePair >> 12 & 63 | 128, surrogatePair >> 6 & 63 | 128, surrogatePair & 63 | 128);
        } else {
          bytes.push(value >> 12 | 224, value >> 6 & 63 | 128, value & 63 | 128);
        }
      }
      return Uint8Array.from(bytes);
    };
    exports.fromUtf8 = fromUtf8;
    var toUtf8 = (input) => {
      let decoded = "";
      for (let i = 0, len = input.length; i < len; i++) {
        const byte = input[i];
        if (byte < 128) {
          decoded += String.fromCharCode(byte);
        } else if (192 <= byte && byte < 224) {
          const nextByte = input[++i];
          decoded += String.fromCharCode((byte & 31) << 6 | nextByte & 63);
        } else if (240 <= byte && byte < 365) {
          const surrogatePair = [byte, input[++i], input[++i], input[++i]];
          const encoded = "%" + surrogatePair.map((byteValue) => byteValue.toString(16)).join("%");
          decoded += decodeURIComponent(encoded);
        } else {
          decoded += String.fromCharCode((byte & 15) << 12 | (input[++i] & 63) << 6 | input[++i] & 63);
        }
      }
      return decoded;
    };
    exports.toUtf8 = toUtf8;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+util-utf8-browser@3.188.0/node_modules/@aws-sdk/util-utf8-browser/dist-cjs/whatwgEncodingApi.js
var require_whatwgEncodingApi = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+util-utf8-browser@3.188.0/node_modules/@aws-sdk/util-utf8-browser/dist-cjs/whatwgEncodingApi.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.toUtf8 = exports.fromUtf8 = void 0;
    function fromUtf8(input) {
      return new TextEncoder().encode(input);
    }
    exports.fromUtf8 = fromUtf8;
    function toUtf8(input) {
      return new TextDecoder("utf-8").decode(input);
    }
    exports.toUtf8 = toUtf8;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+util-utf8-browser@3.188.0/node_modules/@aws-sdk/util-utf8-browser/dist-cjs/index.js
var require_dist_cjs15 = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+util-utf8-browser@3.188.0/node_modules/@aws-sdk/util-utf8-browser/dist-cjs/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.toUtf8 = exports.fromUtf8 = void 0;
    var pureJs_1 = require_pureJs();
    var whatwgEncodingApi_1 = require_whatwgEncodingApi();
    var fromUtf8 = (input) => typeof TextEncoder === "function" ? (0, whatwgEncodingApi_1.fromUtf8)(input) : (0, pureJs_1.fromUtf8)(input);
    exports.fromUtf8 = fromUtf8;
    var toUtf8 = (input) => typeof TextDecoder === "function" ? (0, whatwgEncodingApi_1.toUtf8)(input) : (0, pureJs_1.toUtf8)(input);
    exports.toUtf8 = toUtf8;
  }
});

// ../../node_modules/.pnpm/@aws-crypto+util@3.0.0/node_modules/@aws-crypto/util/build/convertToBuffer.js
var require_convertToBuffer = __commonJS({
  "../../node_modules/.pnpm/@aws-crypto+util@3.0.0/node_modules/@aws-crypto/util/build/convertToBuffer.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.convertToBuffer = void 0;
    var util_utf8_browser_1 = require_dist_cjs15();
    var fromUtf8 = typeof Buffer !== "undefined" && Buffer.from ? function(input) {
      return Buffer.from(input, "utf8");
    } : util_utf8_browser_1.fromUtf8;
    function convertToBuffer(data) {
      if (data instanceof Uint8Array)
        return data;
      if (typeof data === "string") {
        return fromUtf8(data);
      }
      if (ArrayBuffer.isView(data)) {
        return new Uint8Array(data.buffer, data.byteOffset, data.byteLength / Uint8Array.BYTES_PER_ELEMENT);
      }
      return new Uint8Array(data);
    }
    exports.convertToBuffer = convertToBuffer;
  }
});

// ../../node_modules/.pnpm/@aws-crypto+util@3.0.0/node_modules/@aws-crypto/util/build/isEmptyData.js
var require_isEmptyData = __commonJS({
  "../../node_modules/.pnpm/@aws-crypto+util@3.0.0/node_modules/@aws-crypto/util/build/isEmptyData.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.isEmptyData = void 0;
    function isEmptyData(data) {
      if (typeof data === "string") {
        return data.length === 0;
      }
      return data.byteLength === 0;
    }
    exports.isEmptyData = isEmptyData;
  }
});

// ../../node_modules/.pnpm/@aws-crypto+util@3.0.0/node_modules/@aws-crypto/util/build/numToUint8.js
var require_numToUint8 = __commonJS({
  "../../node_modules/.pnpm/@aws-crypto+util@3.0.0/node_modules/@aws-crypto/util/build/numToUint8.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.numToUint8 = void 0;
    function numToUint8(num) {
      return new Uint8Array([
        (num & 4278190080) >> 24,
        (num & 16711680) >> 16,
        (num & 65280) >> 8,
        num & 255
      ]);
    }
    exports.numToUint8 = numToUint8;
  }
});

// ../../node_modules/.pnpm/@aws-crypto+util@3.0.0/node_modules/@aws-crypto/util/build/uint32ArrayFrom.js
var require_uint32ArrayFrom = __commonJS({
  "../../node_modules/.pnpm/@aws-crypto+util@3.0.0/node_modules/@aws-crypto/util/build/uint32ArrayFrom.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.uint32ArrayFrom = void 0;
    function uint32ArrayFrom(a_lookUpTable) {
      if (!Uint32Array.from) {
        var return_array = new Uint32Array(a_lookUpTable.length);
        var a_index = 0;
        while (a_index < a_lookUpTable.length) {
          return_array[a_index] = a_lookUpTable[a_index];
          a_index += 1;
        }
        return return_array;
      }
      return Uint32Array.from(a_lookUpTable);
    }
    exports.uint32ArrayFrom = uint32ArrayFrom;
  }
});

// ../../node_modules/.pnpm/@aws-crypto+util@3.0.0/node_modules/@aws-crypto/util/build/index.js
var require_build = __commonJS({
  "../../node_modules/.pnpm/@aws-crypto+util@3.0.0/node_modules/@aws-crypto/util/build/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.uint32ArrayFrom = exports.numToUint8 = exports.isEmptyData = exports.convertToBuffer = void 0;
    var convertToBuffer_1 = require_convertToBuffer();
    Object.defineProperty(exports, "convertToBuffer", { enumerable: true, get: function() {
      return convertToBuffer_1.convertToBuffer;
    } });
    var isEmptyData_1 = require_isEmptyData();
    Object.defineProperty(exports, "isEmptyData", { enumerable: true, get: function() {
      return isEmptyData_1.isEmptyData;
    } });
    var numToUint8_1 = require_numToUint8();
    Object.defineProperty(exports, "numToUint8", { enumerable: true, get: function() {
      return numToUint8_1.numToUint8;
    } });
    var uint32ArrayFrom_1 = require_uint32ArrayFrom();
    Object.defineProperty(exports, "uint32ArrayFrom", { enumerable: true, get: function() {
      return uint32ArrayFrom_1.uint32ArrayFrom;
    } });
  }
});

// ../../node_modules/.pnpm/@aws-crypto+crc32@3.0.0/node_modules/@aws-crypto/crc32/build/aws_crc32.js
var require_aws_crc32 = __commonJS({
  "../../node_modules/.pnpm/@aws-crypto+crc32@3.0.0/node_modules/@aws-crypto/crc32/build/aws_crc32.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.AwsCrc32 = void 0;
    var tslib_1 = (init_tslib_es62(), __toCommonJS(tslib_es6_exports2));
    var util_1 = require_build();
    var index_1 = require_build2();
    var AwsCrc32 = (
      /** @class */
      function() {
        function AwsCrc322() {
          this.crc32 = new index_1.Crc32();
        }
        AwsCrc322.prototype.update = function(toHash) {
          if ((0, util_1.isEmptyData)(toHash))
            return;
          this.crc32.update((0, util_1.convertToBuffer)(toHash));
        };
        AwsCrc322.prototype.digest = function() {
          return tslib_1.__awaiter(this, void 0, void 0, function() {
            return tslib_1.__generator(this, function(_a) {
              return [2, (0, util_1.numToUint8)(this.crc32.digest())];
            });
          });
        };
        AwsCrc322.prototype.reset = function() {
          this.crc32 = new index_1.Crc32();
        };
        return AwsCrc322;
      }()
    );
    exports.AwsCrc32 = AwsCrc32;
  }
});

// ../../node_modules/.pnpm/@aws-crypto+crc32@3.0.0/node_modules/@aws-crypto/crc32/build/index.js
var require_build2 = __commonJS({
  "../../node_modules/.pnpm/@aws-crypto+crc32@3.0.0/node_modules/@aws-crypto/crc32/build/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.AwsCrc32 = exports.Crc32 = exports.crc32 = void 0;
    var tslib_1 = (init_tslib_es62(), __toCommonJS(tslib_es6_exports2));
    var util_1 = require_build();
    function crc32(data) {
      return new Crc32().update(data).digest();
    }
    exports.crc32 = crc32;
    var Crc32 = (
      /** @class */
      function() {
        function Crc322() {
          this.checksum = 4294967295;
        }
        Crc322.prototype.update = function(data) {
          var e_1, _a;
          try {
            for (var data_1 = tslib_1.__values(data), data_1_1 = data_1.next(); !data_1_1.done; data_1_1 = data_1.next()) {
              var byte = data_1_1.value;
              this.checksum = this.checksum >>> 8 ^ lookupTable[(this.checksum ^ byte) & 255];
            }
          } catch (e_1_1) {
            e_1 = { error: e_1_1 };
          } finally {
            try {
              if (data_1_1 && !data_1_1.done && (_a = data_1.return))
                _a.call(data_1);
            } finally {
              if (e_1)
                throw e_1.error;
            }
          }
          return this;
        };
        Crc322.prototype.digest = function() {
          return (this.checksum ^ 4294967295) >>> 0;
        };
        return Crc322;
      }()
    );
    exports.Crc32 = Crc32;
    var a_lookUpTable = [
      0,
      1996959894,
      3993919788,
      2567524794,
      124634137,
      1886057615,
      3915621685,
      2657392035,
      249268274,
      2044508324,
      3772115230,
      2547177864,
      162941995,
      2125561021,
      3887607047,
      2428444049,
      498536548,
      1789927666,
      4089016648,
      2227061214,
      450548861,
      1843258603,
      4107580753,
      2211677639,
      325883990,
      1684777152,
      4251122042,
      2321926636,
      335633487,
      1661365465,
      4195302755,
      2366115317,
      997073096,
      1281953886,
      3579855332,
      2724688242,
      1006888145,
      1258607687,
      3524101629,
      2768942443,
      901097722,
      1119000684,
      3686517206,
      2898065728,
      853044451,
      1172266101,
      3705015759,
      2882616665,
      651767980,
      1373503546,
      3369554304,
      3218104598,
      565507253,
      1454621731,
      3485111705,
      3099436303,
      671266974,
      1594198024,
      3322730930,
      2970347812,
      795835527,
      1483230225,
      3244367275,
      3060149565,
      1994146192,
      31158534,
      2563907772,
      4023717930,
      1907459465,
      112637215,
      2680153253,
      3904427059,
      2013776290,
      251722036,
      2517215374,
      3775830040,
      2137656763,
      141376813,
      2439277719,
      3865271297,
      1802195444,
      476864866,
      2238001368,
      4066508878,
      1812370925,
      453092731,
      2181625025,
      4111451223,
      1706088902,
      314042704,
      2344532202,
      4240017532,
      1658658271,
      366619977,
      2362670323,
      4224994405,
      1303535960,
      984961486,
      2747007092,
      3569037538,
      1256170817,
      1037604311,
      2765210733,
      3554079995,
      1131014506,
      879679996,
      2909243462,
      3663771856,
      1141124467,
      855842277,
      2852801631,
      3708648649,
      1342533948,
      654459306,
      3188396048,
      3373015174,
      1466479909,
      544179635,
      3110523913,
      3462522015,
      1591671054,
      702138776,
      2966460450,
      3352799412,
      1504918807,
      783551873,
      3082640443,
      3233442989,
      3988292384,
      2596254646,
      62317068,
      1957810842,
      3939845945,
      2647816111,
      81470997,
      1943803523,
      3814918930,
      2489596804,
      225274430,
      2053790376,
      3826175755,
      2466906013,
      167816743,
      2097651377,
      4027552580,
      2265490386,
      503444072,
      1762050814,
      4150417245,
      2154129355,
      426522225,
      1852507879,
      4275313526,
      2312317920,
      282753626,
      1742555852,
      4189708143,
      2394877945,
      397917763,
      1622183637,
      3604390888,
      2714866558,
      953729732,
      1340076626,
      3518719985,
      2797360999,
      1068828381,
      1219638859,
      3624741850,
      2936675148,
      906185462,
      1090812512,
      3747672003,
      2825379669,
      829329135,
      1181335161,
      3412177804,
      3160834842,
      628085408,
      1382605366,
      3423369109,
      3138078467,
      570562233,
      1426400815,
      3317316542,
      2998733608,
      733239954,
      1555261956,
      3268935591,
      3050360625,
      752459403,
      1541320221,
      2607071920,
      3965973030,
      1969922972,
      40735498,
      2617837225,
      3943577151,
      1913087877,
      83908371,
      2512341634,
      3803740692,
      2075208622,
      213261112,
      2463272603,
      3855990285,
      2094854071,
      198958881,
      2262029012,
      4057260610,
      1759359992,
      534414190,
      2176718541,
      4139329115,
      1873836001,
      414664567,
      2282248934,
      4279200368,
      1711684554,
      285281116,
      2405801727,
      4167216745,
      1634467795,
      376229701,
      2685067896,
      3608007406,
      1308918612,
      956543938,
      2808555105,
      3495958263,
      1231636301,
      1047427035,
      2932959818,
      3654703836,
      1088359270,
      936918e3,
      2847714899,
      3736837829,
      1202900863,
      817233897,
      3183342108,
      3401237130,
      1404277552,
      615818150,
      3134207493,
      3453421203,
      1423857449,
      601450431,
      3009837614,
      3294710456,
      1567103746,
      711928724,
      3020668471,
      3272380065,
      1510334235,
      755167117
    ];
    var lookupTable = (0, util_1.uint32ArrayFrom)(a_lookUpTable);
    var aws_crc32_1 = require_aws_crc32();
    Object.defineProperty(exports, "AwsCrc32", { enumerable: true, get: function() {
      return aws_crc32_1.AwsCrc32;
    } });
  }
});

// ../../node_modules/.pnpm/@aws-crypto+crc32c@3.0.0/node_modules/@aws-crypto/crc32c/build/aws_crc32c.js
var require_aws_crc32c = __commonJS({
  "../../node_modules/.pnpm/@aws-crypto+crc32c@3.0.0/node_modules/@aws-crypto/crc32c/build/aws_crc32c.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.AwsCrc32c = void 0;
    var tslib_1 = (init_tslib_es62(), __toCommonJS(tslib_es6_exports2));
    var util_1 = require_build();
    var index_1 = require_build3();
    var AwsCrc32c = (
      /** @class */
      function() {
        function AwsCrc32c2() {
          this.crc32c = new index_1.Crc32c();
        }
        AwsCrc32c2.prototype.update = function(toHash) {
          if ((0, util_1.isEmptyData)(toHash))
            return;
          this.crc32c.update((0, util_1.convertToBuffer)(toHash));
        };
        AwsCrc32c2.prototype.digest = function() {
          return tslib_1.__awaiter(this, void 0, void 0, function() {
            return tslib_1.__generator(this, function(_a) {
              return [2, (0, util_1.numToUint8)(this.crc32c.digest())];
            });
          });
        };
        AwsCrc32c2.prototype.reset = function() {
          this.crc32c = new index_1.Crc32c();
        };
        return AwsCrc32c2;
      }()
    );
    exports.AwsCrc32c = AwsCrc32c;
  }
});

// ../../node_modules/.pnpm/@aws-crypto+crc32c@3.0.0/node_modules/@aws-crypto/crc32c/build/index.js
var require_build3 = __commonJS({
  "../../node_modules/.pnpm/@aws-crypto+crc32c@3.0.0/node_modules/@aws-crypto/crc32c/build/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.AwsCrc32c = exports.Crc32c = exports.crc32c = void 0;
    var tslib_1 = (init_tslib_es62(), __toCommonJS(tslib_es6_exports2));
    var util_1 = require_build();
    function crc32c(data) {
      return new Crc32c().update(data).digest();
    }
    exports.crc32c = crc32c;
    var Crc32c = (
      /** @class */
      function() {
        function Crc32c2() {
          this.checksum = 4294967295;
        }
        Crc32c2.prototype.update = function(data) {
          var e_1, _a;
          try {
            for (var data_1 = tslib_1.__values(data), data_1_1 = data_1.next(); !data_1_1.done; data_1_1 = data_1.next()) {
              var byte = data_1_1.value;
              this.checksum = this.checksum >>> 8 ^ lookupTable[(this.checksum ^ byte) & 255];
            }
          } catch (e_1_1) {
            e_1 = { error: e_1_1 };
          } finally {
            try {
              if (data_1_1 && !data_1_1.done && (_a = data_1.return))
                _a.call(data_1);
            } finally {
              if (e_1)
                throw e_1.error;
            }
          }
          return this;
        };
        Crc32c2.prototype.digest = function() {
          return (this.checksum ^ 4294967295) >>> 0;
        };
        return Crc32c2;
      }()
    );
    exports.Crc32c = Crc32c;
    var a_lookupTable = [
      0,
      4067132163,
      3778769143,
      324072436,
      3348797215,
      904991772,
      648144872,
      3570033899,
      2329499855,
      2024987596,
      1809983544,
      2575936315,
      1296289744,
      3207089363,
      2893594407,
      1578318884,
      274646895,
      3795141740,
      4049975192,
      51262619,
      3619967088,
      632279923,
      922689671,
      3298075524,
      2592579488,
      1760304291,
      2075979607,
      2312596564,
      1562183871,
      2943781820,
      3156637768,
      1313733451,
      549293790,
      3537243613,
      3246849577,
      871202090,
      3878099393,
      357341890,
      102525238,
      4101499445,
      2858735121,
      1477399826,
      1264559846,
      3107202533,
      1845379342,
      2677391885,
      2361733625,
      2125378298,
      820201905,
      3263744690,
      3520608582,
      598981189,
      4151959214,
      85089709,
      373468761,
      3827903834,
      3124367742,
      1213305469,
      1526817161,
      2842354314,
      2107672161,
      2412447074,
      2627466902,
      1861252501,
      1098587580,
      3004210879,
      2688576843,
      1378610760,
      2262928035,
      1955203488,
      1742404180,
      2511436119,
      3416409459,
      969524848,
      714683780,
      3639785095,
      205050476,
      4266873199,
      3976438427,
      526918040,
      1361435347,
      2739821008,
      2954799652,
      1114974503,
      2529119692,
      1691668175,
      2005155131,
      2247081528,
      3690758684,
      697762079,
      986182379,
      3366744552,
      476452099,
      3993867776,
      4250756596,
      255256311,
      1640403810,
      2477592673,
      2164122517,
      1922457750,
      2791048317,
      1412925310,
      1197962378,
      3037525897,
      3944729517,
      427051182,
      170179418,
      4165941337,
      746937522,
      3740196785,
      3451792453,
      1070968646,
      1905808397,
      2213795598,
      2426610938,
      1657317369,
      3053634322,
      1147748369,
      1463399397,
      2773627110,
      4215344322,
      153784257,
      444234805,
      3893493558,
      1021025245,
      3467647198,
      3722505002,
      797665321,
      2197175160,
      1889384571,
      1674398607,
      2443626636,
      1164749927,
      3070701412,
      2757221520,
      1446797203,
      137323447,
      4198817972,
      3910406976,
      461344835,
      3484808360,
      1037989803,
      781091935,
      3705997148,
      2460548119,
      1623424788,
      1939049696,
      2180517859,
      1429367560,
      2807687179,
      3020495871,
      1180866812,
      410100952,
      3927582683,
      4182430767,
      186734380,
      3756733383,
      763408580,
      1053836080,
      3434856499,
      2722870694,
      1344288421,
      1131464017,
      2971354706,
      1708204729,
      2545590714,
      2229949006,
      1988219213,
      680717673,
      3673779818,
      3383336350,
      1002577565,
      4010310262,
      493091189,
      238226049,
      4233660802,
      2987750089,
      1082061258,
      1395524158,
      2705686845,
      1972364758,
      2279892693,
      2494862625,
      1725896226,
      952904198,
      3399985413,
      3656866545,
      731699698,
      4283874585,
      222117402,
      510512622,
      3959836397,
      3280807620,
      837199303,
      582374963,
      3504198960,
      68661723,
      4135334616,
      3844915500,
      390545967,
      1230274059,
      3141532936,
      2825850620,
      1510247935,
      2395924756,
      2091215383,
      1878366691,
      2644384480,
      3553878443,
      565732008,
      854102364,
      3229815391,
      340358836,
      3861050807,
      4117890627,
      119113024,
      1493875044,
      2875275879,
      3090270611,
      1247431312,
      2660249211,
      1828433272,
      2141937292,
      2378227087,
      3811616794,
      291187481,
      34330861,
      4032846830,
      615137029,
      3603020806,
      3314634738,
      939183345,
      1776939221,
      2609017814,
      2295496738,
      2058945313,
      2926798794,
      1545135305,
      1330124605,
      3173225534,
      4084100981,
      17165430,
      307568514,
      3762199681,
      888469610,
      3332340585,
      3587147933,
      665062302,
      2042050490,
      2346497209,
      2559330125,
      1793573966,
      3190661285,
      1279665062,
      1595330642,
      2910671697
    ];
    var lookupTable = (0, util_1.uint32ArrayFrom)(a_lookupTable);
    var aws_crc32c_1 = require_aws_crc32c();
    Object.defineProperty(exports, "AwsCrc32c", { enumerable: true, get: function() {
      return aws_crc32c_1.AwsCrc32c;
    } });
  }
});

// ../../node_modules/.pnpm/@aws-sdk+middleware-flexible-checksums@3.272.0/node_modules/@aws-sdk/middleware-flexible-checksums/dist-cjs/selectChecksumAlgorithmFunction.js
var require_selectChecksumAlgorithmFunction = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+middleware-flexible-checksums@3.272.0/node_modules/@aws-sdk/middleware-flexible-checksums/dist-cjs/selectChecksumAlgorithmFunction.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.selectChecksumAlgorithmFunction = void 0;
    var crc32_1 = require_build2();
    var crc32c_1 = require_build3();
    var constants_1 = require_constants2();
    var selectChecksumAlgorithmFunction = (checksumAlgorithm, config) => ({
      [constants_1.ChecksumAlgorithm.MD5]: config.md5,
      [constants_1.ChecksumAlgorithm.CRC32]: crc32_1.AwsCrc32,
      [constants_1.ChecksumAlgorithm.CRC32C]: crc32c_1.AwsCrc32c,
      [constants_1.ChecksumAlgorithm.SHA1]: config.sha1,
      [constants_1.ChecksumAlgorithm.SHA256]: config.sha256
    })[checksumAlgorithm];
    exports.selectChecksumAlgorithmFunction = selectChecksumAlgorithmFunction;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+util-buffer-from@3.208.0/node_modules/@aws-sdk/util-buffer-from/dist-cjs/index.js
var require_dist_cjs16 = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+util-buffer-from@3.208.0/node_modules/@aws-sdk/util-buffer-from/dist-cjs/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.fromString = exports.fromArrayBuffer = void 0;
    var is_array_buffer_1 = require_dist_cjs14();
    var buffer_1 = require("buffer");
    var fromArrayBuffer = (input, offset = 0, length = input.byteLength - offset) => {
      if (!(0, is_array_buffer_1.isArrayBuffer)(input)) {
        throw new TypeError(`The "input" argument must be ArrayBuffer. Received type ${typeof input} (${input})`);
      }
      return buffer_1.Buffer.from(input, offset, length);
    };
    exports.fromArrayBuffer = fromArrayBuffer;
    var fromString = (input, encoding) => {
      if (typeof input !== "string") {
        throw new TypeError(`The "input" argument must be of type string. Received type ${typeof input} (${input})`);
      }
      return encoding ? buffer_1.Buffer.from(input, encoding) : buffer_1.Buffer.from(input);
    };
    exports.fromString = fromString;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+util-utf8@3.254.0/node_modules/@aws-sdk/util-utf8/dist-cjs/fromUtf8.js
var require_fromUtf8 = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+util-utf8@3.254.0/node_modules/@aws-sdk/util-utf8/dist-cjs/fromUtf8.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.fromUtf8 = void 0;
    var util_buffer_from_1 = require_dist_cjs16();
    var fromUtf8 = (input) => {
      const buf = (0, util_buffer_from_1.fromString)(input, "utf8");
      return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength / Uint8Array.BYTES_PER_ELEMENT);
    };
    exports.fromUtf8 = fromUtf8;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+util-utf8@3.254.0/node_modules/@aws-sdk/util-utf8/dist-cjs/toUint8Array.js
var require_toUint8Array = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+util-utf8@3.254.0/node_modules/@aws-sdk/util-utf8/dist-cjs/toUint8Array.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.toUint8Array = void 0;
    var fromUtf8_1 = require_fromUtf8();
    var toUint8Array = (data) => {
      if (typeof data === "string") {
        return (0, fromUtf8_1.fromUtf8)(data);
      }
      if (ArrayBuffer.isView(data)) {
        return new Uint8Array(data.buffer, data.byteOffset, data.byteLength / Uint8Array.BYTES_PER_ELEMENT);
      }
      return new Uint8Array(data);
    };
    exports.toUint8Array = toUint8Array;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+util-utf8@3.254.0/node_modules/@aws-sdk/util-utf8/dist-cjs/toUtf8.js
var require_toUtf8 = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+util-utf8@3.254.0/node_modules/@aws-sdk/util-utf8/dist-cjs/toUtf8.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.toUtf8 = void 0;
    var util_buffer_from_1 = require_dist_cjs16();
    var toUtf8 = (input) => (0, util_buffer_from_1.fromArrayBuffer)(input.buffer, input.byteOffset, input.byteLength).toString("utf8");
    exports.toUtf8 = toUtf8;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+util-utf8@3.254.0/node_modules/@aws-sdk/util-utf8/dist-cjs/index.js
var require_dist_cjs17 = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+util-utf8@3.254.0/node_modules/@aws-sdk/util-utf8/dist-cjs/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    var tslib_1 = (init_tslib_es6(), __toCommonJS(tslib_es6_exports));
    tslib_1.__exportStar(require_fromUtf8(), exports);
    tslib_1.__exportStar(require_toUint8Array(), exports);
    tslib_1.__exportStar(require_toUtf8(), exports);
  }
});

// ../../node_modules/.pnpm/@aws-sdk+middleware-flexible-checksums@3.272.0/node_modules/@aws-sdk/middleware-flexible-checksums/dist-cjs/stringHasher.js
var require_stringHasher = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+middleware-flexible-checksums@3.272.0/node_modules/@aws-sdk/middleware-flexible-checksums/dist-cjs/stringHasher.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.stringHasher = void 0;
    var util_utf8_1 = require_dist_cjs17();
    var stringHasher = (checksumAlgorithmFn, body) => {
      const hash = new checksumAlgorithmFn();
      hash.update((0, util_utf8_1.toUint8Array)(body || ""));
      return hash.digest();
    };
    exports.stringHasher = stringHasher;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+middleware-flexible-checksums@3.272.0/node_modules/@aws-sdk/middleware-flexible-checksums/dist-cjs/getChecksum.js
var require_getChecksum = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+middleware-flexible-checksums@3.272.0/node_modules/@aws-sdk/middleware-flexible-checksums/dist-cjs/getChecksum.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.getChecksum = void 0;
    var isStreaming_1 = require_isStreaming();
    var stringHasher_1 = require_stringHasher();
    var getChecksum = async (body, { streamHasher, checksumAlgorithmFn, base64Encoder }) => {
      const digest = (0, isStreaming_1.isStreaming)(body) ? streamHasher(checksumAlgorithmFn, body) : (0, stringHasher_1.stringHasher)(checksumAlgorithmFn, body);
      return base64Encoder(await digest);
    };
    exports.getChecksum = getChecksum;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+middleware-flexible-checksums@3.272.0/node_modules/@aws-sdk/middleware-flexible-checksums/dist-cjs/getChecksumAlgorithmListForResponse.js
var require_getChecksumAlgorithmListForResponse = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+middleware-flexible-checksums@3.272.0/node_modules/@aws-sdk/middleware-flexible-checksums/dist-cjs/getChecksumAlgorithmListForResponse.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.getChecksumAlgorithmListForResponse = void 0;
    var types_1 = require_types2();
    var getChecksumAlgorithmListForResponse = (responseAlgorithms = []) => {
      const validChecksumAlgorithms = [];
      for (const algorithm of types_1.PRIORITY_ORDER_ALGORITHMS) {
        if (!responseAlgorithms.includes(algorithm) || !types_1.CLIENT_SUPPORTED_ALGORITHMS.includes(algorithm)) {
          continue;
        }
        validChecksumAlgorithms.push(algorithm);
      }
      return validChecksumAlgorithms;
    };
    exports.getChecksumAlgorithmListForResponse = getChecksumAlgorithmListForResponse;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+middleware-flexible-checksums@3.272.0/node_modules/@aws-sdk/middleware-flexible-checksums/dist-cjs/validateChecksumFromResponse.js
var require_validateChecksumFromResponse = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+middleware-flexible-checksums@3.272.0/node_modules/@aws-sdk/middleware-flexible-checksums/dist-cjs/validateChecksumFromResponse.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.validateChecksumFromResponse = void 0;
    var getChecksum_1 = require_getChecksum();
    var getChecksumAlgorithmListForResponse_1 = require_getChecksumAlgorithmListForResponse();
    var getChecksumLocationName_1 = require_getChecksumLocationName();
    var selectChecksumAlgorithmFunction_1 = require_selectChecksumAlgorithmFunction();
    var validateChecksumFromResponse = async (response, { config, responseAlgorithms }) => {
      const checksumAlgorithms = (0, getChecksumAlgorithmListForResponse_1.getChecksumAlgorithmListForResponse)(responseAlgorithms);
      const { body: responseBody, headers: responseHeaders } = response;
      for (const algorithm of checksumAlgorithms) {
        const responseHeader = (0, getChecksumLocationName_1.getChecksumLocationName)(algorithm);
        const checksumFromResponse = responseHeaders[responseHeader];
        if (checksumFromResponse) {
          const checksumAlgorithmFn = (0, selectChecksumAlgorithmFunction_1.selectChecksumAlgorithmFunction)(algorithm, config);
          const { streamHasher, base64Encoder } = config;
          const checksum = await (0, getChecksum_1.getChecksum)(responseBody, { streamHasher, checksumAlgorithmFn, base64Encoder });
          if (checksum === checksumFromResponse) {
            break;
          }
          throw new Error(`Checksum mismatch: expected "${checksum}" but received "${checksumFromResponse}" in response header "${responseHeader}".`);
        }
      }
    };
    exports.validateChecksumFromResponse = validateChecksumFromResponse;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+middleware-flexible-checksums@3.272.0/node_modules/@aws-sdk/middleware-flexible-checksums/dist-cjs/flexibleChecksumsMiddleware.js
var require_flexibleChecksumsMiddleware = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+middleware-flexible-checksums@3.272.0/node_modules/@aws-sdk/middleware-flexible-checksums/dist-cjs/flexibleChecksumsMiddleware.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.flexibleChecksumsMiddleware = void 0;
    var protocol_http_1 = require_dist_cjs8();
    var getChecksumAlgorithmForRequest_1 = require_getChecksumAlgorithmForRequest();
    var getChecksumLocationName_1 = require_getChecksumLocationName();
    var hasHeader_1 = require_hasHeader();
    var isStreaming_1 = require_isStreaming();
    var selectChecksumAlgorithmFunction_1 = require_selectChecksumAlgorithmFunction();
    var stringHasher_1 = require_stringHasher();
    var validateChecksumFromResponse_1 = require_validateChecksumFromResponse();
    var flexibleChecksumsMiddleware = (config, middlewareConfig) => (next) => async (args) => {
      if (!protocol_http_1.HttpRequest.isInstance(args.request)) {
        return next(args);
      }
      const { request } = args;
      const { body: requestBody, headers } = request;
      const { base64Encoder, streamHasher } = config;
      const { input, requestChecksumRequired, requestAlgorithmMember } = middlewareConfig;
      const checksumAlgorithm = (0, getChecksumAlgorithmForRequest_1.getChecksumAlgorithmForRequest)(input, {
        requestChecksumRequired,
        requestAlgorithmMember
      });
      let updatedBody = requestBody;
      let updatedHeaders = headers;
      if (checksumAlgorithm) {
        const checksumLocationName = (0, getChecksumLocationName_1.getChecksumLocationName)(checksumAlgorithm);
        const checksumAlgorithmFn = (0, selectChecksumAlgorithmFunction_1.selectChecksumAlgorithmFunction)(checksumAlgorithm, config);
        if ((0, isStreaming_1.isStreaming)(requestBody)) {
          const { getAwsChunkedEncodingStream, bodyLengthChecker } = config;
          updatedBody = getAwsChunkedEncodingStream(requestBody, {
            base64Encoder,
            bodyLengthChecker,
            checksumLocationName,
            checksumAlgorithmFn,
            streamHasher
          });
          updatedHeaders = {
            ...headers,
            "content-encoding": headers["content-encoding"] ? `${headers["content-encoding"]},aws-chunked` : "aws-chunked",
            "transfer-encoding": "chunked",
            "x-amz-decoded-content-length": headers["content-length"],
            "x-amz-content-sha256": "STREAMING-UNSIGNED-PAYLOAD-TRAILER",
            "x-amz-trailer": checksumLocationName
          };
          delete updatedHeaders["content-length"];
        } else if (!(0, hasHeader_1.hasHeader)(checksumLocationName, headers)) {
          const rawChecksum = await (0, stringHasher_1.stringHasher)(checksumAlgorithmFn, requestBody);
          updatedHeaders = {
            ...headers,
            [checksumLocationName]: base64Encoder(rawChecksum)
          };
        }
      }
      const result = await next({
        ...args,
        request: {
          ...request,
          headers: updatedHeaders,
          body: updatedBody
        }
      });
      const { requestValidationModeMember, responseAlgorithms } = middlewareConfig;
      if (requestValidationModeMember && input[requestValidationModeMember] === "ENABLED") {
        (0, validateChecksumFromResponse_1.validateChecksumFromResponse)(result.response, {
          config,
          responseAlgorithms
        });
      }
      return result;
    };
    exports.flexibleChecksumsMiddleware = flexibleChecksumsMiddleware;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+middleware-flexible-checksums@3.272.0/node_modules/@aws-sdk/middleware-flexible-checksums/dist-cjs/getFlexibleChecksumsPlugin.js
var require_getFlexibleChecksumsPlugin = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+middleware-flexible-checksums@3.272.0/node_modules/@aws-sdk/middleware-flexible-checksums/dist-cjs/getFlexibleChecksumsPlugin.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.getFlexibleChecksumsPlugin = exports.flexibleChecksumsMiddlewareOptions = void 0;
    var flexibleChecksumsMiddleware_1 = require_flexibleChecksumsMiddleware();
    exports.flexibleChecksumsMiddlewareOptions = {
      name: "flexibleChecksumsMiddleware",
      step: "build",
      tags: ["BODY_CHECKSUM"],
      override: true
    };
    var getFlexibleChecksumsPlugin = (config, middlewareConfig) => ({
      applyToStack: (clientStack) => {
        clientStack.add((0, flexibleChecksumsMiddleware_1.flexibleChecksumsMiddleware)(config, middlewareConfig), exports.flexibleChecksumsMiddlewareOptions);
      }
    });
    exports.getFlexibleChecksumsPlugin = getFlexibleChecksumsPlugin;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+middleware-flexible-checksums@3.272.0/node_modules/@aws-sdk/middleware-flexible-checksums/dist-cjs/index.js
var require_dist_cjs18 = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+middleware-flexible-checksums@3.272.0/node_modules/@aws-sdk/middleware-flexible-checksums/dist-cjs/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    var tslib_1 = (init_tslib_es6(), __toCommonJS(tslib_es6_exports));
    tslib_1.__exportStar(require_constants2(), exports);
    tslib_1.__exportStar(require_flexibleChecksumsMiddleware(), exports);
    tslib_1.__exportStar(require_getFlexibleChecksumsPlugin(), exports);
  }
});

// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/DeleteObjectsCommand.js
var require_DeleteObjectsCommand = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/DeleteObjectsCommand.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.DeleteObjectsCommand = void 0;
    var middleware_endpoint_1 = require_dist_cjs5();
    var middleware_flexible_checksums_1 = require_dist_cjs18();
    var middleware_serde_1 = require_dist_cjs3();
    var smithy_client_1 = require_dist_cjs7();
    var models_0_1 = require_models_0();
    var Aws_restXml_1 = require_Aws_restXml();
    var DeleteObjectsCommand = class extends smithy_client_1.Command {
      constructor(input) {
        super();
        this.input = input;
      }
      static getEndpointParameterInstructions() {
        return {
          Bucket: { type: "contextParams", name: "Bucket" },
          ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" },
          UseArnRegion: { type: "clientContextParams", name: "useArnRegion" },
          DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" },
          Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" },
          UseGlobalEndpoint: { type: "builtInParams", name: "useGlobalEndpoint" },
          UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
          Endpoint: { type: "builtInParams", name: "endpoint" },
          Region: { type: "builtInParams", name: "region" },
          UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
        };
      }
      resolveMiddleware(clientStack, configuration, options) {
        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DeleteObjectsCommand.getEndpointParameterInstructions()));
        this.middlewareStack.use((0, middleware_flexible_checksums_1.getFlexibleChecksumsPlugin)(configuration, {
          input: this.input,
          requestAlgorithmMember: "ChecksumAlgorithm",
          requestChecksumRequired: true
        }));
        const stack = clientStack.concat(this.middlewareStack);
        const { logger } = configuration;
        const clientName = "S3Client";
        const commandName = "DeleteObjectsCommand";
        const handlerExecutionContext = {
          logger,
          clientName,
          commandName,
          inputFilterSensitiveLog: models_0_1.DeleteObjectsRequestFilterSensitiveLog,
          outputFilterSensitiveLog: models_0_1.DeleteObjectsOutputFilterSensitiveLog
        };
        const { requestHandler } = configuration;
        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
      }
      serialize(input, context) {
        return (0, Aws_restXml_1.serializeAws_restXmlDeleteObjectsCommand)(input, context);
      }
      deserialize(output, context) {
        return (0, Aws_restXml_1.deserializeAws_restXmlDeleteObjectsCommand)(output, context);
      }
    };
    exports.DeleteObjectsCommand = DeleteObjectsCommand;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/DeleteObjectTaggingCommand.js
var require_DeleteObjectTaggingCommand = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/DeleteObjectTaggingCommand.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.DeleteObjectTaggingCommand = void 0;
    var middleware_endpoint_1 = require_dist_cjs5();
    var middleware_serde_1 = require_dist_cjs3();
    var smithy_client_1 = require_dist_cjs7();
    var models_0_1 = require_models_0();
    var Aws_restXml_1 = require_Aws_restXml();
    var DeleteObjectTaggingCommand = class extends smithy_client_1.Command {
      constructor(input) {
        super();
        this.input = input;
      }
      static getEndpointParameterInstructions() {
        return {
          Bucket: { type: "contextParams", name: "Bucket" },
          ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" },
          UseArnRegion: { type: "clientContextParams", name: "useArnRegion" },
          DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" },
          Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" },
          UseGlobalEndpoint: { type: "builtInParams", name: "useGlobalEndpoint" },
          UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
          Endpoint: { type: "builtInParams", name: "endpoint" },
          Region: { type: "builtInParams", name: "region" },
          UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
        };
      }
      resolveMiddleware(clientStack, configuration, options) {
        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DeleteObjectTaggingCommand.getEndpointParameterInstructions()));
        const stack = clientStack.concat(this.middlewareStack);
        const { logger } = configuration;
        const clientName = "S3Client";
        const commandName = "DeleteObjectTaggingCommand";
        const handlerExecutionContext = {
          logger,
          clientName,
          commandName,
          inputFilterSensitiveLog: models_0_1.DeleteObjectTaggingRequestFilterSensitiveLog,
          outputFilterSensitiveLog: models_0_1.DeleteObjectTaggingOutputFilterSensitiveLog
        };
        const { requestHandler } = configuration;
        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
      }
      serialize(input, context) {
        return (0, Aws_restXml_1.serializeAws_restXmlDeleteObjectTaggingCommand)(input, context);
      }
      deserialize(output, context) {
        return (0, Aws_restXml_1.deserializeAws_restXmlDeleteObjectTaggingCommand)(output, context);
      }
    };
    exports.DeleteObjectTaggingCommand = DeleteObjectTaggingCommand;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/DeletePublicAccessBlockCommand.js
var require_DeletePublicAccessBlockCommand = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/DeletePublicAccessBlockCommand.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.DeletePublicAccessBlockCommand = void 0;
    var middleware_endpoint_1 = require_dist_cjs5();
    var middleware_serde_1 = require_dist_cjs3();
    var smithy_client_1 = require_dist_cjs7();
    var models_0_1 = require_models_0();
    var Aws_restXml_1 = require_Aws_restXml();
    var DeletePublicAccessBlockCommand = class extends smithy_client_1.Command {
      constructor(input) {
        super();
        this.input = input;
      }
      static getEndpointParameterInstructions() {
        return {
          Bucket: { type: "contextParams", name: "Bucket" },
          ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" },
          UseArnRegion: { type: "clientContextParams", name: "useArnRegion" },
          DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" },
          Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" },
          UseGlobalEndpoint: { type: "builtInParams", name: "useGlobalEndpoint" },
          UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
          Endpoint: { type: "builtInParams", name: "endpoint" },
          Region: { type: "builtInParams", name: "region" },
          UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
        };
      }
      resolveMiddleware(clientStack, configuration, options) {
        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DeletePublicAccessBlockCommand.getEndpointParameterInstructions()));
        const stack = clientStack.concat(this.middlewareStack);
        const { logger } = configuration;
        const clientName = "S3Client";
        const commandName = "DeletePublicAccessBlockCommand";
        const handlerExecutionContext = {
          logger,
          clientName,
          commandName,
          inputFilterSensitiveLog: models_0_1.DeletePublicAccessBlockRequestFilterSensitiveLog,
          outputFilterSensitiveLog: (output) => output
        };
        const { requestHandler } = configuration;
        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
      }
      serialize(input, context) {
        return (0, Aws_restXml_1.serializeAws_restXmlDeletePublicAccessBlockCommand)(input, context);
      }
      deserialize(output, context) {
        return (0, Aws_restXml_1.deserializeAws_restXmlDeletePublicAccessBlockCommand)(output, context);
      }
    };
    exports.DeletePublicAccessBlockCommand = DeletePublicAccessBlockCommand;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetBucketAccelerateConfigurationCommand.js
var require_GetBucketAccelerateConfigurationCommand = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetBucketAccelerateConfigurationCommand.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.GetBucketAccelerateConfigurationCommand = void 0;
    var middleware_endpoint_1 = require_dist_cjs5();
    var middleware_serde_1 = require_dist_cjs3();
    var smithy_client_1 = require_dist_cjs7();
    var models_0_1 = require_models_0();
    var Aws_restXml_1 = require_Aws_restXml();
    var GetBucketAccelerateConfigurationCommand = class extends smithy_client_1.Command {
      constructor(input) {
        super();
        this.input = input;
      }
      static getEndpointParameterInstructions() {
        return {
          Bucket: { type: "contextParams", name: "Bucket" },
          ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" },
          UseArnRegion: { type: "clientContextParams", name: "useArnRegion" },
          DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" },
          Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" },
          UseGlobalEndpoint: { type: "builtInParams", name: "useGlobalEndpoint" },
          UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
          Endpoint: { type: "builtInParams", name: "endpoint" },
          Region: { type: "builtInParams", name: "region" },
          UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
        };
      }
      resolveMiddleware(clientStack, configuration, options) {
        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, GetBucketAccelerateConfigurationCommand.getEndpointParameterInstructions()));
        const stack = clientStack.concat(this.middlewareStack);
        const { logger } = configuration;
        const clientName = "S3Client";
        const commandName = "GetBucketAccelerateConfigurationCommand";
        const handlerExecutionContext = {
          logger,
          clientName,
          commandName,
          inputFilterSensitiveLog: models_0_1.GetBucketAccelerateConfigurationRequestFilterSensitiveLog,
          outputFilterSensitiveLog: models_0_1.GetBucketAccelerateConfigurationOutputFilterSensitiveLog
        };
        const { requestHandler } = configuration;
        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
      }
      serialize(input, context) {
        return (0, Aws_restXml_1.serializeAws_restXmlGetBucketAccelerateConfigurationCommand)(input, context);
      }
      deserialize(output, context) {
        return (0, Aws_restXml_1.deserializeAws_restXmlGetBucketAccelerateConfigurationCommand)(output, context);
      }
    };
    exports.GetBucketAccelerateConfigurationCommand = GetBucketAccelerateConfigurationCommand;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetBucketAclCommand.js
var require_GetBucketAclCommand = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetBucketAclCommand.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.GetBucketAclCommand = void 0;
    var middleware_endpoint_1 = require_dist_cjs5();
    var middleware_serde_1 = require_dist_cjs3();
    var smithy_client_1 = require_dist_cjs7();
    var models_0_1 = require_models_0();
    var Aws_restXml_1 = require_Aws_restXml();
    var GetBucketAclCommand = class extends smithy_client_1.Command {
      constructor(input) {
        super();
        this.input = input;
      }
      static getEndpointParameterInstructions() {
        return {
          Bucket: { type: "contextParams", name: "Bucket" },
          ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" },
          UseArnRegion: { type: "clientContextParams", name: "useArnRegion" },
          DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" },
          Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" },
          UseGlobalEndpoint: { type: "builtInParams", name: "useGlobalEndpoint" },
          UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
          Endpoint: { type: "builtInParams", name: "endpoint" },
          Region: { type: "builtInParams", name: "region" },
          UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
        };
      }
      resolveMiddleware(clientStack, configuration, options) {
        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, GetBucketAclCommand.getEndpointParameterInstructions()));
        const stack = clientStack.concat(this.middlewareStack);
        const { logger } = configuration;
        const clientName = "S3Client";
        const commandName = "GetBucketAclCommand";
        const handlerExecutionContext = {
          logger,
          clientName,
          commandName,
          inputFilterSensitiveLog: models_0_1.GetBucketAclRequestFilterSensitiveLog,
          outputFilterSensitiveLog: models_0_1.GetBucketAclOutputFilterSensitiveLog
        };
        const { requestHandler } = configuration;
        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
      }
      serialize(input, context) {
        return (0, Aws_restXml_1.serializeAws_restXmlGetBucketAclCommand)(input, context);
      }
      deserialize(output, context) {
        return (0, Aws_restXml_1.deserializeAws_restXmlGetBucketAclCommand)(output, context);
      }
    };
    exports.GetBucketAclCommand = GetBucketAclCommand;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetBucketAnalyticsConfigurationCommand.js
var require_GetBucketAnalyticsConfigurationCommand = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetBucketAnalyticsConfigurationCommand.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.GetBucketAnalyticsConfigurationCommand = void 0;
    var middleware_endpoint_1 = require_dist_cjs5();
    var middleware_serde_1 = require_dist_cjs3();
    var smithy_client_1 = require_dist_cjs7();
    var models_0_1 = require_models_0();
    var Aws_restXml_1 = require_Aws_restXml();
    var GetBucketAnalyticsConfigurationCommand = class extends smithy_client_1.Command {
      constructor(input) {
        super();
        this.input = input;
      }
      static getEndpointParameterInstructions() {
        return {
          Bucket: { type: "contextParams", name: "Bucket" },
          ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" },
          UseArnRegion: { type: "clientContextParams", name: "useArnRegion" },
          DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" },
          Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" },
          UseGlobalEndpoint: { type: "builtInParams", name: "useGlobalEndpoint" },
          UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
          Endpoint: { type: "builtInParams", name: "endpoint" },
          Region: { type: "builtInParams", name: "region" },
          UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
        };
      }
      resolveMiddleware(clientStack, configuration, options) {
        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, GetBucketAnalyticsConfigurationCommand.getEndpointParameterInstructions()));
        const stack = clientStack.concat(this.middlewareStack);
        const { logger } = configuration;
        const clientName = "S3Client";
        const commandName = "GetBucketAnalyticsConfigurationCommand";
        const handlerExecutionContext = {
          logger,
          clientName,
          commandName,
          inputFilterSensitiveLog: models_0_1.GetBucketAnalyticsConfigurationRequestFilterSensitiveLog,
          outputFilterSensitiveLog: models_0_1.GetBucketAnalyticsConfigurationOutputFilterSensitiveLog
        };
        const { requestHandler } = configuration;
        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
      }
      serialize(input, context) {
        return (0, Aws_restXml_1.serializeAws_restXmlGetBucketAnalyticsConfigurationCommand)(input, context);
      }
      deserialize(output, context) {
        return (0, Aws_restXml_1.deserializeAws_restXmlGetBucketAnalyticsConfigurationCommand)(output, context);
      }
    };
    exports.GetBucketAnalyticsConfigurationCommand = GetBucketAnalyticsConfigurationCommand;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetBucketCorsCommand.js
var require_GetBucketCorsCommand = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetBucketCorsCommand.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.GetBucketCorsCommand = void 0;
    var middleware_endpoint_1 = require_dist_cjs5();
    var middleware_serde_1 = require_dist_cjs3();
    var smithy_client_1 = require_dist_cjs7();
    var models_0_1 = require_models_0();
    var Aws_restXml_1 = require_Aws_restXml();
    var GetBucketCorsCommand = class extends smithy_client_1.Command {
      constructor(input) {
        super();
        this.input = input;
      }
      static getEndpointParameterInstructions() {
        return {
          Bucket: { type: "contextParams", name: "Bucket" },
          ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" },
          UseArnRegion: { type: "clientContextParams", name: "useArnRegion" },
          DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" },
          Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" },
          UseGlobalEndpoint: { type: "builtInParams", name: "useGlobalEndpoint" },
          UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
          Endpoint: { type: "builtInParams", name: "endpoint" },
          Region: { type: "builtInParams", name: "region" },
          UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
        };
      }
      resolveMiddleware(clientStack, configuration, options) {
        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, GetBucketCorsCommand.getEndpointParameterInstructions()));
        const stack = clientStack.concat(this.middlewareStack);
        const { logger } = configuration;
        const clientName = "S3Client";
        const commandName = "GetBucketCorsCommand";
        const handlerExecutionContext = {
          logger,
          clientName,
          commandName,
          inputFilterSensitiveLog: models_0_1.GetBucketCorsRequestFilterSensitiveLog,
          outputFilterSensitiveLog: models_0_1.GetBucketCorsOutputFilterSensitiveLog
        };
        const { requestHandler } = configuration;
        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
      }
      serialize(input, context) {
        return (0, Aws_restXml_1.serializeAws_restXmlGetBucketCorsCommand)(input, context);
      }
      deserialize(output, context) {
        return (0, Aws_restXml_1.deserializeAws_restXmlGetBucketCorsCommand)(output, context);
      }
    };
    exports.GetBucketCorsCommand = GetBucketCorsCommand;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetBucketEncryptionCommand.js
var require_GetBucketEncryptionCommand = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetBucketEncryptionCommand.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.GetBucketEncryptionCommand = void 0;
    var middleware_endpoint_1 = require_dist_cjs5();
    var middleware_serde_1 = require_dist_cjs3();
    var smithy_client_1 = require_dist_cjs7();
    var models_0_1 = require_models_0();
    var Aws_restXml_1 = require_Aws_restXml();
    var GetBucketEncryptionCommand = class extends smithy_client_1.Command {
      constructor(input) {
        super();
        this.input = input;
      }
      static getEndpointParameterInstructions() {
        return {
          Bucket: { type: "contextParams", name: "Bucket" },
          ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" },
          UseArnRegion: { type: "clientContextParams", name: "useArnRegion" },
          DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" },
          Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" },
          UseGlobalEndpoint: { type: "builtInParams", name: "useGlobalEndpoint" },
          UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
          Endpoint: { type: "builtInParams", name: "endpoint" },
          Region: { type: "builtInParams", name: "region" },
          UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
        };
      }
      resolveMiddleware(clientStack, configuration, options) {
        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, GetBucketEncryptionCommand.getEndpointParameterInstructions()));
        const stack = clientStack.concat(this.middlewareStack);
        const { logger } = configuration;
        const clientName = "S3Client";
        const commandName = "GetBucketEncryptionCommand";
        const handlerExecutionContext = {
          logger,
          clientName,
          commandName,
          inputFilterSensitiveLog: models_0_1.GetBucketEncryptionRequestFilterSensitiveLog,
          outputFilterSensitiveLog: models_0_1.GetBucketEncryptionOutputFilterSensitiveLog
        };
        const { requestHandler } = configuration;
        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
      }
      serialize(input, context) {
        return (0, Aws_restXml_1.serializeAws_restXmlGetBucketEncryptionCommand)(input, context);
      }
      deserialize(output, context) {
        return (0, Aws_restXml_1.deserializeAws_restXmlGetBucketEncryptionCommand)(output, context);
      }
    };
    exports.GetBucketEncryptionCommand = GetBucketEncryptionCommand;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetBucketIntelligentTieringConfigurationCommand.js
var require_GetBucketIntelligentTieringConfigurationCommand = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetBucketIntelligentTieringConfigurationCommand.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.GetBucketIntelligentTieringConfigurationCommand = void 0;
    var middleware_endpoint_1 = require_dist_cjs5();
    var middleware_serde_1 = require_dist_cjs3();
    var smithy_client_1 = require_dist_cjs7();
    var models_0_1 = require_models_0();
    var Aws_restXml_1 = require_Aws_restXml();
    var GetBucketIntelligentTieringConfigurationCommand = class extends smithy_client_1.Command {
      constructor(input) {
        super();
        this.input = input;
      }
      static getEndpointParameterInstructions() {
        return {
          Bucket: { type: "contextParams", name: "Bucket" },
          ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" },
          UseArnRegion: { type: "clientContextParams", name: "useArnRegion" },
          DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" },
          Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" },
          UseGlobalEndpoint: { type: "builtInParams", name: "useGlobalEndpoint" },
          UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
          Endpoint: { type: "builtInParams", name: "endpoint" },
          Region: { type: "builtInParams", name: "region" },
          UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
        };
      }
      resolveMiddleware(clientStack, configuration, options) {
        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, GetBucketIntelligentTieringConfigurationCommand.getEndpointParameterInstructions()));
        const stack = clientStack.concat(this.middlewareStack);
        const { logger } = configuration;
        const clientName = "S3Client";
        const commandName = "GetBucketIntelligentTieringConfigurationCommand";
        const handlerExecutionContext = {
          logger,
          clientName,
          commandName,
          inputFilterSensitiveLog: models_0_1.GetBucketIntelligentTieringConfigurationRequestFilterSensitiveLog,
          outputFilterSensitiveLog: models_0_1.GetBucketIntelligentTieringConfigurationOutputFilterSensitiveLog
        };
        const { requestHandler } = configuration;
        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
      }
      serialize(input, context) {
        return (0, Aws_restXml_1.serializeAws_restXmlGetBucketIntelligentTieringConfigurationCommand)(input, context);
      }
      deserialize(output, context) {
        return (0, Aws_restXml_1.deserializeAws_restXmlGetBucketIntelligentTieringConfigurationCommand)(output, context);
      }
    };
    exports.GetBucketIntelligentTieringConfigurationCommand = GetBucketIntelligentTieringConfigurationCommand;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetBucketInventoryConfigurationCommand.js
var require_GetBucketInventoryConfigurationCommand = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetBucketInventoryConfigurationCommand.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.GetBucketInventoryConfigurationCommand = void 0;
    var middleware_endpoint_1 = require_dist_cjs5();
    var middleware_serde_1 = require_dist_cjs3();
    var smithy_client_1 = require_dist_cjs7();
    var models_0_1 = require_models_0();
    var Aws_restXml_1 = require_Aws_restXml();
    var GetBucketInventoryConfigurationCommand = class extends smithy_client_1.Command {
      constructor(input) {
        super();
        this.input = input;
      }
      static getEndpointParameterInstructions() {
        return {
          Bucket: { type: "contextParams", name: "Bucket" },
          ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" },
          UseArnRegion: { type: "clientContextParams", name: "useArnRegion" },
          DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" },
          Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" },
          UseGlobalEndpoint: { type: "builtInParams", name: "useGlobalEndpoint" },
          UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
          Endpoint: { type: "builtInParams", name: "endpoint" },
          Region: { type: "builtInParams", name: "region" },
          UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
        };
      }
      resolveMiddleware(clientStack, configuration, options) {
        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, GetBucketInventoryConfigurationCommand.getEndpointParameterInstructions()));
        const stack = clientStack.concat(this.middlewareStack);
        const { logger } = configuration;
        const clientName = "S3Client";
        const commandName = "GetBucketInventoryConfigurationCommand";
        const handlerExecutionContext = {
          logger,
          clientName,
          commandName,
          inputFilterSensitiveLog: models_0_1.GetBucketInventoryConfigurationRequestFilterSensitiveLog,
          outputFilterSensitiveLog: models_0_1.GetBucketInventoryConfigurationOutputFilterSensitiveLog
        };
        const { requestHandler } = configuration;
        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
      }
      serialize(input, context) {
        return (0, Aws_restXml_1.serializeAws_restXmlGetBucketInventoryConfigurationCommand)(input, context);
      }
      deserialize(output, context) {
        return (0, Aws_restXml_1.deserializeAws_restXmlGetBucketInventoryConfigurationCommand)(output, context);
      }
    };
    exports.GetBucketInventoryConfigurationCommand = GetBucketInventoryConfigurationCommand;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetBucketLifecycleConfigurationCommand.js
var require_GetBucketLifecycleConfigurationCommand = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetBucketLifecycleConfigurationCommand.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.GetBucketLifecycleConfigurationCommand = void 0;
    var middleware_endpoint_1 = require_dist_cjs5();
    var middleware_serde_1 = require_dist_cjs3();
    var smithy_client_1 = require_dist_cjs7();
    var models_0_1 = require_models_0();
    var Aws_restXml_1 = require_Aws_restXml();
    var GetBucketLifecycleConfigurationCommand = class extends smithy_client_1.Command {
      constructor(input) {
        super();
        this.input = input;
      }
      static getEndpointParameterInstructions() {
        return {
          Bucket: { type: "contextParams", name: "Bucket" },
          ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" },
          UseArnRegion: { type: "clientContextParams", name: "useArnRegion" },
          DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" },
          Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" },
          UseGlobalEndpoint: { type: "builtInParams", name: "useGlobalEndpoint" },
          UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
          Endpoint: { type: "builtInParams", name: "endpoint" },
          Region: { type: "builtInParams", name: "region" },
          UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
        };
      }
      resolveMiddleware(clientStack, configuration, options) {
        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, GetBucketLifecycleConfigurationCommand.getEndpointParameterInstructions()));
        const stack = clientStack.concat(this.middlewareStack);
        const { logger } = configuration;
        const clientName = "S3Client";
        const commandName = "GetBucketLifecycleConfigurationCommand";
        const handlerExecutionContext = {
          logger,
          clientName,
          commandName,
          inputFilterSensitiveLog: models_0_1.GetBucketLifecycleConfigurationRequestFilterSensitiveLog,
          outputFilterSensitiveLog: models_0_1.GetBucketLifecycleConfigurationOutputFilterSensitiveLog
        };
        const { requestHandler } = configuration;
        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
      }
      serialize(input, context) {
        return (0, Aws_restXml_1.serializeAws_restXmlGetBucketLifecycleConfigurationCommand)(input, context);
      }
      deserialize(output, context) {
        return (0, Aws_restXml_1.deserializeAws_restXmlGetBucketLifecycleConfigurationCommand)(output, context);
      }
    };
    exports.GetBucketLifecycleConfigurationCommand = GetBucketLifecycleConfigurationCommand;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetBucketLocationCommand.js
var require_GetBucketLocationCommand = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetBucketLocationCommand.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.GetBucketLocationCommand = void 0;
    var middleware_endpoint_1 = require_dist_cjs5();
    var middleware_serde_1 = require_dist_cjs3();
    var smithy_client_1 = require_dist_cjs7();
    var models_0_1 = require_models_0();
    var Aws_restXml_1 = require_Aws_restXml();
    var GetBucketLocationCommand = class extends smithy_client_1.Command {
      constructor(input) {
        super();
        this.input = input;
      }
      static getEndpointParameterInstructions() {
        return {
          Bucket: { type: "contextParams", name: "Bucket" },
          ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" },
          UseArnRegion: { type: "clientContextParams", name: "useArnRegion" },
          DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" },
          Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" },
          UseGlobalEndpoint: { type: "builtInParams", name: "useGlobalEndpoint" },
          UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
          Endpoint: { type: "builtInParams", name: "endpoint" },
          Region: { type: "builtInParams", name: "region" },
          UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
        };
      }
      resolveMiddleware(clientStack, configuration, options) {
        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, GetBucketLocationCommand.getEndpointParameterInstructions()));
        const stack = clientStack.concat(this.middlewareStack);
        const { logger } = configuration;
        const clientName = "S3Client";
        const commandName = "GetBucketLocationCommand";
        const handlerExecutionContext = {
          logger,
          clientName,
          commandName,
          inputFilterSensitiveLog: models_0_1.GetBucketLocationRequestFilterSensitiveLog,
          outputFilterSensitiveLog: models_0_1.GetBucketLocationOutputFilterSensitiveLog
        };
        const { requestHandler } = configuration;
        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
      }
      serialize(input, context) {
        return (0, Aws_restXml_1.serializeAws_restXmlGetBucketLocationCommand)(input, context);
      }
      deserialize(output, context) {
        return (0, Aws_restXml_1.deserializeAws_restXmlGetBucketLocationCommand)(output, context);
      }
    };
    exports.GetBucketLocationCommand = GetBucketLocationCommand;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetBucketLoggingCommand.js
var require_GetBucketLoggingCommand = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetBucketLoggingCommand.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.GetBucketLoggingCommand = void 0;
    var middleware_endpoint_1 = require_dist_cjs5();
    var middleware_serde_1 = require_dist_cjs3();
    var smithy_client_1 = require_dist_cjs7();
    var models_0_1 = require_models_0();
    var Aws_restXml_1 = require_Aws_restXml();
    var GetBucketLoggingCommand = class extends smithy_client_1.Command {
      constructor(input) {
        super();
        this.input = input;
      }
      static getEndpointParameterInstructions() {
        return {
          Bucket: { type: "contextParams", name: "Bucket" },
          ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" },
          UseArnRegion: { type: "clientContextParams", name: "useArnRegion" },
          DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" },
          Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" },
          UseGlobalEndpoint: { type: "builtInParams", name: "useGlobalEndpoint" },
          UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
          Endpoint: { type: "builtInParams", name: "endpoint" },
          Region: { type: "builtInParams", name: "region" },
          UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
        };
      }
      resolveMiddleware(clientStack, configuration, options) {
        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, GetBucketLoggingCommand.getEndpointParameterInstructions()));
        const stack = clientStack.concat(this.middlewareStack);
        const { logger } = configuration;
        const clientName = "S3Client";
        const commandName = "GetBucketLoggingCommand";
        const handlerExecutionContext = {
          logger,
          clientName,
          commandName,
          inputFilterSensitiveLog: models_0_1.GetBucketLoggingRequestFilterSensitiveLog,
          outputFilterSensitiveLog: models_0_1.GetBucketLoggingOutputFilterSensitiveLog
        };
        const { requestHandler } = configuration;
        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
      }
      serialize(input, context) {
        return (0, Aws_restXml_1.serializeAws_restXmlGetBucketLoggingCommand)(input, context);
      }
      deserialize(output, context) {
        return (0, Aws_restXml_1.deserializeAws_restXmlGetBucketLoggingCommand)(output, context);
      }
    };
    exports.GetBucketLoggingCommand = GetBucketLoggingCommand;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetBucketMetricsConfigurationCommand.js
var require_GetBucketMetricsConfigurationCommand = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetBucketMetricsConfigurationCommand.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.GetBucketMetricsConfigurationCommand = void 0;
    var middleware_endpoint_1 = require_dist_cjs5();
    var middleware_serde_1 = require_dist_cjs3();
    var smithy_client_1 = require_dist_cjs7();
    var models_0_1 = require_models_0();
    var Aws_restXml_1 = require_Aws_restXml();
    var GetBucketMetricsConfigurationCommand = class extends smithy_client_1.Command {
      constructor(input) {
        super();
        this.input = input;
      }
      static getEndpointParameterInstructions() {
        return {
          Bucket: { type: "contextParams", name: "Bucket" },
          ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" },
          UseArnRegion: { type: "clientContextParams", name: "useArnRegion" },
          DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" },
          Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" },
          UseGlobalEndpoint: { type: "builtInParams", name: "useGlobalEndpoint" },
          UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
          Endpoint: { type: "builtInParams", name: "endpoint" },
          Region: { type: "builtInParams", name: "region" },
          UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
        };
      }
      resolveMiddleware(clientStack, configuration, options) {
        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, GetBucketMetricsConfigurationCommand.getEndpointParameterInstructions()));
        const stack = clientStack.concat(this.middlewareStack);
        const { logger } = configuration;
        const clientName = "S3Client";
        const commandName = "GetBucketMetricsConfigurationCommand";
        const handlerExecutionContext = {
          logger,
          clientName,
          commandName,
          inputFilterSensitiveLog: models_0_1.GetBucketMetricsConfigurationRequestFilterSensitiveLog,
          outputFilterSensitiveLog: models_0_1.GetBucketMetricsConfigurationOutputFilterSensitiveLog
        };
        const { requestHandler } = configuration;
        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
      }
      serialize(input, context) {
        return (0, Aws_restXml_1.serializeAws_restXmlGetBucketMetricsConfigurationCommand)(input, context);
      }
      deserialize(output, context) {
        return (0, Aws_restXml_1.deserializeAws_restXmlGetBucketMetricsConfigurationCommand)(output, context);
      }
    };
    exports.GetBucketMetricsConfigurationCommand = GetBucketMetricsConfigurationCommand;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetBucketNotificationConfigurationCommand.js
var require_GetBucketNotificationConfigurationCommand = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetBucketNotificationConfigurationCommand.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.GetBucketNotificationConfigurationCommand = void 0;
    var middleware_endpoint_1 = require_dist_cjs5();
    var middleware_serde_1 = require_dist_cjs3();
    var smithy_client_1 = require_dist_cjs7();
    var models_0_1 = require_models_0();
    var Aws_restXml_1 = require_Aws_restXml();
    var GetBucketNotificationConfigurationCommand = class extends smithy_client_1.Command {
      constructor(input) {
        super();
        this.input = input;
      }
      static getEndpointParameterInstructions() {
        return {
          Bucket: { type: "contextParams", name: "Bucket" },
          ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" },
          UseArnRegion: { type: "clientContextParams", name: "useArnRegion" },
          DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" },
          Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" },
          UseGlobalEndpoint: { type: "builtInParams", name: "useGlobalEndpoint" },
          UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
          Endpoint: { type: "builtInParams", name: "endpoint" },
          Region: { type: "builtInParams", name: "region" },
          UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
        };
      }
      resolveMiddleware(clientStack, configuration, options) {
        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, GetBucketNotificationConfigurationCommand.getEndpointParameterInstructions()));
        const stack = clientStack.concat(this.middlewareStack);
        const { logger } = configuration;
        const clientName = "S3Client";
        const commandName = "GetBucketNotificationConfigurationCommand";
        const handlerExecutionContext = {
          logger,
          clientName,
          commandName,
          inputFilterSensitiveLog: models_0_1.GetBucketNotificationConfigurationRequestFilterSensitiveLog,
          outputFilterSensitiveLog: models_0_1.NotificationConfigurationFilterSensitiveLog
        };
        const { requestHandler } = configuration;
        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
      }
      serialize(input, context) {
        return (0, Aws_restXml_1.serializeAws_restXmlGetBucketNotificationConfigurationCommand)(input, context);
      }
      deserialize(output, context) {
        return (0, Aws_restXml_1.deserializeAws_restXmlGetBucketNotificationConfigurationCommand)(output, context);
      }
    };
    exports.GetBucketNotificationConfigurationCommand = GetBucketNotificationConfigurationCommand;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetBucketOwnershipControlsCommand.js
var require_GetBucketOwnershipControlsCommand = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetBucketOwnershipControlsCommand.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.GetBucketOwnershipControlsCommand = void 0;
    var middleware_endpoint_1 = require_dist_cjs5();
    var middleware_serde_1 = require_dist_cjs3();
    var smithy_client_1 = require_dist_cjs7();
    var models_0_1 = require_models_0();
    var Aws_restXml_1 = require_Aws_restXml();
    var GetBucketOwnershipControlsCommand = class extends smithy_client_1.Command {
      constructor(input) {
        super();
        this.input = input;
      }
      static getEndpointParameterInstructions() {
        return {
          Bucket: { type: "contextParams", name: "Bucket" },
          ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" },
          UseArnRegion: { type: "clientContextParams", name: "useArnRegion" },
          DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" },
          Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" },
          UseGlobalEndpoint: { type: "builtInParams", name: "useGlobalEndpoint" },
          UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
          Endpoint: { type: "builtInParams", name: "endpoint" },
          Region: { type: "builtInParams", name: "region" },
          UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
        };
      }
      resolveMiddleware(clientStack, configuration, options) {
        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, GetBucketOwnershipControlsCommand.getEndpointParameterInstructions()));
        const stack = clientStack.concat(this.middlewareStack);
        const { logger } = configuration;
        const clientName = "S3Client";
        const commandName = "GetBucketOwnershipControlsCommand";
        const handlerExecutionContext = {
          logger,
          clientName,
          commandName,
          inputFilterSensitiveLog: models_0_1.GetBucketOwnershipControlsRequestFilterSensitiveLog,
          outputFilterSensitiveLog: models_0_1.GetBucketOwnershipControlsOutputFilterSensitiveLog
        };
        const { requestHandler } = configuration;
        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
      }
      serialize(input, context) {
        return (0, Aws_restXml_1.serializeAws_restXmlGetBucketOwnershipControlsCommand)(input, context);
      }
      deserialize(output, context) {
        return (0, Aws_restXml_1.deserializeAws_restXmlGetBucketOwnershipControlsCommand)(output, context);
      }
    };
    exports.GetBucketOwnershipControlsCommand = GetBucketOwnershipControlsCommand;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetBucketPolicyCommand.js
var require_GetBucketPolicyCommand = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetBucketPolicyCommand.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.GetBucketPolicyCommand = void 0;
    var middleware_endpoint_1 = require_dist_cjs5();
    var middleware_serde_1 = require_dist_cjs3();
    var smithy_client_1 = require_dist_cjs7();
    var models_0_1 = require_models_0();
    var Aws_restXml_1 = require_Aws_restXml();
    var GetBucketPolicyCommand = class extends smithy_client_1.Command {
      constructor(input) {
        super();
        this.input = input;
      }
      static getEndpointParameterInstructions() {
        return {
          Bucket: { type: "contextParams", name: "Bucket" },
          ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" },
          UseArnRegion: { type: "clientContextParams", name: "useArnRegion" },
          DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" },
          Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" },
          UseGlobalEndpoint: { type: "builtInParams", name: "useGlobalEndpoint" },
          UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
          Endpoint: { type: "builtInParams", name: "endpoint" },
          Region: { type: "builtInParams", name: "region" },
          UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
        };
      }
      resolveMiddleware(clientStack, configuration, options) {
        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, GetBucketPolicyCommand.getEndpointParameterInstructions()));
        const stack = clientStack.concat(this.middlewareStack);
        const { logger } = configuration;
        const clientName = "S3Client";
        const commandName = "GetBucketPolicyCommand";
        const handlerExecutionContext = {
          logger,
          clientName,
          commandName,
          inputFilterSensitiveLog: models_0_1.GetBucketPolicyRequestFilterSensitiveLog,
          outputFilterSensitiveLog: models_0_1.GetBucketPolicyOutputFilterSensitiveLog
        };
        const { requestHandler } = configuration;
        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
      }
      serialize(input, context) {
        return (0, Aws_restXml_1.serializeAws_restXmlGetBucketPolicyCommand)(input, context);
      }
      deserialize(output, context) {
        return (0, Aws_restXml_1.deserializeAws_restXmlGetBucketPolicyCommand)(output, context);
      }
    };
    exports.GetBucketPolicyCommand = GetBucketPolicyCommand;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetBucketPolicyStatusCommand.js
var require_GetBucketPolicyStatusCommand = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetBucketPolicyStatusCommand.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.GetBucketPolicyStatusCommand = void 0;
    var middleware_endpoint_1 = require_dist_cjs5();
    var middleware_serde_1 = require_dist_cjs3();
    var smithy_client_1 = require_dist_cjs7();
    var models_0_1 = require_models_0();
    var Aws_restXml_1 = require_Aws_restXml();
    var GetBucketPolicyStatusCommand = class extends smithy_client_1.Command {
      constructor(input) {
        super();
        this.input = input;
      }
      static getEndpointParameterInstructions() {
        return {
          Bucket: { type: "contextParams", name: "Bucket" },
          ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" },
          UseArnRegion: { type: "clientContextParams", name: "useArnRegion" },
          DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" },
          Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" },
          UseGlobalEndpoint: { type: "builtInParams", name: "useGlobalEndpoint" },
          UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
          Endpoint: { type: "builtInParams", name: "endpoint" },
          Region: { type: "builtInParams", name: "region" },
          UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
        };
      }
      resolveMiddleware(clientStack, configuration, options) {
        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, GetBucketPolicyStatusCommand.getEndpointParameterInstructions()));
        const stack = clientStack.concat(this.middlewareStack);
        const { logger } = configuration;
        const clientName = "S3Client";
        const commandName = "GetBucketPolicyStatusCommand";
        const handlerExecutionContext = {
          logger,
          clientName,
          commandName,
          inputFilterSensitiveLog: models_0_1.GetBucketPolicyStatusRequestFilterSensitiveLog,
          outputFilterSensitiveLog: models_0_1.GetBucketPolicyStatusOutputFilterSensitiveLog
        };
        const { requestHandler } = configuration;
        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
      }
      serialize(input, context) {
        return (0, Aws_restXml_1.serializeAws_restXmlGetBucketPolicyStatusCommand)(input, context);
      }
      deserialize(output, context) {
        return (0, Aws_restXml_1.deserializeAws_restXmlGetBucketPolicyStatusCommand)(output, context);
      }
    };
    exports.GetBucketPolicyStatusCommand = GetBucketPolicyStatusCommand;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetBucketReplicationCommand.js
var require_GetBucketReplicationCommand = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetBucketReplicationCommand.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.GetBucketReplicationCommand = void 0;
    var middleware_endpoint_1 = require_dist_cjs5();
    var middleware_serde_1 = require_dist_cjs3();
    var smithy_client_1 = require_dist_cjs7();
    var models_0_1 = require_models_0();
    var Aws_restXml_1 = require_Aws_restXml();
    var GetBucketReplicationCommand = class extends smithy_client_1.Command {
      constructor(input) {
        super();
        this.input = input;
      }
      static getEndpointParameterInstructions() {
        return {
          Bucket: { type: "contextParams", name: "Bucket" },
          ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" },
          UseArnRegion: { type: "clientContextParams", name: "useArnRegion" },
          DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" },
          Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" },
          UseGlobalEndpoint: { type: "builtInParams", name: "useGlobalEndpoint" },
          UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
          Endpoint: { type: "builtInParams", name: "endpoint" },
          Region: { type: "builtInParams", name: "region" },
          UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
        };
      }
      resolveMiddleware(clientStack, configuration, options) {
        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, GetBucketReplicationCommand.getEndpointParameterInstructions()));
        const stack = clientStack.concat(this.middlewareStack);
        const { logger } = configuration;
        const clientName = "S3Client";
        const commandName = "GetBucketReplicationCommand";
        const handlerExecutionContext = {
          logger,
          clientName,
          commandName,
          inputFilterSensitiveLog: models_0_1.GetBucketReplicationRequestFilterSensitiveLog,
          outputFilterSensitiveLog: models_0_1.GetBucketReplicationOutputFilterSensitiveLog
        };
        const { requestHandler } = configuration;
        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
      }
      serialize(input, context) {
        return (0, Aws_restXml_1.serializeAws_restXmlGetBucketReplicationCommand)(input, context);
      }
      deserialize(output, context) {
        return (0, Aws_restXml_1.deserializeAws_restXmlGetBucketReplicationCommand)(output, context);
      }
    };
    exports.GetBucketReplicationCommand = GetBucketReplicationCommand;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetBucketRequestPaymentCommand.js
var require_GetBucketRequestPaymentCommand = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetBucketRequestPaymentCommand.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.GetBucketRequestPaymentCommand = void 0;
    var middleware_endpoint_1 = require_dist_cjs5();
    var middleware_serde_1 = require_dist_cjs3();
    var smithy_client_1 = require_dist_cjs7();
    var models_0_1 = require_models_0();
    var Aws_restXml_1 = require_Aws_restXml();
    var GetBucketRequestPaymentCommand = class extends smithy_client_1.Command {
      constructor(input) {
        super();
        this.input = input;
      }
      static getEndpointParameterInstructions() {
        return {
          Bucket: { type: "contextParams", name: "Bucket" },
          ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" },
          UseArnRegion: { type: "clientContextParams", name: "useArnRegion" },
          DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" },
          Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" },
          UseGlobalEndpoint: { type: "builtInParams", name: "useGlobalEndpoint" },
          UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
          Endpoint: { type: "builtInParams", name: "endpoint" },
          Region: { type: "builtInParams", name: "region" },
          UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
        };
      }
      resolveMiddleware(clientStack, configuration, options) {
        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, GetBucketRequestPaymentCommand.getEndpointParameterInstructions()));
        const stack = clientStack.concat(this.middlewareStack);
        const { logger } = configuration;
        const clientName = "S3Client";
        const commandName = "GetBucketRequestPaymentCommand";
        const handlerExecutionContext = {
          logger,
          clientName,
          commandName,
          inputFilterSensitiveLog: models_0_1.GetBucketRequestPaymentRequestFilterSensitiveLog,
          outputFilterSensitiveLog: models_0_1.GetBucketRequestPaymentOutputFilterSensitiveLog
        };
        const { requestHandler } = configuration;
        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
      }
      serialize(input, context) {
        return (0, Aws_restXml_1.serializeAws_restXmlGetBucketRequestPaymentCommand)(input, context);
      }
      deserialize(output, context) {
        return (0, Aws_restXml_1.deserializeAws_restXmlGetBucketRequestPaymentCommand)(output, context);
      }
    };
    exports.GetBucketRequestPaymentCommand = GetBucketRequestPaymentCommand;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetBucketTaggingCommand.js
var require_GetBucketTaggingCommand = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetBucketTaggingCommand.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.GetBucketTaggingCommand = void 0;
    var middleware_endpoint_1 = require_dist_cjs5();
    var middleware_serde_1 = require_dist_cjs3();
    var smithy_client_1 = require_dist_cjs7();
    var models_0_1 = require_models_0();
    var Aws_restXml_1 = require_Aws_restXml();
    var GetBucketTaggingCommand = class extends smithy_client_1.Command {
      constructor(input) {
        super();
        this.input = input;
      }
      static getEndpointParameterInstructions() {
        return {
          Bucket: { type: "contextParams", name: "Bucket" },
          ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" },
          UseArnRegion: { type: "clientContextParams", name: "useArnRegion" },
          DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" },
          Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" },
          UseGlobalEndpoint: { type: "builtInParams", name: "useGlobalEndpoint" },
          UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
          Endpoint: { type: "builtInParams", name: "endpoint" },
          Region: { type: "builtInParams", name: "region" },
          UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
        };
      }
      resolveMiddleware(clientStack, configuration, options) {
        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, GetBucketTaggingCommand.getEndpointParameterInstructions()));
        const stack = clientStack.concat(this.middlewareStack);
        const { logger } = configuration;
        const clientName = "S3Client";
        const commandName = "GetBucketTaggingCommand";
        const handlerExecutionContext = {
          logger,
          clientName,
          commandName,
          inputFilterSensitiveLog: models_0_1.GetBucketTaggingRequestFilterSensitiveLog,
          outputFilterSensitiveLog: models_0_1.GetBucketTaggingOutputFilterSensitiveLog
        };
        const { requestHandler } = configuration;
        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
      }
      serialize(input, context) {
        return (0, Aws_restXml_1.serializeAws_restXmlGetBucketTaggingCommand)(input, context);
      }
      deserialize(output, context) {
        return (0, Aws_restXml_1.deserializeAws_restXmlGetBucketTaggingCommand)(output, context);
      }
    };
    exports.GetBucketTaggingCommand = GetBucketTaggingCommand;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetBucketVersioningCommand.js
var require_GetBucketVersioningCommand = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetBucketVersioningCommand.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.GetBucketVersioningCommand = void 0;
    var middleware_endpoint_1 = require_dist_cjs5();
    var middleware_serde_1 = require_dist_cjs3();
    var smithy_client_1 = require_dist_cjs7();
    var models_0_1 = require_models_0();
    var Aws_restXml_1 = require_Aws_restXml();
    var GetBucketVersioningCommand = class extends smithy_client_1.Command {
      constructor(input) {
        super();
        this.input = input;
      }
      static getEndpointParameterInstructions() {
        return {
          Bucket: { type: "contextParams", name: "Bucket" },
          ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" },
          UseArnRegion: { type: "clientContextParams", name: "useArnRegion" },
          DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" },
          Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" },
          UseGlobalEndpoint: { type: "builtInParams", name: "useGlobalEndpoint" },
          UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
          Endpoint: { type: "builtInParams", name: "endpoint" },
          Region: { type: "builtInParams", name: "region" },
          UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
        };
      }
      resolveMiddleware(clientStack, configuration, options) {
        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, GetBucketVersioningCommand.getEndpointParameterInstructions()));
        const stack = clientStack.concat(this.middlewareStack);
        const { logger } = configuration;
        const clientName = "S3Client";
        const commandName = "GetBucketVersioningCommand";
        const handlerExecutionContext = {
          logger,
          clientName,
          commandName,
          inputFilterSensitiveLog: models_0_1.GetBucketVersioningRequestFilterSensitiveLog,
          outputFilterSensitiveLog: models_0_1.GetBucketVersioningOutputFilterSensitiveLog
        };
        const { requestHandler } = configuration;
        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
      }
      serialize(input, context) {
        return (0, Aws_restXml_1.serializeAws_restXmlGetBucketVersioningCommand)(input, context);
      }
      deserialize(output, context) {
        return (0, Aws_restXml_1.deserializeAws_restXmlGetBucketVersioningCommand)(output, context);
      }
    };
    exports.GetBucketVersioningCommand = GetBucketVersioningCommand;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetBucketWebsiteCommand.js
var require_GetBucketWebsiteCommand = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetBucketWebsiteCommand.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.GetBucketWebsiteCommand = void 0;
    var middleware_endpoint_1 = require_dist_cjs5();
    var middleware_serde_1 = require_dist_cjs3();
    var smithy_client_1 = require_dist_cjs7();
    var models_0_1 = require_models_0();
    var Aws_restXml_1 = require_Aws_restXml();
    var GetBucketWebsiteCommand = class extends smithy_client_1.Command {
      constructor(input) {
        super();
        this.input = input;
      }
      static getEndpointParameterInstructions() {
        return {
          Bucket: { type: "contextParams", name: "Bucket" },
          ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" },
          UseArnRegion: { type: "clientContextParams", name: "useArnRegion" },
          DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" },
          Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" },
          UseGlobalEndpoint: { type: "builtInParams", name: "useGlobalEndpoint" },
          UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
          Endpoint: { type: "builtInParams", name: "endpoint" },
          Region: { type: "builtInParams", name: "region" },
          UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
        };
      }
      resolveMiddleware(clientStack, configuration, options) {
        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, GetBucketWebsiteCommand.getEndpointParameterInstructions()));
        const stack = clientStack.concat(this.middlewareStack);
        const { logger } = configuration;
        const clientName = "S3Client";
        const commandName = "GetBucketWebsiteCommand";
        const handlerExecutionContext = {
          logger,
          clientName,
          commandName,
          inputFilterSensitiveLog: models_0_1.GetBucketWebsiteRequestFilterSensitiveLog,
          outputFilterSensitiveLog: models_0_1.GetBucketWebsiteOutputFilterSensitiveLog
        };
        const { requestHandler } = configuration;
        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
      }
      serialize(input, context) {
        return (0, Aws_restXml_1.serializeAws_restXmlGetBucketWebsiteCommand)(input, context);
      }
      deserialize(output, context) {
        return (0, Aws_restXml_1.deserializeAws_restXmlGetBucketWebsiteCommand)(output, context);
      }
    };
    exports.GetBucketWebsiteCommand = GetBucketWebsiteCommand;
  }
});

// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetObjectAclCommand.js
var require_GetObjectAclCommand = __commonJS({
  "../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetObjectAclCommand.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.GetObjectAclCommand = void 0;
    var middleware_endpoint_1 = require_dist_cjs5();
    var middleware_serde_1 = require_dist_cjs3();
    var smithy_client_1 = require_dist_cjs7();
    var models_0_1 = require_models_0();
    var Aws_restXml_1 = require_Aws_restXml();
    var GetObjectAclCommand = class extends smithy_client_1.Command {
      constructor(input) {
        super();
        this.input = input;
      }
      static getEndpointParameterInstructions() {
        return {
          Bucket: { type: "contextParams", name: "Bucket" },
          ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" },
          UseArnRegion: { type: "clientContextParams", name: "useArnRegion" },
          DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" },
          Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" },
          UseGlobalEndpoint: { type: "builtInParams", name: "useGlobalEndpoint" },
          UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
          Endpoint: { type: "builtInParams", name: "endpoint" },
          Region: { type: "builtInParams", name: "region" },
          UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
        };
      }
      resolveMiddleware(clientStack, configuration, options) {
        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, GetObjectAclCommand.getEndpointParameterInstructions()));
        const stack = clientStack.concat(this.middlewareStack);
        const { logger } = configuration;
        const clientName = "S3Client";
        const commandName = "GetObjectAclCommand";
        const handlerExecutionContext = {
          logger,
          clientName,
          commandName,
          inputFilterSensitiveLog: models_0_1.GetObjectAclRequestFilterSensitiveLog,