@aws-sdk/client-glacier 3.489.0 → 3.495.0

package/dist-cjs/index.js

@@ -1,13 +1,3221 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GlacierServiceException = void 0;
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./GlacierClient"), exports);
-tslib_1.__exportStar(require("./Glacier"), exports);
-tslib_1.__exportStar(require("./commands"), exports);
-tslib_1.__exportStar(require("./pagination"), exports);
-tslib_1.__exportStar(require("./waiters"), exports);
-tslib_1.__exportStar(require("./models"), exports);
-require("@aws-sdk/util-endpoints");
-var GlacierServiceException_1 = require("./models/GlacierServiceException");
-Object.defineProperty(exports, "GlacierServiceException", { enumerable: true, get: function () { return GlacierServiceException_1.GlacierServiceException; } });
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AbortMultipartUploadCommand: () => AbortMultipartUploadCommand,
+  AbortVaultLockCommand: () => AbortVaultLockCommand,
+  ActionCode: () => ActionCode,
+  AddTagsToVaultCommand: () => AddTagsToVaultCommand,
+  CannedACL: () => CannedACL,
+  CompleteMultipartUploadCommand: () => CompleteMultipartUploadCommand,
+  CompleteVaultLockCommand: () => CompleteVaultLockCommand,
+  CreateVaultCommand: () => CreateVaultCommand,
+  DeleteArchiveCommand: () => DeleteArchiveCommand,
+  DeleteVaultAccessPolicyCommand: () => DeleteVaultAccessPolicyCommand,
+  DeleteVaultCommand: () => DeleteVaultCommand,
+  DeleteVaultNotificationsCommand: () => DeleteVaultNotificationsCommand,
+  DescribeJobCommand: () => DescribeJobCommand,
+  DescribeVaultCommand: () => DescribeVaultCommand,
+  EncryptionType: () => EncryptionType,
+  ExpressionType: () => ExpressionType,
+  FileHeaderInfo: () => FileHeaderInfo,
+  GetDataRetrievalPolicyCommand: () => GetDataRetrievalPolicyCommand,
+  GetJobOutputCommand: () => GetJobOutputCommand,
+  GetJobOutputOutputFilterSensitiveLog: () => GetJobOutputOutputFilterSensitiveLog,
+  GetVaultAccessPolicyCommand: () => GetVaultAccessPolicyCommand,
+  GetVaultLockCommand: () => GetVaultLockCommand,
+  GetVaultNotificationsCommand: () => GetVaultNotificationsCommand,
+  Glacier: () => Glacier,
+  GlacierClient: () => GlacierClient,
+  GlacierServiceException: () => GlacierServiceException,
+  InitiateJobCommand: () => InitiateJobCommand,
+  InitiateMultipartUploadCommand: () => InitiateMultipartUploadCommand,
+  InitiateVaultLockCommand: () => InitiateVaultLockCommand,
+  InsufficientCapacityException: () => InsufficientCapacityException,
+  InvalidParameterValueException: () => InvalidParameterValueException,
+  LimitExceededException: () => LimitExceededException,
+  ListJobsCommand: () => ListJobsCommand,
+  ListMultipartUploadsCommand: () => ListMultipartUploadsCommand,
+  ListPartsCommand: () => ListPartsCommand,
+  ListProvisionedCapacityCommand: () => ListProvisionedCapacityCommand,
+  ListTagsForVaultCommand: () => ListTagsForVaultCommand,
+  ListVaultsCommand: () => ListVaultsCommand,
+  MissingParameterValueException: () => MissingParameterValueException,
+  Permission: () => Permission,
+  PolicyEnforcedException: () => PolicyEnforcedException,
+  PurchaseProvisionedCapacityCommand: () => PurchaseProvisionedCapacityCommand,
+  QuoteFields: () => QuoteFields,
+  RemoveTagsFromVaultCommand: () => RemoveTagsFromVaultCommand,
+  RequestTimeoutException: () => RequestTimeoutException,
+  ResourceNotFoundException: () => ResourceNotFoundException,
+  ServiceUnavailableException: () => ServiceUnavailableException,
+  SetDataRetrievalPolicyCommand: () => SetDataRetrievalPolicyCommand,
+  SetVaultAccessPolicyCommand: () => SetVaultAccessPolicyCommand,
+  SetVaultNotificationsCommand: () => SetVaultNotificationsCommand,
+  StatusCode: () => StatusCode,
+  StorageClass: () => StorageClass,
+  Type: () => Type,
+  UploadArchiveCommand: () => UploadArchiveCommand,
+  UploadArchiveInputFilterSensitiveLog: () => UploadArchiveInputFilterSensitiveLog,
+  UploadMultipartPartCommand: () => UploadMultipartPartCommand,
+  UploadMultipartPartInputFilterSensitiveLog: () => UploadMultipartPartInputFilterSensitiveLog,
+  __Client: () => import_smithy_client.Client,
+  paginateListJobs: () => paginateListJobs,
+  paginateListMultipartUploads: () => paginateListMultipartUploads,
+  paginateListParts: () => paginateListParts,
+  paginateListVaults: () => paginateListVaults,
+  waitForVaultExists: () => waitForVaultExists,
+  waitForVaultNotExists: () => waitForVaultNotExists,
+  waitUntilVaultExists: () => waitUntilVaultExists,
+  waitUntilVaultNotExists: () => waitUntilVaultNotExists
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/GlacierClient.ts
+var import_middleware_host_header = require("@aws-sdk/middleware-host-header");
+var import_middleware_logger = require("@aws-sdk/middleware-logger");
+var import_middleware_recursion_detection = require("@aws-sdk/middleware-recursion-detection");
+var import_middleware_sdk_glacier = require("@aws-sdk/middleware-sdk-glacier");
+var import_middleware_user_agent = require("@aws-sdk/middleware-user-agent");
+var import_config_resolver = require("@smithy/config-resolver");
+var import_core = require("@smithy/core");
+var import_middleware_content_length = require("@smithy/middleware-content-length");
+var import_middleware_endpoint = require("@smithy/middleware-endpoint");
+var import_middleware_retry = require("@smithy/middleware-retry");
+
+var import_httpAuthSchemeProvider = require("./auth/httpAuthSchemeProvider");
+
+// src/endpoint/EndpointParameters.ts
+var resolveClientEndpointParameters = /* @__PURE__ */ __name((options) => {
+  return {
+    ...options,
+    useDualstackEndpoint: options.useDualstackEndpoint ?? false,
+    useFipsEndpoint: options.useFipsEndpoint ?? false,
+    defaultSigningName: "glacier"
+  };
+}, "resolveClientEndpointParameters");
+var commonParams = {
+  UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+  Endpoint: { type: "builtInParams", name: "endpoint" },
+  Region: { type: "builtInParams", name: "region" },
+  UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
+};
+
+// src/GlacierClient.ts
+var import_runtimeConfig = require("././runtimeConfig");
+
+// src/runtimeExtensions.ts
+var import_region_config_resolver = require("@aws-sdk/region-config-resolver");
+var import_protocol_http = require("@smithy/protocol-http");
+var import_smithy_client = require("@smithy/smithy-client");
+
+// src/auth/httpAuthExtensionConfiguration.ts
+var getHttpAuthExtensionConfiguration = /* @__PURE__ */ __name((runtimeConfig) => {
+  const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
+  let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
+  let _credentials = runtimeConfig.credentials;
+  return {
+    setHttpAuthScheme(httpAuthScheme) {
+      const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
+      if (index === -1) {
+        _httpAuthSchemes.push(httpAuthScheme);
+      } else {
+        _httpAuthSchemes.splice(index, 1, httpAuthScheme);
+      }
+    },
+    httpAuthSchemes() {
+      return _httpAuthSchemes;
+    },
+    setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
+      _httpAuthSchemeProvider = httpAuthSchemeProvider;
+    },
+    httpAuthSchemeProvider() {
+      return _httpAuthSchemeProvider;
+    },
+    setCredentials(credentials) {
+      _credentials = credentials;
+    },
+    credentials() {
+      return _credentials;
+    }
+  };
+}, "getHttpAuthExtensionConfiguration");
+var resolveHttpAuthRuntimeConfig = /* @__PURE__ */ __name((config) => {
+  return {
+    httpAuthSchemes: config.httpAuthSchemes(),
+    httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
+    credentials: config.credentials()
+  };
+}, "resolveHttpAuthRuntimeConfig");
+
+// src/runtimeExtensions.ts
+var asPartial = /* @__PURE__ */ __name((t) => t, "asPartial");
+var resolveRuntimeExtensions = /* @__PURE__ */ __name((runtimeConfig, extensions) => {
+  const extensionConfiguration = {
+    ...asPartial((0, import_region_config_resolver.getAwsRegionExtensionConfiguration)(runtimeConfig)),
+    ...asPartial((0, import_smithy_client.getDefaultExtensionConfiguration)(runtimeConfig)),
+    ...asPartial((0, import_protocol_http.getHttpHandlerExtensionConfiguration)(runtimeConfig)),
+    ...asPartial(getHttpAuthExtensionConfiguration(runtimeConfig))
+  };
+  extensions.forEach((extension) => extension.configure(extensionConfiguration));
+  return {
+    ...runtimeConfig,
+    ...(0, import_region_config_resolver.resolveAwsRegionExtensionConfiguration)(extensionConfiguration),
+    ...(0, import_smithy_client.resolveDefaultRuntimeConfig)(extensionConfiguration),
+    ...(0, import_protocol_http.resolveHttpHandlerRuntimeConfig)(extensionConfiguration),
+    ...resolveHttpAuthRuntimeConfig(extensionConfiguration)
+  };
+}, "resolveRuntimeExtensions");
+
+// src/GlacierClient.ts
+var _GlacierClient = class _GlacierClient extends import_smithy_client.Client {
+  constructor(...[configuration]) {
+    const _config_0 = (0, import_runtimeConfig.getRuntimeConfig)(configuration || {});
+    const _config_1 = resolveClientEndpointParameters(_config_0);
+    const _config_2 = (0, import_config_resolver.resolveRegionConfig)(_config_1);
+    const _config_3 = (0, import_middleware_endpoint.resolveEndpointConfig)(_config_2);
+    const _config_4 = (0, import_middleware_retry.resolveRetryConfig)(_config_3);
+    const _config_5 = (0, import_middleware_host_header.resolveHostHeaderConfig)(_config_4);
+    const _config_6 = (0, import_middleware_user_agent.resolveUserAgentConfig)(_config_5);
+    const _config_7 = (0, import_httpAuthSchemeProvider.resolveHttpAuthSchemeConfig)(_config_6);
+    const _config_8 = resolveRuntimeExtensions(_config_7, (configuration == null ? void 0 : configuration.extensions) || []);
+    super(_config_8);
+    this.config = _config_8;
+    this.middlewareStack.use((0, import_middleware_retry.getRetryPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_content_length.getContentLengthPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_sdk_glacier.getGlacierPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_host_header.getHostHeaderPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_logger.getLoggerPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_recursion_detection.getRecursionDetectionPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_user_agent.getUserAgentPlugin)(this.config));
+    this.middlewareStack.use(
+      (0, import_core.getHttpAuthSchemeEndpointRuleSetPlugin)(this.config, {
+        httpAuthSchemeParametersProvider: this.getDefaultHttpAuthSchemeParametersProvider(),
+        identityProviderConfigProvider: this.getIdentityProviderConfigProvider()
+      })
+    );
+    this.middlewareStack.use((0, import_core.getHttpSigningPlugin)(this.config));
+  }
+  /**
+   * Destroy underlying resources, like sockets. It's usually not necessary to do this.
+   * However in Node.js, it's best to explicitly shut down the client's agent when it is no longer needed.
+   * Otherwise, sockets might stay open for quite a long time before the server terminates them.
+   */
+  destroy() {
+    super.destroy();
+  }
+  getDefaultHttpAuthSchemeParametersProvider() {
+    return import_httpAuthSchemeProvider.defaultGlacierHttpAuthSchemeParametersProvider;
+  }
+  getIdentityProviderConfigProvider() {
+    return async (config) => new import_core.DefaultIdentityProviderConfig({
+      "aws.auth#sigv4": config.credentials
+    });
+  }
+};
+__name(_GlacierClient, "GlacierClient");
+var GlacierClient = _GlacierClient;
+
+// src/Glacier.ts
+
+
+// src/commands/AbortMultipartUploadCommand.ts
+
+var import_middleware_serde = require("@smithy/middleware-serde");
+
+var import_types = require("@smithy/types");
+
+// src/protocols/Aws_restJson1.ts
+
+
+
+// src/models/GlacierServiceException.ts
+
+var _GlacierServiceException = class _GlacierServiceException extends import_smithy_client.ServiceException {
+  /**
+   * @internal
+   */
+  constructor(options) {
+    super(options);
+    Object.setPrototypeOf(this, _GlacierServiceException.prototype);
+  }
+};
+__name(_GlacierServiceException, "GlacierServiceException");
+var GlacierServiceException = _GlacierServiceException;
+
+// src/models/models_0.ts
+var _InvalidParameterValueException = class _InvalidParameterValueException extends GlacierServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InvalidParameterValueException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "InvalidParameterValueException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _InvalidParameterValueException.prototype);
+    this.type = opts.type;
+    this.code = opts.code;
+  }
+};
+__name(_InvalidParameterValueException, "InvalidParameterValueException");
+var InvalidParameterValueException = _InvalidParameterValueException;
+var _MissingParameterValueException = class _MissingParameterValueException extends GlacierServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "MissingParameterValueException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "MissingParameterValueException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _MissingParameterValueException.prototype);
+    this.type = opts.type;
+    this.code = opts.code;
+  }
+};
+__name(_MissingParameterValueException, "MissingParameterValueException");
+var MissingParameterValueException = _MissingParameterValueException;
+var _ResourceNotFoundException = class _ResourceNotFoundException extends GlacierServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ResourceNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ResourceNotFoundException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ResourceNotFoundException.prototype);
+    this.type = opts.type;
+    this.code = opts.code;
+  }
+};
+__name(_ResourceNotFoundException, "ResourceNotFoundException");
+var ResourceNotFoundException = _ResourceNotFoundException;
+var _ServiceUnavailableException = class _ServiceUnavailableException extends GlacierServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ServiceUnavailableException",
+      $fault: "server",
+      ...opts
+    });
+    this.name = "ServiceUnavailableException";
+    this.$fault = "server";
+    Object.setPrototypeOf(this, _ServiceUnavailableException.prototype);
+    this.type = opts.type;
+    this.code = opts.code;
+  }
+};
+__name(_ServiceUnavailableException, "ServiceUnavailableException");
+var ServiceUnavailableException = _ServiceUnavailableException;
+var Type = {
+  AmazonCustomerByEmail: "AmazonCustomerByEmail",
+  CanonicalUser: "CanonicalUser",
+  Group: "Group"
+};
+var Permission = {
+  FULL_CONTROL: "FULL_CONTROL",
+  READ: "READ",
+  READ_ACP: "READ_ACP",
+  WRITE: "WRITE",
+  WRITE_ACP: "WRITE_ACP"
+};
+var ActionCode = {
+  ArchiveRetrieval: "ArchiveRetrieval",
+  InventoryRetrieval: "InventoryRetrieval",
+  Select: "Select"
+};
+var _LimitExceededException = class _LimitExceededException extends GlacierServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "LimitExceededException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "LimitExceededException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _LimitExceededException.prototype);
+    this.type = opts.type;
+    this.code = opts.code;
+  }
+};
+__name(_LimitExceededException, "LimitExceededException");
+var LimitExceededException = _LimitExceededException;
+var CannedACL = {
+  AuthenticatedRead: "authenticated-read",
+  AwsExecRead: "aws-exec-read",
+  BucketOwnerFullControl: "bucket-owner-full-control",
+  BucketOwnerRead: "bucket-owner-read",
+  Private: "private",
+  PublicRead: "public-read",
+  PublicReadWrite: "public-read-write"
+};
+var FileHeaderInfo = {
+  Ignore: "IGNORE",
+  None: "NONE",
+  Use: "USE"
+};
+var QuoteFields = {
+  Always: "ALWAYS",
+  AsNeeded: "ASNEEDED"
+};
+var EncryptionType = {
+  KMS: "aws:kms",
+  S3: "AES256"
+};
+var StorageClass = {
+  ReducedRedundancy: "REDUCED_REDUNDANCY",
+  Standard: "STANDARD",
+  StandardInfrequentAccess: "STANDARD_IA"
+};
+var ExpressionType = {
+  SQL: "SQL"
+};
+var StatusCode = {
+  Failed: "Failed",
+  InProgress: "InProgress",
+  Succeeded: "Succeeded"
+};
+var _InsufficientCapacityException = class _InsufficientCapacityException extends GlacierServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InsufficientCapacityException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "InsufficientCapacityException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _InsufficientCapacityException.prototype);
+    this.type = opts.type;
+    this.code = opts.code;
+  }
+};
+__name(_InsufficientCapacityException, "InsufficientCapacityException");
+var InsufficientCapacityException = _InsufficientCapacityException;
+var _PolicyEnforcedException = class _PolicyEnforcedException extends GlacierServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "PolicyEnforcedException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "PolicyEnforcedException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _PolicyEnforcedException.prototype);
+    this.type = opts.type;
+    this.code = opts.code;
+  }
+};
+__name(_PolicyEnforcedException, "PolicyEnforcedException");
+var PolicyEnforcedException = _PolicyEnforcedException;
+var _RequestTimeoutException = class _RequestTimeoutException extends GlacierServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "RequestTimeoutException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "RequestTimeoutException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _RequestTimeoutException.prototype);
+    this.type = opts.type;
+    this.code = opts.code;
+  }
+};
+__name(_RequestTimeoutException, "RequestTimeoutException");
+var RequestTimeoutException = _RequestTimeoutException;
+var GetJobOutputOutputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj
+}), "GetJobOutputOutputFilterSensitiveLog");
+var UploadArchiveInputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj
+}), "UploadArchiveInputFilterSensitiveLog");
+var UploadMultipartPartInputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj
+}), "UploadMultipartPartInputFilterSensitiveLog");
+
+// src/protocols/Aws_restJson1.ts
+var se_AbortMultipartUploadCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/{accountId}/vaults/{vaultName}/multipart-uploads/{uploadId}");
+  b.p("accountId", () => input.accountId, "{accountId}", false);
+  b.p("vaultName", () => input.vaultName, "{vaultName}", false);
+  b.p("uploadId", () => input.uploadId, "{uploadId}", false);
+  let body;
+  b.m("DELETE").h(headers).b(body);
+  return b.build();
+}, "se_AbortMultipartUploadCommand");
+var se_AbortVaultLockCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/{accountId}/vaults/{vaultName}/lock-policy");
+  b.p("accountId", () => input.accountId, "{accountId}", false);
+  b.p("vaultName", () => input.vaultName, "{vaultName}", false);
+  let body;
+  b.m("DELETE").h(headers).b(body);
+  return b.build();
+}, "se_AbortVaultLockCommand");
+var se_AddTagsToVaultCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/{accountId}/vaults/{vaultName}/tags");
+  b.p("accountId", () => input.accountId, "{accountId}", false);
+  b.p("vaultName", () => input.vaultName, "{vaultName}", false);
+  const query = (0, import_smithy_client.map)({
+    [_o]: [, "add"]
+  });
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      Tags: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).q(query).b(body);
+  return b.build();
+}, "se_AddTagsToVaultCommand");
+var se_CompleteMultipartUploadCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = (0, import_smithy_client.map)({}, isSerializableHeaderValue, {
+    [_xaas]: input[_aS],
+    [_xasth]: input[_c]
+  });
+  b.bp("/{accountId}/vaults/{vaultName}/multipart-uploads/{uploadId}");
+  b.p("accountId", () => input.accountId, "{accountId}", false);
+  b.p("vaultName", () => input.vaultName, "{vaultName}", false);
+  b.p("uploadId", () => input.uploadId, "{uploadId}", false);
+  let body;
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_CompleteMultipartUploadCommand");
+var se_CompleteVaultLockCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/{accountId}/vaults/{vaultName}/lock-policy/{lockId}");
+  b.p("accountId", () => input.accountId, "{accountId}", false);
+  b.p("vaultName", () => input.vaultName, "{vaultName}", false);
+  b.p("lockId", () => input.lockId, "{lockId}", false);
+  let body;
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_CompleteVaultLockCommand");
+var se_CreateVaultCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/{accountId}/vaults/{vaultName}");
+  b.p("accountId", () => input.accountId, "{accountId}", false);
+  b.p("vaultName", () => input.vaultName, "{vaultName}", false);
+  let body;
+  b.m("PUT").h(headers).b(body);
+  return b.build();
+}, "se_CreateVaultCommand");
+var se_DeleteArchiveCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/{accountId}/vaults/{vaultName}/archives/{archiveId}");
+  b.p("accountId", () => input.accountId, "{accountId}", false);
+  b.p("vaultName", () => input.vaultName, "{vaultName}", false);
+  b.p("archiveId", () => input.archiveId, "{archiveId}", false);
+  let body;
+  b.m("DELETE").h(headers).b(body);
+  return b.build();
+}, "se_DeleteArchiveCommand");
+var se_DeleteVaultCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/{accountId}/vaults/{vaultName}");
+  b.p("accountId", () => input.accountId, "{accountId}", false);
+  b.p("vaultName", () => input.vaultName, "{vaultName}", false);
+  let body;
+  b.m("DELETE").h(headers).b(body);
+  return b.build();
+}, "se_DeleteVaultCommand");
+var se_DeleteVaultAccessPolicyCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/{accountId}/vaults/{vaultName}/access-policy");
+  b.p("accountId", () => input.accountId, "{accountId}", false);
+  b.p("vaultName", () => input.vaultName, "{vaultName}", false);
+  let body;
+  b.m("DELETE").h(headers).b(body);
+  return b.build();
+}, "se_DeleteVaultAccessPolicyCommand");
+var se_DeleteVaultNotificationsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/{accountId}/vaults/{vaultName}/notification-configuration");
+  b.p("accountId", () => input.accountId, "{accountId}", false);
+  b.p("vaultName", () => input.vaultName, "{vaultName}", false);
+  let body;
+  b.m("DELETE").h(headers).b(body);
+  return b.build();
+}, "se_DeleteVaultNotificationsCommand");
+var se_DescribeJobCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/{accountId}/vaults/{vaultName}/jobs/{jobId}");
+  b.p("accountId", () => input.accountId, "{accountId}", false);
+  b.p("vaultName", () => input.vaultName, "{vaultName}", false);
+  b.p("jobId", () => input.jobId, "{jobId}", false);
+  let body;
+  b.m("GET").h(headers).b(body);
+  return b.build();
+}, "se_DescribeJobCommand");
+var se_DescribeVaultCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/{accountId}/vaults/{vaultName}");
+  b.p("accountId", () => input.accountId, "{accountId}", false);
+  b.p("vaultName", () => input.vaultName, "{vaultName}", false);
+  let body;
+  b.m("GET").h(headers).b(body);
+  return b.build();
+}, "se_DescribeVaultCommand");
+var se_GetDataRetrievalPolicyCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/{accountId}/policies/data-retrieval");
+  b.p("accountId", () => input.accountId, "{accountId}", false);
+  let body;
+  b.m("GET").h(headers).b(body);
+  return b.build();
+}, "se_GetDataRetrievalPolicyCommand");
+var se_GetJobOutputCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = (0, import_smithy_client.map)({}, isSerializableHeaderValue, {
+    [_r]: input[_r]
+  });
+  b.bp("/{accountId}/vaults/{vaultName}/jobs/{jobId}/output");
+  b.p("accountId", () => input.accountId, "{accountId}", false);
+  b.p("vaultName", () => input.vaultName, "{vaultName}", false);
+  b.p("jobId", () => input.jobId, "{jobId}", false);
+  let body;
+  b.m("GET").h(headers).b(body);
+  return b.build();
+}, "se_GetJobOutputCommand");
+var se_GetVaultAccessPolicyCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/{accountId}/vaults/{vaultName}/access-policy");
+  b.p("accountId", () => input.accountId, "{accountId}", false);
+  b.p("vaultName", () => input.vaultName, "{vaultName}", false);
+  let body;
+  b.m("GET").h(headers).b(body);
+  return b.build();
+}, "se_GetVaultAccessPolicyCommand");
+var se_GetVaultLockCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/{accountId}/vaults/{vaultName}/lock-policy");
+  b.p("accountId", () => input.accountId, "{accountId}", false);
+  b.p("vaultName", () => input.vaultName, "{vaultName}", false);
+  let body;
+  b.m("GET").h(headers).b(body);
+  return b.build();
+}, "se_GetVaultLockCommand");
+var se_GetVaultNotificationsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/{accountId}/vaults/{vaultName}/notification-configuration");
+  b.p("accountId", () => input.accountId, "{accountId}", false);
+  b.p("vaultName", () => input.vaultName, "{vaultName}", false);
+  let body;
+  b.m("GET").h(headers).b(body);
+  return b.build();
+}, "se_GetVaultNotificationsCommand");
+var se_InitiateJobCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/{accountId}/vaults/{vaultName}/jobs");
+  b.p("accountId", () => input.accountId, "{accountId}", false);
+  b.p("vaultName", () => input.vaultName, "{vaultName}", false);
+  let body;
+  if (input.jobParameters !== void 0) {
+    body = (0, import_smithy_client._json)(input.jobParameters);
+  }
+  if (body === void 0) {
+    body = {};
+  }
+  body = JSON.stringify(body);
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_InitiateJobCommand");
+var se_InitiateMultipartUploadCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = (0, import_smithy_client.map)({}, isSerializableHeaderValue, {
+    [_xaad]: input[_aD],
+    [_xaps]: input[_pS]
+  });
+  b.bp("/{accountId}/vaults/{vaultName}/multipart-uploads");
+  b.p("accountId", () => input.accountId, "{accountId}", false);
+  b.p("vaultName", () => input.vaultName, "{vaultName}", false);
+  let body;
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_InitiateMultipartUploadCommand");
+var se_InitiateVaultLockCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/{accountId}/vaults/{vaultName}/lock-policy");
+  b.p("accountId", () => input.accountId, "{accountId}", false);
+  b.p("vaultName", () => input.vaultName, "{vaultName}", false);
+  let body;
+  if (input.policy !== void 0) {
+    body = (0, import_smithy_client._json)(input.policy);
+  }
+  if (body === void 0) {
+    body = {};
+  }
+  body = JSON.stringify(body);
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_InitiateVaultLockCommand");
+var se_ListJobsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/{accountId}/vaults/{vaultName}/jobs");
+  b.p("accountId", () => input.accountId, "{accountId}", false);
+  b.p("vaultName", () => input.vaultName, "{vaultName}", false);
+  const query = (0, import_smithy_client.map)({
+    [_l]: [() => input.limit !== void 0, () => input[_l].toString()],
+    [_m]: [, input[_m]],
+    [_s]: [, input[_s]],
+    [_co]: [, input[_co]]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_ListJobsCommand");
+var se_ListMultipartUploadsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/{accountId}/vaults/{vaultName}/multipart-uploads");
+  b.p("accountId", () => input.accountId, "{accountId}", false);
+  b.p("vaultName", () => input.vaultName, "{vaultName}", false);
+  const query = (0, import_smithy_client.map)({
+    [_l]: [() => input.limit !== void 0, () => input[_l].toString()],
+    [_m]: [, input[_m]]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_ListMultipartUploadsCommand");
+var se_ListPartsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/{accountId}/vaults/{vaultName}/multipart-uploads/{uploadId}");
+  b.p("accountId", () => input.accountId, "{accountId}", false);
+  b.p("vaultName", () => input.vaultName, "{vaultName}", false);
+  b.p("uploadId", () => input.uploadId, "{uploadId}", false);
+  const query = (0, import_smithy_client.map)({
+    [_m]: [, input[_m]],
+    [_l]: [() => input.limit !== void 0, () => input[_l].toString()]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_ListPartsCommand");
+var se_ListProvisionedCapacityCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/{accountId}/provisioned-capacity");
+  b.p("accountId", () => input.accountId, "{accountId}", false);
+  let body;
+  b.m("GET").h(headers).b(body);
+  return b.build();
+}, "se_ListProvisionedCapacityCommand");
+var se_ListTagsForVaultCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/{accountId}/vaults/{vaultName}/tags");
+  b.p("accountId", () => input.accountId, "{accountId}", false);
+  b.p("vaultName", () => input.vaultName, "{vaultName}", false);
+  let body;
+  b.m("GET").h(headers).b(body);
+  return b.build();
+}, "se_ListTagsForVaultCommand");
+var se_ListVaultsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/{accountId}/vaults");
+  b.p("accountId", () => input.accountId, "{accountId}", false);
+  const query = (0, import_smithy_client.map)({
+    [_m]: [, input[_m]],
+    [_l]: [() => input.limit !== void 0, () => input[_l].toString()]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_ListVaultsCommand");
+var se_PurchaseProvisionedCapacityCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/{accountId}/provisioned-capacity");
+  b.p("accountId", () => input.accountId, "{accountId}", false);
+  let body;
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_PurchaseProvisionedCapacityCommand");
+var se_RemoveTagsFromVaultCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/{accountId}/vaults/{vaultName}/tags");
+  b.p("accountId", () => input.accountId, "{accountId}", false);
+  b.p("vaultName", () => input.vaultName, "{vaultName}", false);
+  const query = (0, import_smithy_client.map)({
+    [_o]: [, "remove"]
+  });
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      TagKeys: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).q(query).b(body);
+  return b.build();
+}, "se_RemoveTagsFromVaultCommand");
+var se_SetDataRetrievalPolicyCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/{accountId}/policies/data-retrieval");
+  b.p("accountId", () => input.accountId, "{accountId}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      Policy: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("PUT").h(headers).b(body);
+  return b.build();
+}, "se_SetDataRetrievalPolicyCommand");
+var se_SetVaultAccessPolicyCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/{accountId}/vaults/{vaultName}/access-policy");
+  b.p("accountId", () => input.accountId, "{accountId}", false);
+  b.p("vaultName", () => input.vaultName, "{vaultName}", false);
+  let body;
+  if (input.policy !== void 0) {
+    body = (0, import_smithy_client._json)(input.policy);
+  }
+  if (body === void 0) {
+    body = {};
+  }
+  body = JSON.stringify(body);
+  b.m("PUT").h(headers).b(body);
+  return b.build();
+}, "se_SetVaultAccessPolicyCommand");
+var se_SetVaultNotificationsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/{accountId}/vaults/{vaultName}/notification-configuration");
+  b.p("accountId", () => input.accountId, "{accountId}", false);
+  b.p("vaultName", () => input.vaultName, "{vaultName}", false);
+  let body;
+  if (input.vaultNotificationConfig !== void 0) {
+    body = (0, import_smithy_client._json)(input.vaultNotificationConfig);
+  }
+  if (body === void 0) {
+    body = {};
+  }
+  body = JSON.stringify(body);
+  b.m("PUT").h(headers).b(body);
+  return b.build();
+}, "se_SetVaultNotificationsCommand");
+var se_UploadArchiveCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = (0, import_smithy_client.map)({}, isSerializableHeaderValue, {
+    "content-type": "application/octet-stream",
+    [_xaad]: input[_aD],
+    [_xasth]: input[_c]
+  });
+  b.bp("/{accountId}/vaults/{vaultName}/archives");
+  b.p("vaultName", () => input.vaultName, "{vaultName}", false);
+  b.p("accountId", () => input.accountId, "{accountId}", false);
+  let body;
+  if (input.body !== void 0) {
+    body = input.body;
+  }
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_UploadArchiveCommand");
+var se_UploadMultipartPartCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = (0, import_smithy_client.map)({}, isSerializableHeaderValue, {
+    "content-type": "application/octet-stream",
+    [_xasth]: input[_c],
+    [_cr]: input[_r]
+  });
+  b.bp("/{accountId}/vaults/{vaultName}/multipart-uploads/{uploadId}");
+  b.p("accountId", () => input.accountId, "{accountId}", false);
+  b.p("vaultName", () => input.vaultName, "{vaultName}", false);
+  b.p("uploadId", () => input.uploadId, "{uploadId}", false);
+  let body;
+  if (input.body !== void 0) {
+    body = input.body;
+  }
+  b.m("PUT").h(headers).b(body);
+  return b.build();
+}, "se_UploadMultipartPartCommand");
+var de_AbortMultipartUploadCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 204 && output.statusCode >= 300) {
+    return de_AbortMultipartUploadCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_AbortMultipartUploadCommand");
+var de_AbortMultipartUploadCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidParameterValueException":
+    case "com.amazonaws.glacier#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "MissingParameterValueException":
+    case "com.amazonaws.glacier#MissingParameterValueException":
+      throw await de_MissingParameterValueExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.glacier#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.glacier#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_AbortMultipartUploadCommandError");
+var de_AbortVaultLockCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 204 && output.statusCode >= 300) {
+    return de_AbortVaultLockCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_AbortVaultLockCommand");
+var de_AbortVaultLockCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidParameterValueException":
+    case "com.amazonaws.glacier#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "MissingParameterValueException":
+    case "com.amazonaws.glacier#MissingParameterValueException":
+      throw await de_MissingParameterValueExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.glacier#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.glacier#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_AbortVaultLockCommandError");
+var de_AddTagsToVaultCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 204 && output.statusCode >= 300) {
+    return de_AddTagsToVaultCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_AddTagsToVaultCommand");
+var de_AddTagsToVaultCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidParameterValueException":
+    case "com.amazonaws.glacier#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.glacier#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "MissingParameterValueException":
+    case "com.amazonaws.glacier#MissingParameterValueException":
+      throw await de_MissingParameterValueExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.glacier#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.glacier#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_AddTagsToVaultCommandError");
+var de_CompleteMultipartUploadCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 201 && output.statusCode >= 300) {
+    return de_CompleteMultipartUploadCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output),
+    [_lo]: [, output.headers[_lo]],
+    [_c]: [, output.headers[_xasth]],
+    [_aI]: [, output.headers[_xaai]]
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_CompleteMultipartUploadCommand");
+var de_CompleteMultipartUploadCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidParameterValueException":
+    case "com.amazonaws.glacier#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "MissingParameterValueException":
+    case "com.amazonaws.glacier#MissingParameterValueException":
+      throw await de_MissingParameterValueExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.glacier#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.glacier#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CompleteMultipartUploadCommandError");
+var de_CompleteVaultLockCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 204 && output.statusCode >= 300) {
+    return de_CompleteVaultLockCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_CompleteVaultLockCommand");
+var de_CompleteVaultLockCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidParameterValueException":
+    case "com.amazonaws.glacier#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "MissingParameterValueException":
+    case "com.amazonaws.glacier#MissingParameterValueException":
+      throw await de_MissingParameterValueExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.glacier#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.glacier#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CompleteVaultLockCommandError");
+var de_CreateVaultCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 201 && output.statusCode >= 300) {
+    return de_CreateVaultCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output),
+    [_lo]: [, output.headers[_lo]]
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_CreateVaultCommand");
+var de_CreateVaultCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidParameterValueException":
+    case "com.amazonaws.glacier#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.glacier#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "MissingParameterValueException":
+    case "com.amazonaws.glacier#MissingParameterValueException":
+      throw await de_MissingParameterValueExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.glacier#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateVaultCommandError");
+var de_DeleteArchiveCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 204 && output.statusCode >= 300) {
+    return de_DeleteArchiveCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_DeleteArchiveCommand");
+var de_DeleteArchiveCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidParameterValueException":
+    case "com.amazonaws.glacier#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "MissingParameterValueException":
+    case "com.amazonaws.glacier#MissingParameterValueException":
+      throw await de_MissingParameterValueExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.glacier#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.glacier#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteArchiveCommandError");
+var de_DeleteVaultCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 204 && output.statusCode >= 300) {
+    return de_DeleteVaultCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_DeleteVaultCommand");
+var de_DeleteVaultCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidParameterValueException":
+    case "com.amazonaws.glacier#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "MissingParameterValueException":
+    case "com.amazonaws.glacier#MissingParameterValueException":
+      throw await de_MissingParameterValueExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.glacier#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.glacier#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteVaultCommandError");
+var de_DeleteVaultAccessPolicyCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 204 && output.statusCode >= 300) {
+    return de_DeleteVaultAccessPolicyCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_DeleteVaultAccessPolicyCommand");
+var de_DeleteVaultAccessPolicyCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidParameterValueException":
+    case "com.amazonaws.glacier#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "MissingParameterValueException":
+    case "com.amazonaws.glacier#MissingParameterValueException":
+      throw await de_MissingParameterValueExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.glacier#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.glacier#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteVaultAccessPolicyCommandError");
+var de_DeleteVaultNotificationsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 204 && output.statusCode >= 300) {
+    return de_DeleteVaultNotificationsCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_DeleteVaultNotificationsCommand");
+var de_DeleteVaultNotificationsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidParameterValueException":
+    case "com.amazonaws.glacier#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "MissingParameterValueException":
+    case "com.amazonaws.glacier#MissingParameterValueException":
+      throw await de_MissingParameterValueExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.glacier#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.glacier#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteVaultNotificationsCommandError");
+var de_DescribeJobCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DescribeJobCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    Action: import_smithy_client.expectString,
+    ArchiveId: import_smithy_client.expectString,
+    ArchiveSHA256TreeHash: import_smithy_client.expectString,
+    ArchiveSizeInBytes: import_smithy_client.expectLong,
+    Completed: import_smithy_client.expectBoolean,
+    CompletionDate: import_smithy_client.expectString,
+    CreationDate: import_smithy_client.expectString,
+    InventoryRetrievalParameters: import_smithy_client._json,
+    InventorySizeInBytes: import_smithy_client.expectLong,
+    JobDescription: import_smithy_client.expectString,
+    JobId: import_smithy_client.expectString,
+    JobOutputPath: import_smithy_client.expectString,
+    OutputLocation: import_smithy_client._json,
+    RetrievalByteRange: import_smithy_client.expectString,
+    SHA256TreeHash: import_smithy_client.expectString,
+    SNSTopic: import_smithy_client.expectString,
+    SelectParameters: import_smithy_client._json,
+    StatusCode: import_smithy_client.expectString,
+    StatusMessage: import_smithy_client.expectString,
+    Tier: import_smithy_client.expectString,
+    VaultARN: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_DescribeJobCommand");
+var de_DescribeJobCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidParameterValueException":
+    case "com.amazonaws.glacier#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "MissingParameterValueException":
+    case "com.amazonaws.glacier#MissingParameterValueException":
+      throw await de_MissingParameterValueExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.glacier#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.glacier#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeJobCommandError");
+var de_DescribeVaultCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DescribeVaultCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    CreationDate: import_smithy_client.expectString,
+    LastInventoryDate: import_smithy_client.expectString,
+    NumberOfArchives: import_smithy_client.expectLong,
+    SizeInBytes: import_smithy_client.expectLong,
+    VaultARN: import_smithy_client.expectString,
+    VaultName: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_DescribeVaultCommand");
+var de_DescribeVaultCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidParameterValueException":
+    case "com.amazonaws.glacier#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "MissingParameterValueException":
+    case "com.amazonaws.glacier#MissingParameterValueException":
+      throw await de_MissingParameterValueExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.glacier#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.glacier#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeVaultCommandError");
+var de_GetDataRetrievalPolicyCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetDataRetrievalPolicyCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    Policy: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetDataRetrievalPolicyCommand");
+var de_GetDataRetrievalPolicyCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidParameterValueException":
+    case "com.amazonaws.glacier#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "MissingParameterValueException":
+    case "com.amazonaws.glacier#MissingParameterValueException":
+      throw await de_MissingParameterValueExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.glacier#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetDataRetrievalPolicyCommandError");
+var de_GetJobOutputCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetJobOutputCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output),
+    [_c]: [, output.headers[_xasth]],
+    [_cR]: [, output.headers[_cr]],
+    [_aR]: [, output.headers[_ar]],
+    [_cT]: [, output.headers[_ct]],
+    [_aD]: [, output.headers[_xaad]]
+  });
+  const data = output.body;
+  context.sdkStreamMixin(data);
+  contents.body = data;
+  (0, import_smithy_client.map)(contents, {
+    status: [, output.statusCode]
+  });
+  return contents;
+}, "de_GetJobOutputCommand");
+var de_GetJobOutputCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidParameterValueException":
+    case "com.amazonaws.glacier#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "MissingParameterValueException":
+    case "com.amazonaws.glacier#MissingParameterValueException":
+      throw await de_MissingParameterValueExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.glacier#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.glacier#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetJobOutputCommandError");
+var de_GetVaultAccessPolicyCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetVaultAccessPolicyCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectObject)(await parseBody(output.body, context));
+  contents.policy = (0, import_smithy_client._json)(data);
+  return contents;
+}, "de_GetVaultAccessPolicyCommand");
+var de_GetVaultAccessPolicyCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidParameterValueException":
+    case "com.amazonaws.glacier#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "MissingParameterValueException":
+    case "com.amazonaws.glacier#MissingParameterValueException":
+      throw await de_MissingParameterValueExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.glacier#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.glacier#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetVaultAccessPolicyCommandError");
+var de_GetVaultLockCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetVaultLockCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    CreationDate: import_smithy_client.expectString,
+    ExpirationDate: import_smithy_client.expectString,
+    Policy: import_smithy_client.expectString,
+    State: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetVaultLockCommand");
+var de_GetVaultLockCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidParameterValueException":
+    case "com.amazonaws.glacier#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "MissingParameterValueException":
+    case "com.amazonaws.glacier#MissingParameterValueException":
+      throw await de_MissingParameterValueExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.glacier#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.glacier#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetVaultLockCommandError");
+var de_GetVaultNotificationsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetVaultNotificationsCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectObject)(await parseBody(output.body, context));
+  contents.vaultNotificationConfig = (0, import_smithy_client._json)(data);
+  return contents;
+}, "de_GetVaultNotificationsCommand");
+var de_GetVaultNotificationsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidParameterValueException":
+    case "com.amazonaws.glacier#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "MissingParameterValueException":
+    case "com.amazonaws.glacier#MissingParameterValueException":
+      throw await de_MissingParameterValueExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.glacier#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.glacier#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetVaultNotificationsCommandError");
+var de_InitiateJobCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 202 && output.statusCode >= 300) {
+    return de_InitiateJobCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output),
+    [_lo]: [, output.headers[_lo]],
+    [_jI]: [, output.headers[_xaji]],
+    [_jOP]: [, output.headers[_xajop]]
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_InitiateJobCommand");
+var de_InitiateJobCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InsufficientCapacityException":
+    case "com.amazonaws.glacier#InsufficientCapacityException":
+      throw await de_InsufficientCapacityExceptionRes(parsedOutput, context);
+    case "InvalidParameterValueException":
+    case "com.amazonaws.glacier#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "MissingParameterValueException":
+    case "com.amazonaws.glacier#MissingParameterValueException":
+      throw await de_MissingParameterValueExceptionRes(parsedOutput, context);
+    case "PolicyEnforcedException":
+    case "com.amazonaws.glacier#PolicyEnforcedException":
+      throw await de_PolicyEnforcedExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.glacier#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.glacier#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_InitiateJobCommandError");
+var de_InitiateMultipartUploadCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 201 && output.statusCode >= 300) {
+    return de_InitiateMultipartUploadCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output),
+    [_lo]: [, output.headers[_lo]],
+    [_uI]: [, output.headers[_xamui]]
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_InitiateMultipartUploadCommand");
+var de_InitiateMultipartUploadCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidParameterValueException":
+    case "com.amazonaws.glacier#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "MissingParameterValueException":
+    case "com.amazonaws.glacier#MissingParameterValueException":
+      throw await de_MissingParameterValueExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.glacier#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.glacier#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_InitiateMultipartUploadCommandError");
+var de_InitiateVaultLockCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 201 && output.statusCode >= 300) {
+    return de_InitiateVaultLockCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output),
+    [_lI]: [, output.headers[_xali]]
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_InitiateVaultLockCommand");
+var de_InitiateVaultLockCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidParameterValueException":
+    case "com.amazonaws.glacier#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "MissingParameterValueException":
+    case "com.amazonaws.glacier#MissingParameterValueException":
+      throw await de_MissingParameterValueExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.glacier#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.glacier#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_InitiateVaultLockCommandError");
+var de_ListJobsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListJobsCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    JobList: import_smithy_client._json,
+    Marker: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListJobsCommand");
+var de_ListJobsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidParameterValueException":
+    case "com.amazonaws.glacier#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "MissingParameterValueException":
+    case "com.amazonaws.glacier#MissingParameterValueException":
+      throw await de_MissingParameterValueExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.glacier#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.glacier#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListJobsCommandError");
+var de_ListMultipartUploadsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListMultipartUploadsCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    Marker: import_smithy_client.expectString,
+    UploadsList: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListMultipartUploadsCommand");
+var de_ListMultipartUploadsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidParameterValueException":
+    case "com.amazonaws.glacier#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "MissingParameterValueException":
+    case "com.amazonaws.glacier#MissingParameterValueException":
+      throw await de_MissingParameterValueExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.glacier#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.glacier#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListMultipartUploadsCommandError");
+var de_ListPartsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListPartsCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    ArchiveDescription: import_smithy_client.expectString,
+    CreationDate: import_smithy_client.expectString,
+    Marker: import_smithy_client.expectString,
+    MultipartUploadId: import_smithy_client.expectString,
+    PartSizeInBytes: import_smithy_client.expectLong,
+    Parts: import_smithy_client._json,
+    VaultARN: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListPartsCommand");
+var de_ListPartsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidParameterValueException":
+    case "com.amazonaws.glacier#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "MissingParameterValueException":
+    case "com.amazonaws.glacier#MissingParameterValueException":
+      throw await de_MissingParameterValueExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.glacier#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.glacier#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListPartsCommandError");
+var de_ListProvisionedCapacityCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListProvisionedCapacityCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    ProvisionedCapacityList: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListProvisionedCapacityCommand");
+var de_ListProvisionedCapacityCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidParameterValueException":
+    case "com.amazonaws.glacier#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "MissingParameterValueException":
+    case "com.amazonaws.glacier#MissingParameterValueException":
+      throw await de_MissingParameterValueExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.glacier#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListProvisionedCapacityCommandError");
+var de_ListTagsForVaultCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListTagsForVaultCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    Tags: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListTagsForVaultCommand");
+var de_ListTagsForVaultCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidParameterValueException":
+    case "com.amazonaws.glacier#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "MissingParameterValueException":
+    case "com.amazonaws.glacier#MissingParameterValueException":
+      throw await de_MissingParameterValueExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.glacier#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.glacier#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListTagsForVaultCommandError");
+var de_ListVaultsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListVaultsCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    Marker: import_smithy_client.expectString,
+    VaultList: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListVaultsCommand");
+var de_ListVaultsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidParameterValueException":
+    case "com.amazonaws.glacier#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "MissingParameterValueException":
+    case "com.amazonaws.glacier#MissingParameterValueException":
+      throw await de_MissingParameterValueExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.glacier#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.glacier#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListVaultsCommandError");
+var de_PurchaseProvisionedCapacityCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 201 && output.statusCode >= 300) {
+    return de_PurchaseProvisionedCapacityCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output),
+    [_cI]: [, output.headers[_xaci]]
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_PurchaseProvisionedCapacityCommand");
+var de_PurchaseProvisionedCapacityCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidParameterValueException":
+    case "com.amazonaws.glacier#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.glacier#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "MissingParameterValueException":
+    case "com.amazonaws.glacier#MissingParameterValueException":
+      throw await de_MissingParameterValueExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.glacier#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_PurchaseProvisionedCapacityCommandError");
+var de_RemoveTagsFromVaultCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 204 && output.statusCode >= 300) {
+    return de_RemoveTagsFromVaultCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_RemoveTagsFromVaultCommand");
+var de_RemoveTagsFromVaultCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidParameterValueException":
+    case "com.amazonaws.glacier#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "MissingParameterValueException":
+    case "com.amazonaws.glacier#MissingParameterValueException":
+      throw await de_MissingParameterValueExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.glacier#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.glacier#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_RemoveTagsFromVaultCommandError");
+var de_SetDataRetrievalPolicyCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 204 && output.statusCode >= 300) {
+    return de_SetDataRetrievalPolicyCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_SetDataRetrievalPolicyCommand");
+var de_SetDataRetrievalPolicyCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidParameterValueException":
+    case "com.amazonaws.glacier#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "MissingParameterValueException":
+    case "com.amazonaws.glacier#MissingParameterValueException":
+      throw await de_MissingParameterValueExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.glacier#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_SetDataRetrievalPolicyCommandError");
+var de_SetVaultAccessPolicyCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 204 && output.statusCode >= 300) {
+    return de_SetVaultAccessPolicyCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_SetVaultAccessPolicyCommand");
+var de_SetVaultAccessPolicyCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidParameterValueException":
+    case "com.amazonaws.glacier#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "MissingParameterValueException":
+    case "com.amazonaws.glacier#MissingParameterValueException":
+      throw await de_MissingParameterValueExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.glacier#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.glacier#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_SetVaultAccessPolicyCommandError");
+var de_SetVaultNotificationsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 204 && output.statusCode >= 300) {
+    return de_SetVaultNotificationsCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_SetVaultNotificationsCommand");
+var de_SetVaultNotificationsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidParameterValueException":
+    case "com.amazonaws.glacier#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "MissingParameterValueException":
+    case "com.amazonaws.glacier#MissingParameterValueException":
+      throw await de_MissingParameterValueExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.glacier#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.glacier#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_SetVaultNotificationsCommandError");
+var de_UploadArchiveCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 201 && output.statusCode >= 300) {
+    return de_UploadArchiveCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output),
+    [_lo]: [, output.headers[_lo]],
+    [_c]: [, output.headers[_xasth]],
+    [_aI]: [, output.headers[_xaai]]
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_UploadArchiveCommand");
+var de_UploadArchiveCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidParameterValueException":
+    case "com.amazonaws.glacier#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "MissingParameterValueException":
+    case "com.amazonaws.glacier#MissingParameterValueException":
+      throw await de_MissingParameterValueExceptionRes(parsedOutput, context);
+    case "RequestTimeoutException":
+    case "com.amazonaws.glacier#RequestTimeoutException":
+      throw await de_RequestTimeoutExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.glacier#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.glacier#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UploadArchiveCommandError");
+var de_UploadMultipartPartCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 204 && output.statusCode >= 300) {
+    return de_UploadMultipartPartCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output),
+    [_c]: [, output.headers[_xasth]]
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_UploadMultipartPartCommand");
+var de_UploadMultipartPartCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidParameterValueException":
+    case "com.amazonaws.glacier#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "MissingParameterValueException":
+    case "com.amazonaws.glacier#MissingParameterValueException":
+      throw await de_MissingParameterValueExceptionRes(parsedOutput, context);
+    case "RequestTimeoutException":
+    case "com.amazonaws.glacier#RequestTimeoutException":
+      throw await de_RequestTimeoutExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.glacier#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.glacier#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UploadMultipartPartCommandError");
+var throwDefaultError = (0, import_smithy_client.withBaseException)(GlacierServiceException);
+var de_InsufficientCapacityExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    code: import_smithy_client.expectString,
+    message: import_smithy_client.expectString,
+    type: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new InsufficientCapacityException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_InsufficientCapacityExceptionRes");
+var de_InvalidParameterValueExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    code: import_smithy_client.expectString,
+    message: import_smithy_client.expectString,
+    type: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new InvalidParameterValueException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_InvalidParameterValueExceptionRes");
+var de_LimitExceededExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    code: import_smithy_client.expectString,
+    message: import_smithy_client.expectString,
+    type: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new LimitExceededException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_LimitExceededExceptionRes");
+var de_MissingParameterValueExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    code: import_smithy_client.expectString,
+    message: import_smithy_client.expectString,
+    type: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new MissingParameterValueException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_MissingParameterValueExceptionRes");
+var de_PolicyEnforcedExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    code: import_smithy_client.expectString,
+    message: import_smithy_client.expectString,
+    type: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new PolicyEnforcedException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_PolicyEnforcedExceptionRes");
+var de_RequestTimeoutExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    code: import_smithy_client.expectString,
+    message: import_smithy_client.expectString,
+    type: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new RequestTimeoutException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_RequestTimeoutExceptionRes");
+var de_ResourceNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    code: import_smithy_client.expectString,
+    message: import_smithy_client.expectString,
+    type: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new ResourceNotFoundException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ResourceNotFoundExceptionRes");
+var de_ServiceUnavailableExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    code: import_smithy_client.expectString,
+    message: import_smithy_client.expectString,
+    type: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new ServiceUnavailableException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ServiceUnavailableExceptionRes");
+var deserializeMetadata = /* @__PURE__ */ __name((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"]
+}), "deserializeMetadata");
+var collectBodyString = /* @__PURE__ */ __name((streamBody, context) => (0, import_smithy_client.collectBody)(streamBody, context).then((body) => context.utf8Encoder(body)), "collectBodyString");
+var isSerializableHeaderValue = /* @__PURE__ */ __name((value) => value !== void 0 && value !== null && value !== "" && (!Object.getOwnPropertyNames(value).includes("length") || value.length != 0) && (!Object.getOwnPropertyNames(value).includes("size") || value.size != 0), "isSerializableHeaderValue");
+var _aD = "archiveDescription";
+var _aI = "archiveId";
+var _aR = "acceptRanges";
+var _aS = "archiveSize";
+var _ar = "accept-ranges";
+var _c = "checksum";
+var _cI = "capacityId";
+var _cR = "contentRange";
+var _cT = "contentType";
+var _co = "completed";
+var _cr = "content-range";
+var _ct = "content-type";
+var _jI = "jobId";
+var _jOP = "jobOutputPath";
+var _l = "limit";
+var _lI = "lockId";
+var _lo = "location";
+var _m = "marker";
+var _o = "operation";
+var _pS = "partSize";
+var _r = "range";
+var _s = "statuscode";
+var _uI = "uploadId";
+var _xaad = "x-amz-archive-description";
+var _xaai = "x-amz-archive-id";
+var _xaas = "x-amz-archive-size";
+var _xaci = "x-amz-capacity-id";
+var _xaji = "x-amz-job-id";
+var _xajop = "x-amz-job-output-path";
+var _xali = "x-amz-lock-id";
+var _xamui = "x-amz-multipart-upload-id";
+var _xaps = "x-amz-part-size";
+var _xasth = "x-amz-sha256-tree-hash";
+var parseBody = /* @__PURE__ */ __name((streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
+  if (encoded.length) {
+    return JSON.parse(encoded);
+  }
+  return {};
+}), "parseBody");
+var parseErrorBody = /* @__PURE__ */ __name(async (errorBody, context) => {
+  const value = await parseBody(errorBody, context);
+  value.message = value.message ?? value.Message;
+  return value;
+}, "parseErrorBody");
+var loadRestJsonErrorCode = /* @__PURE__ */ __name((output, data) => {
+  const findKey = /* @__PURE__ */ __name((object, key) => Object.keys(object).find((k) => k.toLowerCase() === key.toLowerCase()), "findKey");
+  const sanitizeErrorCode = /* @__PURE__ */ __name((rawValue) => {
+    let cleanValue = rawValue;
+    if (typeof cleanValue === "number") {
+      cleanValue = cleanValue.toString();
+    }
+    if (cleanValue.indexOf(",") >= 0) {
+      cleanValue = cleanValue.split(",")[0];
+    }
+    if (cleanValue.indexOf(":") >= 0) {
+      cleanValue = cleanValue.split(":")[0];
+    }
+    if (cleanValue.indexOf("#") >= 0) {
+      cleanValue = cleanValue.split("#")[1];
+    }
+    return cleanValue;
+  }, "sanitizeErrorCode");
+  const headerKey = findKey(output.headers, "x-amzn-errortype");
+  if (headerKey !== void 0) {
+    return sanitizeErrorCode(output.headers[headerKey]);
+  }
+  if (data.code !== void 0) {
+    return sanitizeErrorCode(data.code);
+  }
+  if (data["__type"] !== void 0) {
+    return sanitizeErrorCode(data["__type"]);
+  }
+}, "loadRestJsonErrorCode");
+
+// src/commands/AbortMultipartUploadCommand.ts
+var _AbortMultipartUploadCommand = class _AbortMultipartUploadCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Glacier", "AbortMultipartUpload", {}).n("GlacierClient", "AbortMultipartUploadCommand").f(void 0, void 0).ser(se_AbortMultipartUploadCommand).de(de_AbortMultipartUploadCommand).build() {
+};
+__name(_AbortMultipartUploadCommand, "AbortMultipartUploadCommand");
+var AbortMultipartUploadCommand = _AbortMultipartUploadCommand;
+
+// src/commands/AbortVaultLockCommand.ts
+
+
+
+
+var _AbortVaultLockCommand = class _AbortVaultLockCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Glacier", "AbortVaultLock", {}).n("GlacierClient", "AbortVaultLockCommand").f(void 0, void 0).ser(se_AbortVaultLockCommand).de(de_AbortVaultLockCommand).build() {
+};
+__name(_AbortVaultLockCommand, "AbortVaultLockCommand");
+var AbortVaultLockCommand = _AbortVaultLockCommand;
+
+// src/commands/AddTagsToVaultCommand.ts
+
+
+
+
+var _AddTagsToVaultCommand = class _AddTagsToVaultCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Glacier", "AddTagsToVault", {}).n("GlacierClient", "AddTagsToVaultCommand").f(void 0, void 0).ser(se_AddTagsToVaultCommand).de(de_AddTagsToVaultCommand).build() {
+};
+__name(_AddTagsToVaultCommand, "AddTagsToVaultCommand");
+var AddTagsToVaultCommand = _AddTagsToVaultCommand;
+
+// src/commands/CompleteMultipartUploadCommand.ts
+
+
+
+
+var _CompleteMultipartUploadCommand = class _CompleteMultipartUploadCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Glacier", "CompleteMultipartUpload", {}).n("GlacierClient", "CompleteMultipartUploadCommand").f(void 0, void 0).ser(se_CompleteMultipartUploadCommand).de(de_CompleteMultipartUploadCommand).build() {
+};
+__name(_CompleteMultipartUploadCommand, "CompleteMultipartUploadCommand");
+var CompleteMultipartUploadCommand = _CompleteMultipartUploadCommand;
+
+// src/commands/CompleteVaultLockCommand.ts
+
+
+
+
+var _CompleteVaultLockCommand = class _CompleteVaultLockCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Glacier", "CompleteVaultLock", {}).n("GlacierClient", "CompleteVaultLockCommand").f(void 0, void 0).ser(se_CompleteVaultLockCommand).de(de_CompleteVaultLockCommand).build() {
+};
+__name(_CompleteVaultLockCommand, "CompleteVaultLockCommand");
+var CompleteVaultLockCommand = _CompleteVaultLockCommand;
+
+// src/commands/CreateVaultCommand.ts
+
+
+
+
+var _CreateVaultCommand = class _CreateVaultCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Glacier", "CreateVault", {}).n("GlacierClient", "CreateVaultCommand").f(void 0, void 0).ser(se_CreateVaultCommand).de(de_CreateVaultCommand).build() {
+};
+__name(_CreateVaultCommand, "CreateVaultCommand");
+var CreateVaultCommand = _CreateVaultCommand;
+
+// src/commands/DeleteArchiveCommand.ts
+
+
+
+
+var _DeleteArchiveCommand = class _DeleteArchiveCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Glacier", "DeleteArchive", {}).n("GlacierClient", "DeleteArchiveCommand").f(void 0, void 0).ser(se_DeleteArchiveCommand).de(de_DeleteArchiveCommand).build() {
+};
+__name(_DeleteArchiveCommand, "DeleteArchiveCommand");
+var DeleteArchiveCommand = _DeleteArchiveCommand;
+
+// src/commands/DeleteVaultAccessPolicyCommand.ts
+
+
+
+
+var _DeleteVaultAccessPolicyCommand = class _DeleteVaultAccessPolicyCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Glacier", "DeleteVaultAccessPolicy", {}).n("GlacierClient", "DeleteVaultAccessPolicyCommand").f(void 0, void 0).ser(se_DeleteVaultAccessPolicyCommand).de(de_DeleteVaultAccessPolicyCommand).build() {
+};
+__name(_DeleteVaultAccessPolicyCommand, "DeleteVaultAccessPolicyCommand");
+var DeleteVaultAccessPolicyCommand = _DeleteVaultAccessPolicyCommand;
+
+// src/commands/DeleteVaultCommand.ts
+
+
+
+
+var _DeleteVaultCommand = class _DeleteVaultCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Glacier", "DeleteVault", {}).n("GlacierClient", "DeleteVaultCommand").f(void 0, void 0).ser(se_DeleteVaultCommand).de(de_DeleteVaultCommand).build() {
+};
+__name(_DeleteVaultCommand, "DeleteVaultCommand");
+var DeleteVaultCommand = _DeleteVaultCommand;
+
+// src/commands/DeleteVaultNotificationsCommand.ts
+
+
+
+
+var _DeleteVaultNotificationsCommand = class _DeleteVaultNotificationsCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Glacier", "DeleteVaultNotifications", {}).n("GlacierClient", "DeleteVaultNotificationsCommand").f(void 0, void 0).ser(se_DeleteVaultNotificationsCommand).de(de_DeleteVaultNotificationsCommand).build() {
+};
+__name(_DeleteVaultNotificationsCommand, "DeleteVaultNotificationsCommand");
+var DeleteVaultNotificationsCommand = _DeleteVaultNotificationsCommand;
+
+// src/commands/DescribeJobCommand.ts
+
+
+
+
+var _DescribeJobCommand = class _DescribeJobCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Glacier", "DescribeJob", {}).n("GlacierClient", "DescribeJobCommand").f(void 0, void 0).ser(se_DescribeJobCommand).de(de_DescribeJobCommand).build() {
+};
+__name(_DescribeJobCommand, "DescribeJobCommand");
+var DescribeJobCommand = _DescribeJobCommand;
+
+// src/commands/DescribeVaultCommand.ts
+
+
+
+
+var _DescribeVaultCommand = class _DescribeVaultCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Glacier", "DescribeVault", {}).n("GlacierClient", "DescribeVaultCommand").f(void 0, void 0).ser(se_DescribeVaultCommand).de(de_DescribeVaultCommand).build() {
+};
+__name(_DescribeVaultCommand, "DescribeVaultCommand");
+var DescribeVaultCommand = _DescribeVaultCommand;
+
+// src/commands/GetDataRetrievalPolicyCommand.ts
+
+
+
+
+var _GetDataRetrievalPolicyCommand = class _GetDataRetrievalPolicyCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Glacier", "GetDataRetrievalPolicy", {}).n("GlacierClient", "GetDataRetrievalPolicyCommand").f(void 0, void 0).ser(se_GetDataRetrievalPolicyCommand).de(de_GetDataRetrievalPolicyCommand).build() {
+};
+__name(_GetDataRetrievalPolicyCommand, "GetDataRetrievalPolicyCommand");
+var GetDataRetrievalPolicyCommand = _GetDataRetrievalPolicyCommand;
+
+// src/commands/GetJobOutputCommand.ts
+
+
+
+
+var _GetJobOutputCommand = class _GetJobOutputCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Glacier", "GetJobOutput", {}).n("GlacierClient", "GetJobOutputCommand").f(void 0, GetJobOutputOutputFilterSensitiveLog).ser(se_GetJobOutputCommand).de(de_GetJobOutputCommand).build() {
+};
+__name(_GetJobOutputCommand, "GetJobOutputCommand");
+var GetJobOutputCommand = _GetJobOutputCommand;
+
+// src/commands/GetVaultAccessPolicyCommand.ts
+
+
+
+
+var _GetVaultAccessPolicyCommand = class _GetVaultAccessPolicyCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Glacier", "GetVaultAccessPolicy", {}).n("GlacierClient", "GetVaultAccessPolicyCommand").f(void 0, void 0).ser(se_GetVaultAccessPolicyCommand).de(de_GetVaultAccessPolicyCommand).build() {
+};
+__name(_GetVaultAccessPolicyCommand, "GetVaultAccessPolicyCommand");
+var GetVaultAccessPolicyCommand = _GetVaultAccessPolicyCommand;
+
+// src/commands/GetVaultLockCommand.ts
+
+
+
+
+var _GetVaultLockCommand = class _GetVaultLockCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Glacier", "GetVaultLock", {}).n("GlacierClient", "GetVaultLockCommand").f(void 0, void 0).ser(se_GetVaultLockCommand).de(de_GetVaultLockCommand).build() {
+};
+__name(_GetVaultLockCommand, "GetVaultLockCommand");
+var GetVaultLockCommand = _GetVaultLockCommand;
+
+// src/commands/GetVaultNotificationsCommand.ts
+
+
+
+
+var _GetVaultNotificationsCommand = class _GetVaultNotificationsCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Glacier", "GetVaultNotifications", {}).n("GlacierClient", "GetVaultNotificationsCommand").f(void 0, void 0).ser(se_GetVaultNotificationsCommand).de(de_GetVaultNotificationsCommand).build() {
+};
+__name(_GetVaultNotificationsCommand, "GetVaultNotificationsCommand");
+var GetVaultNotificationsCommand = _GetVaultNotificationsCommand;
+
+// src/commands/InitiateJobCommand.ts
+
+
+
+
+var _InitiateJobCommand = class _InitiateJobCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Glacier", "InitiateJob", {}).n("GlacierClient", "InitiateJobCommand").f(void 0, void 0).ser(se_InitiateJobCommand).de(de_InitiateJobCommand).build() {
+};
+__name(_InitiateJobCommand, "InitiateJobCommand");
+var InitiateJobCommand = _InitiateJobCommand;
+
+// src/commands/InitiateMultipartUploadCommand.ts
+
+
+
+
+var _InitiateMultipartUploadCommand = class _InitiateMultipartUploadCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Glacier", "InitiateMultipartUpload", {}).n("GlacierClient", "InitiateMultipartUploadCommand").f(void 0, void 0).ser(se_InitiateMultipartUploadCommand).de(de_InitiateMultipartUploadCommand).build() {
+};
+__name(_InitiateMultipartUploadCommand, "InitiateMultipartUploadCommand");
+var InitiateMultipartUploadCommand = _InitiateMultipartUploadCommand;
+
+// src/commands/InitiateVaultLockCommand.ts
+
+
+
+
+var _InitiateVaultLockCommand = class _InitiateVaultLockCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Glacier", "InitiateVaultLock", {}).n("GlacierClient", "InitiateVaultLockCommand").f(void 0, void 0).ser(se_InitiateVaultLockCommand).de(de_InitiateVaultLockCommand).build() {
+};
+__name(_InitiateVaultLockCommand, "InitiateVaultLockCommand");
+var InitiateVaultLockCommand = _InitiateVaultLockCommand;
+
+// src/commands/ListJobsCommand.ts
+
+
+
+
+var _ListJobsCommand = class _ListJobsCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Glacier", "ListJobs", {}).n("GlacierClient", "ListJobsCommand").f(void 0, void 0).ser(se_ListJobsCommand).de(de_ListJobsCommand).build() {
+};
+__name(_ListJobsCommand, "ListJobsCommand");
+var ListJobsCommand = _ListJobsCommand;
+
+// src/commands/ListMultipartUploadsCommand.ts
+
+
+
+
+var _ListMultipartUploadsCommand = class _ListMultipartUploadsCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Glacier", "ListMultipartUploads", {}).n("GlacierClient", "ListMultipartUploadsCommand").f(void 0, void 0).ser(se_ListMultipartUploadsCommand).de(de_ListMultipartUploadsCommand).build() {
+};
+__name(_ListMultipartUploadsCommand, "ListMultipartUploadsCommand");
+var ListMultipartUploadsCommand = _ListMultipartUploadsCommand;
+
+// src/commands/ListPartsCommand.ts
+
+
+
+
+var _ListPartsCommand = class _ListPartsCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Glacier", "ListParts", {}).n("GlacierClient", "ListPartsCommand").f(void 0, void 0).ser(se_ListPartsCommand).de(de_ListPartsCommand).build() {
+};
+__name(_ListPartsCommand, "ListPartsCommand");
+var ListPartsCommand = _ListPartsCommand;
+
+// src/commands/ListProvisionedCapacityCommand.ts
+
+
+
+
+var _ListProvisionedCapacityCommand = class _ListProvisionedCapacityCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Glacier", "ListProvisionedCapacity", {}).n("GlacierClient", "ListProvisionedCapacityCommand").f(void 0, void 0).ser(se_ListProvisionedCapacityCommand).de(de_ListProvisionedCapacityCommand).build() {
+};
+__name(_ListProvisionedCapacityCommand, "ListProvisionedCapacityCommand");
+var ListProvisionedCapacityCommand = _ListProvisionedCapacityCommand;
+
+// src/commands/ListTagsForVaultCommand.ts
+
+
+
+
+var _ListTagsForVaultCommand = class _ListTagsForVaultCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Glacier", "ListTagsForVault", {}).n("GlacierClient", "ListTagsForVaultCommand").f(void 0, void 0).ser(se_ListTagsForVaultCommand).de(de_ListTagsForVaultCommand).build() {
+};
+__name(_ListTagsForVaultCommand, "ListTagsForVaultCommand");
+var ListTagsForVaultCommand = _ListTagsForVaultCommand;
+
+// src/commands/ListVaultsCommand.ts
+
+
+
+
+var _ListVaultsCommand = class _ListVaultsCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Glacier", "ListVaults", {}).n("GlacierClient", "ListVaultsCommand").f(void 0, void 0).ser(se_ListVaultsCommand).de(de_ListVaultsCommand).build() {
+};
+__name(_ListVaultsCommand, "ListVaultsCommand");
+var ListVaultsCommand = _ListVaultsCommand;
+
+// src/commands/PurchaseProvisionedCapacityCommand.ts
+
+
+
+
+var _PurchaseProvisionedCapacityCommand = class _PurchaseProvisionedCapacityCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Glacier", "PurchaseProvisionedCapacity", {}).n("GlacierClient", "PurchaseProvisionedCapacityCommand").f(void 0, void 0).ser(se_PurchaseProvisionedCapacityCommand).de(de_PurchaseProvisionedCapacityCommand).build() {
+};
+__name(_PurchaseProvisionedCapacityCommand, "PurchaseProvisionedCapacityCommand");
+var PurchaseProvisionedCapacityCommand = _PurchaseProvisionedCapacityCommand;
+
+// src/commands/RemoveTagsFromVaultCommand.ts
+
+
+
+
+var _RemoveTagsFromVaultCommand = class _RemoveTagsFromVaultCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Glacier", "RemoveTagsFromVault", {}).n("GlacierClient", "RemoveTagsFromVaultCommand").f(void 0, void 0).ser(se_RemoveTagsFromVaultCommand).de(de_RemoveTagsFromVaultCommand).build() {
+};
+__name(_RemoveTagsFromVaultCommand, "RemoveTagsFromVaultCommand");
+var RemoveTagsFromVaultCommand = _RemoveTagsFromVaultCommand;
+
+// src/commands/SetDataRetrievalPolicyCommand.ts
+
+
+
+
+var _SetDataRetrievalPolicyCommand = class _SetDataRetrievalPolicyCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Glacier", "SetDataRetrievalPolicy", {}).n("GlacierClient", "SetDataRetrievalPolicyCommand").f(void 0, void 0).ser(se_SetDataRetrievalPolicyCommand).de(de_SetDataRetrievalPolicyCommand).build() {
+};
+__name(_SetDataRetrievalPolicyCommand, "SetDataRetrievalPolicyCommand");
+var SetDataRetrievalPolicyCommand = _SetDataRetrievalPolicyCommand;
+
+// src/commands/SetVaultAccessPolicyCommand.ts
+
+
+
+
+var _SetVaultAccessPolicyCommand = class _SetVaultAccessPolicyCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Glacier", "SetVaultAccessPolicy", {}).n("GlacierClient", "SetVaultAccessPolicyCommand").f(void 0, void 0).ser(se_SetVaultAccessPolicyCommand).de(de_SetVaultAccessPolicyCommand).build() {
+};
+__name(_SetVaultAccessPolicyCommand, "SetVaultAccessPolicyCommand");
+var SetVaultAccessPolicyCommand = _SetVaultAccessPolicyCommand;
+
+// src/commands/SetVaultNotificationsCommand.ts
+
+
+
+
+var _SetVaultNotificationsCommand = class _SetVaultNotificationsCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Glacier", "SetVaultNotifications", {}).n("GlacierClient", "SetVaultNotificationsCommand").f(void 0, void 0).ser(se_SetVaultNotificationsCommand).de(de_SetVaultNotificationsCommand).build() {
+};
+__name(_SetVaultNotificationsCommand, "SetVaultNotificationsCommand");
+var SetVaultNotificationsCommand = _SetVaultNotificationsCommand;
+
+// src/commands/UploadArchiveCommand.ts
+
+
+
+
+var _UploadArchiveCommand = class _UploadArchiveCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Glacier", "UploadArchive", {}).n("GlacierClient", "UploadArchiveCommand").f(UploadArchiveInputFilterSensitiveLog, void 0).ser(se_UploadArchiveCommand).de(de_UploadArchiveCommand).build() {
+};
+__name(_UploadArchiveCommand, "UploadArchiveCommand");
+var UploadArchiveCommand = _UploadArchiveCommand;
+
+// src/commands/UploadMultipartPartCommand.ts
+
+
+
+
+var _UploadMultipartPartCommand = class _UploadMultipartPartCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Glacier", "UploadMultipartPart", {}).n("GlacierClient", "UploadMultipartPartCommand").f(UploadMultipartPartInputFilterSensitiveLog, void 0).ser(se_UploadMultipartPartCommand).de(de_UploadMultipartPartCommand).build() {
+};
+__name(_UploadMultipartPartCommand, "UploadMultipartPartCommand");
+var UploadMultipartPartCommand = _UploadMultipartPartCommand;
+
+// src/Glacier.ts
+var commands = {
+  AbortMultipartUploadCommand,
+  AbortVaultLockCommand,
+  AddTagsToVaultCommand,
+  CompleteMultipartUploadCommand,
+  CompleteVaultLockCommand,
+  CreateVaultCommand,
+  DeleteArchiveCommand,
+  DeleteVaultCommand,
+  DeleteVaultAccessPolicyCommand,
+  DeleteVaultNotificationsCommand,
+  DescribeJobCommand,
+  DescribeVaultCommand,
+  GetDataRetrievalPolicyCommand,
+  GetJobOutputCommand,
+  GetVaultAccessPolicyCommand,
+  GetVaultLockCommand,
+  GetVaultNotificationsCommand,
+  InitiateJobCommand,
+  InitiateMultipartUploadCommand,
+  InitiateVaultLockCommand,
+  ListJobsCommand,
+  ListMultipartUploadsCommand,
+  ListPartsCommand,
+  ListProvisionedCapacityCommand,
+  ListTagsForVaultCommand,
+  ListVaultsCommand,
+  PurchaseProvisionedCapacityCommand,
+  RemoveTagsFromVaultCommand,
+  SetDataRetrievalPolicyCommand,
+  SetVaultAccessPolicyCommand,
+  SetVaultNotificationsCommand,
+  UploadArchiveCommand,
+  UploadMultipartPartCommand
+};
+var _Glacier = class _Glacier extends GlacierClient {
+};
+__name(_Glacier, "Glacier");
+var Glacier = _Glacier;
+(0, import_smithy_client.createAggregatedClient)(commands, Glacier);
+
+// src/pagination/ListJobsPaginator.ts
+
+var paginateListJobs = (0, import_core.createPaginator)(GlacierClient, ListJobsCommand, "marker", "Marker", "limit");
+
+// src/pagination/ListMultipartUploadsPaginator.ts
+
+var paginateListMultipartUploads = (0, import_core.createPaginator)(GlacierClient, ListMultipartUploadsCommand, "marker", "Marker", "limit");
+
+// src/pagination/ListPartsPaginator.ts
+
+var paginateListParts = (0, import_core.createPaginator)(GlacierClient, ListPartsCommand, "marker", "Marker", "limit");
+
+// src/pagination/ListVaultsPaginator.ts
+
+var paginateListVaults = (0, import_core.createPaginator)(GlacierClient, ListVaultsCommand, "marker", "Marker", "limit");
+
+// src/waiters/waitForVaultExists.ts
+var import_util_waiter = require("@smithy/util-waiter");
+var checkState = /* @__PURE__ */ __name(async (client, input) => {
+  let reason;
+  try {
+    const result = await client.send(new DescribeVaultCommand(input));
+    reason = result;
+    return { state: import_util_waiter.WaiterState.SUCCESS, reason };
+  } catch (exception) {
+    reason = exception;
+    if (exception.name && exception.name == "ResourceNotFoundException") {
+      return { state: import_util_waiter.WaiterState.RETRY, reason };
+    }
+  }
+  return { state: import_util_waiter.WaiterState.RETRY, reason };
+}, "checkState");
+var waitForVaultExists = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 3, maxDelay: 120 };
+  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState);
+}, "waitForVaultExists");
+var waitUntilVaultExists = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 3, maxDelay: 120 };
+  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState);
+  return (0, import_util_waiter.checkExceptions)(result);
+}, "waitUntilVaultExists");
+
+// src/waiters/waitForVaultNotExists.ts
+
+var checkState2 = /* @__PURE__ */ __name(async (client, input) => {
+  let reason;
+  try {
+    const result = await client.send(new DescribeVaultCommand(input));
+    reason = result;
+    return { state: import_util_waiter.WaiterState.RETRY, reason };
+  } catch (exception) {
+    reason = exception;
+    if (exception.name && exception.name == "ResourceNotFoundException") {
+      return { state: import_util_waiter.WaiterState.SUCCESS, reason };
+    }
+  }
+  return { state: import_util_waiter.WaiterState.RETRY, reason };
+}, "checkState");
+var waitForVaultNotExists = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 3, maxDelay: 120 };
+  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState2);
+}, "waitForVaultNotExists");
+var waitUntilVaultNotExists = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 3, maxDelay: 120 };
+  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState2);
+  return (0, import_util_waiter.checkExceptions)(result);
+}, "waitUntilVaultNotExists");
+
+// src/index.ts
+var import_util_endpoints = require("@aws-sdk/util-endpoints");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AbortMultipartUploadCommand,
+  AbortVaultLockCommand,
+  ActionCode,
+  AddTagsToVaultCommand,
+  CannedACL,
+  CompleteMultipartUploadCommand,
+  CompleteVaultLockCommand,
+  CreateVaultCommand,
+  DeleteArchiveCommand,
+  DeleteVaultAccessPolicyCommand,
+  DeleteVaultCommand,
+  DeleteVaultNotificationsCommand,
+  DescribeJobCommand,
+  DescribeVaultCommand,
+  EncryptionType,
+  ExpressionType,
+  FileHeaderInfo,
+  GetDataRetrievalPolicyCommand,
+  GetJobOutputCommand,
+  GetJobOutputOutputFilterSensitiveLog,
+  GetVaultAccessPolicyCommand,
+  GetVaultLockCommand,
+  GetVaultNotificationsCommand,
+  Glacier,
+  GlacierClient,
+  GlacierServiceException,
+  InitiateJobCommand,
+  InitiateMultipartUploadCommand,
+  InitiateVaultLockCommand,
+  InsufficientCapacityException,
+  InvalidParameterValueException,
+  LimitExceededException,
+  ListJobsCommand,
+  ListMultipartUploadsCommand,
+  ListPartsCommand,
+  ListProvisionedCapacityCommand,
+  ListTagsForVaultCommand,
+  ListVaultsCommand,
+  MissingParameterValueException,
+  Permission,
+  PolicyEnforcedException,
+  PurchaseProvisionedCapacityCommand,
+  QuoteFields,
+  RemoveTagsFromVaultCommand,
+  RequestTimeoutException,
+  ResourceNotFoundException,
+  ServiceUnavailableException,
+  SetDataRetrievalPolicyCommand,
+  SetVaultAccessPolicyCommand,
+  SetVaultNotificationsCommand,
+  StatusCode,
+  StorageClass,
+  Type,
+  UploadArchiveCommand,
+  UploadArchiveInputFilterSensitiveLog,
+  UploadMultipartPartCommand,
+  UploadMultipartPartInputFilterSensitiveLog,
+  __Client,
+  paginateListJobs,
+  paginateListMultipartUploads,
+  paginateListParts,
+  paginateListVaults,
+  waitForVaultExists,
+  waitForVaultNotExists,
+  waitUntilVaultExists,
+  waitUntilVaultNotExists
+});