@aws-sdk/client-shield 3.490.0 → 3.495.0

package/dist-cjs/index.js

@@ -1,12 +1,3268 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ShieldServiceException = void 0;
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./ShieldClient"), exports);
-tslib_1.__exportStar(require("./Shield"), exports);
-tslib_1.__exportStar(require("./commands"), exports);
-tslib_1.__exportStar(require("./pagination"), exports);
-tslib_1.__exportStar(require("./models"), exports);
-require("@aws-sdk/util-endpoints");
-var ShieldServiceException_1 = require("./models/ShieldServiceException");
-Object.defineProperty(exports, "ShieldServiceException", { enumerable: true, get: function () { return ShieldServiceException_1.ShieldServiceException; } });
+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, {
+  AccessDeniedException: () => AccessDeniedException,
+  AccessDeniedForDependencyException: () => AccessDeniedForDependencyException,
+  ApplicationLayerAutomaticResponseStatus: () => ApplicationLayerAutomaticResponseStatus,
+  AssociateDRTLogBucketCommand: () => AssociateDRTLogBucketCommand,
+  AssociateDRTRoleCommand: () => AssociateDRTRoleCommand,
+  AssociateHealthCheckCommand: () => AssociateHealthCheckCommand,
+  AssociateProactiveEngagementDetailsCommand: () => AssociateProactiveEngagementDetailsCommand,
+  AttackLayer: () => AttackLayer,
+  AttackPropertyIdentifier: () => AttackPropertyIdentifier,
+  AutoRenew: () => AutoRenew,
+  CreateProtectionCommand: () => CreateProtectionCommand,
+  CreateProtectionGroupCommand: () => CreateProtectionGroupCommand,
+  CreateSubscriptionCommand: () => CreateSubscriptionCommand,
+  DeleteProtectionCommand: () => DeleteProtectionCommand,
+  DeleteProtectionGroupCommand: () => DeleteProtectionGroupCommand,
+  DeleteSubscriptionCommand: () => DeleteSubscriptionCommand,
+  DescribeAttackCommand: () => DescribeAttackCommand,
+  DescribeAttackStatisticsCommand: () => DescribeAttackStatisticsCommand,
+  DescribeDRTAccessCommand: () => DescribeDRTAccessCommand,
+  DescribeEmergencyContactSettingsCommand: () => DescribeEmergencyContactSettingsCommand,
+  DescribeProtectionCommand: () => DescribeProtectionCommand,
+  DescribeProtectionGroupCommand: () => DescribeProtectionGroupCommand,
+  DescribeSubscriptionCommand: () => DescribeSubscriptionCommand,
+  DisableApplicationLayerAutomaticResponseCommand: () => DisableApplicationLayerAutomaticResponseCommand,
+  DisableProactiveEngagementCommand: () => DisableProactiveEngagementCommand,
+  DisassociateDRTLogBucketCommand: () => DisassociateDRTLogBucketCommand,
+  DisassociateDRTRoleCommand: () => DisassociateDRTRoleCommand,
+  DisassociateHealthCheckCommand: () => DisassociateHealthCheckCommand,
+  EnableApplicationLayerAutomaticResponseCommand: () => EnableApplicationLayerAutomaticResponseCommand,
+  EnableProactiveEngagementCommand: () => EnableProactiveEngagementCommand,
+  GetSubscriptionStateCommand: () => GetSubscriptionStateCommand,
+  InternalErrorException: () => InternalErrorException,
+  InvalidOperationException: () => InvalidOperationException,
+  InvalidPaginationTokenException: () => InvalidPaginationTokenException,
+  InvalidParameterException: () => InvalidParameterException,
+  InvalidResourceException: () => InvalidResourceException,
+  LimitsExceededException: () => LimitsExceededException,
+  ListAttacksCommand: () => ListAttacksCommand,
+  ListProtectionGroupsCommand: () => ListProtectionGroupsCommand,
+  ListProtectionsCommand: () => ListProtectionsCommand,
+  ListResourcesInProtectionGroupCommand: () => ListResourcesInProtectionGroupCommand,
+  ListTagsForResourceCommand: () => ListTagsForResourceCommand,
+  LockedSubscriptionException: () => LockedSubscriptionException,
+  NoAssociatedRoleException: () => NoAssociatedRoleException,
+  OptimisticLockException: () => OptimisticLockException,
+  ProactiveEngagementStatus: () => ProactiveEngagementStatus,
+  ProtectedResourceType: () => ProtectedResourceType,
+  ProtectionGroupAggregation: () => ProtectionGroupAggregation,
+  ProtectionGroupPattern: () => ProtectionGroupPattern,
+  ResourceAlreadyExistsException: () => ResourceAlreadyExistsException,
+  ResourceNotFoundException: () => ResourceNotFoundException,
+  Shield: () => Shield,
+  ShieldClient: () => ShieldClient,
+  ShieldServiceException: () => ShieldServiceException,
+  SubResourceType: () => SubResourceType,
+  SubscriptionState: () => SubscriptionState,
+  TagResourceCommand: () => TagResourceCommand,
+  Unit: () => Unit,
+  UntagResourceCommand: () => UntagResourceCommand,
+  UpdateApplicationLayerAutomaticResponseCommand: () => UpdateApplicationLayerAutomaticResponseCommand,
+  UpdateEmergencyContactSettingsCommand: () => UpdateEmergencyContactSettingsCommand,
+  UpdateProtectionGroupCommand: () => UpdateProtectionGroupCommand,
+  UpdateSubscriptionCommand: () => UpdateSubscriptionCommand,
+  ValidationExceptionReason: () => ValidationExceptionReason,
+  __Client: () => import_smithy_client.Client,
+  paginateListAttacks: () => paginateListAttacks,
+  paginateListProtectionGroups: () => paginateListProtectionGroups,
+  paginateListProtections: () => paginateListProtections,
+  paginateListResourcesInProtectionGroup: () => paginateListResourcesInProtectionGroup
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/ShieldClient.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_signing = require("@aws-sdk/middleware-signing");
+var import_middleware_user_agent = require("@aws-sdk/middleware-user-agent");
+var import_config_resolver = require("@smithy/config-resolver");
+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");
+
+
+// src/endpoint/EndpointParameters.ts
+var resolveClientEndpointParameters = /* @__PURE__ */ __name((options) => {
+  return {
+    ...options,
+    useDualstackEndpoint: options.useDualstackEndpoint ?? false,
+    useFipsEndpoint: options.useFipsEndpoint ?? false,
+    defaultSigningName: "shield"
+  };
+}, "resolveClientEndpointParameters");
+var commonParams = {
+  UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+  Endpoint: { type: "builtInParams", name: "endpoint" },
+  Region: { type: "builtInParams", name: "region" },
+  UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
+};
+
+// src/ShieldClient.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");
+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))
+  };
+  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)
+  };
+}, "resolveRuntimeExtensions");
+
+// src/ShieldClient.ts
+var _ShieldClient = class _ShieldClient 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_signing.resolveAwsAuthConfig)(_config_5);
+    const _config_7 = (0, import_middleware_user_agent.resolveUserAgentConfig)(_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_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_signing.getAwsAuthPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_user_agent.getUserAgentPlugin)(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();
+  }
+};
+__name(_ShieldClient, "ShieldClient");
+var ShieldClient = _ShieldClient;
+
+// src/Shield.ts
+
+
+// src/commands/AssociateDRTLogBucketCommand.ts
+
+var import_middleware_serde = require("@smithy/middleware-serde");
+
+var import_types = require("@smithy/types");
+
+// src/protocols/Aws_json1_1.ts
+
+
+
+// src/models/ShieldServiceException.ts
+
+var _ShieldServiceException = class _ShieldServiceException extends import_smithy_client.ServiceException {
+  /**
+   * @internal
+   */
+  constructor(options) {
+    super(options);
+    Object.setPrototypeOf(this, _ShieldServiceException.prototype);
+  }
+};
+__name(_ShieldServiceException, "ShieldServiceException");
+var ShieldServiceException = _ShieldServiceException;
+
+// src/models/models_0.ts
+var _AccessDeniedException = class _AccessDeniedException extends ShieldServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "AccessDeniedException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "AccessDeniedException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _AccessDeniedException.prototype);
+  }
+};
+__name(_AccessDeniedException, "AccessDeniedException");
+var AccessDeniedException = _AccessDeniedException;
+var _AccessDeniedForDependencyException = class _AccessDeniedForDependencyException extends ShieldServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "AccessDeniedForDependencyException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "AccessDeniedForDependencyException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _AccessDeniedForDependencyException.prototype);
+  }
+};
+__name(_AccessDeniedForDependencyException, "AccessDeniedForDependencyException");
+var AccessDeniedForDependencyException = _AccessDeniedForDependencyException;
+var ApplicationLayerAutomaticResponseStatus = {
+  DISABLED: "DISABLED",
+  ENABLED: "ENABLED"
+};
+var _InternalErrorException = class _InternalErrorException extends ShieldServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InternalErrorException",
+      $fault: "server",
+      ...opts
+    });
+    this.name = "InternalErrorException";
+    this.$fault = "server";
+    Object.setPrototypeOf(this, _InternalErrorException.prototype);
+  }
+};
+__name(_InternalErrorException, "InternalErrorException");
+var InternalErrorException = _InternalErrorException;
+var _InvalidOperationException = class _InvalidOperationException extends ShieldServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InvalidOperationException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "InvalidOperationException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _InvalidOperationException.prototype);
+  }
+};
+__name(_InvalidOperationException, "InvalidOperationException");
+var InvalidOperationException = _InvalidOperationException;
+var ValidationExceptionReason = {
+  FIELD_VALIDATION_FAILED: "FIELD_VALIDATION_FAILED",
+  OTHER: "OTHER"
+};
+var _InvalidParameterException = class _InvalidParameterException extends ShieldServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InvalidParameterException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "InvalidParameterException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _InvalidParameterException.prototype);
+    this.reason = opts.reason;
+    this.fields = opts.fields;
+  }
+};
+__name(_InvalidParameterException, "InvalidParameterException");
+var InvalidParameterException = _InvalidParameterException;
+var _LimitsExceededException = class _LimitsExceededException extends ShieldServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "LimitsExceededException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "LimitsExceededException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _LimitsExceededException.prototype);
+    this.Type = opts.Type;
+    this.Limit = opts.Limit;
+  }
+};
+__name(_LimitsExceededException, "LimitsExceededException");
+var LimitsExceededException = _LimitsExceededException;
+var _NoAssociatedRoleException = class _NoAssociatedRoleException extends ShieldServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "NoAssociatedRoleException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "NoAssociatedRoleException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _NoAssociatedRoleException.prototype);
+  }
+};
+__name(_NoAssociatedRoleException, "NoAssociatedRoleException");
+var NoAssociatedRoleException = _NoAssociatedRoleException;
+var _OptimisticLockException = class _OptimisticLockException extends ShieldServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "OptimisticLockException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "OptimisticLockException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _OptimisticLockException.prototype);
+  }
+};
+__name(_OptimisticLockException, "OptimisticLockException");
+var OptimisticLockException = _OptimisticLockException;
+var _ResourceNotFoundException = class _ResourceNotFoundException extends ShieldServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ResourceNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ResourceNotFoundException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ResourceNotFoundException.prototype);
+    this.resourceType = opts.resourceType;
+  }
+};
+__name(_ResourceNotFoundException, "ResourceNotFoundException");
+var ResourceNotFoundException = _ResourceNotFoundException;
+var _InvalidResourceException = class _InvalidResourceException extends ShieldServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InvalidResourceException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "InvalidResourceException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _InvalidResourceException.prototype);
+  }
+};
+__name(_InvalidResourceException, "InvalidResourceException");
+var InvalidResourceException = _InvalidResourceException;
+var AttackLayer = {
+  APPLICATION: "APPLICATION",
+  NETWORK: "NETWORK"
+};
+var AttackPropertyIdentifier = {
+  DESTINATION_URL: "DESTINATION_URL",
+  REFERRER: "REFERRER",
+  SOURCE_ASN: "SOURCE_ASN",
+  SOURCE_COUNTRY: "SOURCE_COUNTRY",
+  SOURCE_IP_ADDRESS: "SOURCE_IP_ADDRESS",
+  SOURCE_USER_AGENT: "SOURCE_USER_AGENT",
+  WORDPRESS_PINGBACK_REFLECTOR: "WORDPRESS_PINGBACK_REFLECTOR",
+  WORDPRESS_PINGBACK_SOURCE: "WORDPRESS_PINGBACK_SOURCE"
+};
+var Unit = {
+  BITS: "BITS",
+  BYTES: "BYTES",
+  PACKETS: "PACKETS",
+  REQUESTS: "REQUESTS"
+};
+var SubResourceType = {
+  IP: "IP",
+  URL: "URL"
+};
+var AutoRenew = {
+  DISABLED: "DISABLED",
+  ENABLED: "ENABLED"
+};
+var _ResourceAlreadyExistsException = class _ResourceAlreadyExistsException extends ShieldServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ResourceAlreadyExistsException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ResourceAlreadyExistsException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ResourceAlreadyExistsException.prototype);
+    this.resourceType = opts.resourceType;
+  }
+};
+__name(_ResourceAlreadyExistsException, "ResourceAlreadyExistsException");
+var ResourceAlreadyExistsException = _ResourceAlreadyExistsException;
+var ProtectionGroupAggregation = {
+  MAX: "MAX",
+  MEAN: "MEAN",
+  SUM: "SUM"
+};
+var ProtectionGroupPattern = {
+  ALL: "ALL",
+  ARBITRARY: "ARBITRARY",
+  BY_RESOURCE_TYPE: "BY_RESOURCE_TYPE"
+};
+var ProtectedResourceType = {
+  APPLICATION_LOAD_BALANCER: "APPLICATION_LOAD_BALANCER",
+  CLASSIC_LOAD_BALANCER: "CLASSIC_LOAD_BALANCER",
+  CLOUDFRONT_DISTRIBUTION: "CLOUDFRONT_DISTRIBUTION",
+  ELASTIC_IP_ALLOCATION: "ELASTIC_IP_ALLOCATION",
+  GLOBAL_ACCELERATOR: "GLOBAL_ACCELERATOR",
+  ROUTE_53_HOSTED_ZONE: "ROUTE_53_HOSTED_ZONE"
+};
+var _LockedSubscriptionException = class _LockedSubscriptionException extends ShieldServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "LockedSubscriptionException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "LockedSubscriptionException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _LockedSubscriptionException.prototype);
+  }
+};
+__name(_LockedSubscriptionException, "LockedSubscriptionException");
+var LockedSubscriptionException = _LockedSubscriptionException;
+var ProactiveEngagementStatus = {
+  DISABLED: "DISABLED",
+  ENABLED: "ENABLED",
+  PENDING: "PENDING"
+};
+var SubscriptionState = {
+  ACTIVE: "ACTIVE",
+  INACTIVE: "INACTIVE"
+};
+var _InvalidPaginationTokenException = class _InvalidPaginationTokenException extends ShieldServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InvalidPaginationTokenException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "InvalidPaginationTokenException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _InvalidPaginationTokenException.prototype);
+  }
+};
+__name(_InvalidPaginationTokenException, "InvalidPaginationTokenException");
+var InvalidPaginationTokenException = _InvalidPaginationTokenException;
+
+// src/protocols/Aws_json1_1.ts
+var se_AssociateDRTLogBucketCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("AssociateDRTLogBucket");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_AssociateDRTLogBucketCommand");
+var se_AssociateDRTRoleCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("AssociateDRTRole");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_AssociateDRTRoleCommand");
+var se_AssociateHealthCheckCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("AssociateHealthCheck");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_AssociateHealthCheckCommand");
+var se_AssociateProactiveEngagementDetailsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("AssociateProactiveEngagementDetails");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_AssociateProactiveEngagementDetailsCommand");
+var se_CreateProtectionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CreateProtection");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreateProtectionCommand");
+var se_CreateProtectionGroupCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CreateProtectionGroup");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreateProtectionGroupCommand");
+var se_CreateSubscriptionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CreateSubscription");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreateSubscriptionCommand");
+var se_DeleteProtectionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeleteProtection");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteProtectionCommand");
+var se_DeleteProtectionGroupCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeleteProtectionGroup");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteProtectionGroupCommand");
+var se_DeleteSubscriptionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeleteSubscription");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteSubscriptionCommand");
+var se_DescribeAttackCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeAttack");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeAttackCommand");
+var se_DescribeAttackStatisticsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeAttackStatistics");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeAttackStatisticsCommand");
+var se_DescribeDRTAccessCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeDRTAccess");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeDRTAccessCommand");
+var se_DescribeEmergencyContactSettingsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeEmergencyContactSettings");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeEmergencyContactSettingsCommand");
+var se_DescribeProtectionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeProtection");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeProtectionCommand");
+var se_DescribeProtectionGroupCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeProtectionGroup");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeProtectionGroupCommand");
+var se_DescribeSubscriptionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeSubscription");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeSubscriptionCommand");
+var se_DisableApplicationLayerAutomaticResponseCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DisableApplicationLayerAutomaticResponse");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DisableApplicationLayerAutomaticResponseCommand");
+var se_DisableProactiveEngagementCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DisableProactiveEngagement");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DisableProactiveEngagementCommand");
+var se_DisassociateDRTLogBucketCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DisassociateDRTLogBucket");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DisassociateDRTLogBucketCommand");
+var se_DisassociateDRTRoleCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DisassociateDRTRole");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DisassociateDRTRoleCommand");
+var se_DisassociateHealthCheckCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DisassociateHealthCheck");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DisassociateHealthCheckCommand");
+var se_EnableApplicationLayerAutomaticResponseCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("EnableApplicationLayerAutomaticResponse");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_EnableApplicationLayerAutomaticResponseCommand");
+var se_EnableProactiveEngagementCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("EnableProactiveEngagement");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_EnableProactiveEngagementCommand");
+var se_GetSubscriptionStateCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetSubscriptionState");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetSubscriptionStateCommand");
+var se_ListAttacksCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListAttacks");
+  let body;
+  body = JSON.stringify(se_ListAttacksRequest(input, context));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListAttacksCommand");
+var se_ListProtectionGroupsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListProtectionGroups");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListProtectionGroupsCommand");
+var se_ListProtectionsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListProtections");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListProtectionsCommand");
+var se_ListResourcesInProtectionGroupCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListResourcesInProtectionGroup");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListResourcesInProtectionGroupCommand");
+var se_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListTagsForResource");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListTagsForResourceCommand");
+var se_TagResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("TagResource");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_TagResourceCommand");
+var se_UntagResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UntagResource");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UntagResourceCommand");
+var se_UpdateApplicationLayerAutomaticResponseCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UpdateApplicationLayerAutomaticResponse");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UpdateApplicationLayerAutomaticResponseCommand");
+var se_UpdateEmergencyContactSettingsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UpdateEmergencyContactSettings");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UpdateEmergencyContactSettingsCommand");
+var se_UpdateProtectionGroupCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UpdateProtectionGroup");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UpdateProtectionGroupCommand");
+var se_UpdateSubscriptionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UpdateSubscription");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UpdateSubscriptionCommand");
+var de_AssociateDRTLogBucketCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_AssociateDRTLogBucketCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_AssociateDRTLogBucketCommand");
+var de_AssociateDRTLogBucketCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedForDependencyException":
+    case "com.amazonaws.shield#AccessDeniedForDependencyException":
+      throw await de_AccessDeniedForDependencyExceptionRes(parsedOutput, context);
+    case "InternalErrorException":
+    case "com.amazonaws.shield#InternalErrorException":
+      throw await de_InternalErrorExceptionRes(parsedOutput, context);
+    case "InvalidOperationException":
+    case "com.amazonaws.shield#InvalidOperationException":
+      throw await de_InvalidOperationExceptionRes(parsedOutput, context);
+    case "InvalidParameterException":
+    case "com.amazonaws.shield#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "LimitsExceededException":
+    case "com.amazonaws.shield#LimitsExceededException":
+      throw await de_LimitsExceededExceptionRes(parsedOutput, context);
+    case "NoAssociatedRoleException":
+    case "com.amazonaws.shield#NoAssociatedRoleException":
+      throw await de_NoAssociatedRoleExceptionRes(parsedOutput, context);
+    case "OptimisticLockException":
+    case "com.amazonaws.shield#OptimisticLockException":
+      throw await de_OptimisticLockExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.shield#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_AssociateDRTLogBucketCommandError");
+var de_AssociateDRTRoleCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_AssociateDRTRoleCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_AssociateDRTRoleCommand");
+var de_AssociateDRTRoleCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedForDependencyException":
+    case "com.amazonaws.shield#AccessDeniedForDependencyException":
+      throw await de_AccessDeniedForDependencyExceptionRes(parsedOutput, context);
+    case "InternalErrorException":
+    case "com.amazonaws.shield#InternalErrorException":
+      throw await de_InternalErrorExceptionRes(parsedOutput, context);
+    case "InvalidOperationException":
+    case "com.amazonaws.shield#InvalidOperationException":
+      throw await de_InvalidOperationExceptionRes(parsedOutput, context);
+    case "InvalidParameterException":
+    case "com.amazonaws.shield#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "OptimisticLockException":
+    case "com.amazonaws.shield#OptimisticLockException":
+      throw await de_OptimisticLockExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.shield#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_AssociateDRTRoleCommandError");
+var de_AssociateHealthCheckCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_AssociateHealthCheckCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_AssociateHealthCheckCommand");
+var de_AssociateHealthCheckCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalErrorException":
+    case "com.amazonaws.shield#InternalErrorException":
+      throw await de_InternalErrorExceptionRes(parsedOutput, context);
+    case "InvalidParameterException":
+    case "com.amazonaws.shield#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "InvalidResourceException":
+    case "com.amazonaws.shield#InvalidResourceException":
+      throw await de_InvalidResourceExceptionRes(parsedOutput, context);
+    case "LimitsExceededException":
+    case "com.amazonaws.shield#LimitsExceededException":
+      throw await de_LimitsExceededExceptionRes(parsedOutput, context);
+    case "OptimisticLockException":
+    case "com.amazonaws.shield#OptimisticLockException":
+      throw await de_OptimisticLockExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.shield#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_AssociateHealthCheckCommandError");
+var de_AssociateProactiveEngagementDetailsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_AssociateProactiveEngagementDetailsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_AssociateProactiveEngagementDetailsCommand");
+var de_AssociateProactiveEngagementDetailsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalErrorException":
+    case "com.amazonaws.shield#InternalErrorException":
+      throw await de_InternalErrorExceptionRes(parsedOutput, context);
+    case "InvalidOperationException":
+    case "com.amazonaws.shield#InvalidOperationException":
+      throw await de_InvalidOperationExceptionRes(parsedOutput, context);
+    case "InvalidParameterException":
+    case "com.amazonaws.shield#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "OptimisticLockException":
+    case "com.amazonaws.shield#OptimisticLockException":
+      throw await de_OptimisticLockExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.shield#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_AssociateProactiveEngagementDetailsCommandError");
+var de_CreateProtectionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreateProtectionCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CreateProtectionCommand");
+var de_CreateProtectionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalErrorException":
+    case "com.amazonaws.shield#InternalErrorException":
+      throw await de_InternalErrorExceptionRes(parsedOutput, context);
+    case "InvalidOperationException":
+    case "com.amazonaws.shield#InvalidOperationException":
+      throw await de_InvalidOperationExceptionRes(parsedOutput, context);
+    case "InvalidParameterException":
+    case "com.amazonaws.shield#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "InvalidResourceException":
+    case "com.amazonaws.shield#InvalidResourceException":
+      throw await de_InvalidResourceExceptionRes(parsedOutput, context);
+    case "LimitsExceededException":
+    case "com.amazonaws.shield#LimitsExceededException":
+      throw await de_LimitsExceededExceptionRes(parsedOutput, context);
+    case "OptimisticLockException":
+    case "com.amazonaws.shield#OptimisticLockException":
+      throw await de_OptimisticLockExceptionRes(parsedOutput, context);
+    case "ResourceAlreadyExistsException":
+    case "com.amazonaws.shield#ResourceAlreadyExistsException":
+      throw await de_ResourceAlreadyExistsExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.shield#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateProtectionCommandError");
+var de_CreateProtectionGroupCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreateProtectionGroupCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CreateProtectionGroupCommand");
+var de_CreateProtectionGroupCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalErrorException":
+    case "com.amazonaws.shield#InternalErrorException":
+      throw await de_InternalErrorExceptionRes(parsedOutput, context);
+    case "InvalidParameterException":
+    case "com.amazonaws.shield#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "LimitsExceededException":
+    case "com.amazonaws.shield#LimitsExceededException":
+      throw await de_LimitsExceededExceptionRes(parsedOutput, context);
+    case "OptimisticLockException":
+    case "com.amazonaws.shield#OptimisticLockException":
+      throw await de_OptimisticLockExceptionRes(parsedOutput, context);
+    case "ResourceAlreadyExistsException":
+    case "com.amazonaws.shield#ResourceAlreadyExistsException":
+      throw await de_ResourceAlreadyExistsExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.shield#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateProtectionGroupCommandError");
+var de_CreateSubscriptionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreateSubscriptionCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CreateSubscriptionCommand");
+var de_CreateSubscriptionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalErrorException":
+    case "com.amazonaws.shield#InternalErrorException":
+      throw await de_InternalErrorExceptionRes(parsedOutput, context);
+    case "ResourceAlreadyExistsException":
+    case "com.amazonaws.shield#ResourceAlreadyExistsException":
+      throw await de_ResourceAlreadyExistsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateSubscriptionCommandError");
+var de_DeleteProtectionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteProtectionCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DeleteProtectionCommand");
+var de_DeleteProtectionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalErrorException":
+    case "com.amazonaws.shield#InternalErrorException":
+      throw await de_InternalErrorExceptionRes(parsedOutput, context);
+    case "OptimisticLockException":
+    case "com.amazonaws.shield#OptimisticLockException":
+      throw await de_OptimisticLockExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.shield#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteProtectionCommandError");
+var de_DeleteProtectionGroupCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteProtectionGroupCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DeleteProtectionGroupCommand");
+var de_DeleteProtectionGroupCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalErrorException":
+    case "com.amazonaws.shield#InternalErrorException":
+      throw await de_InternalErrorExceptionRes(parsedOutput, context);
+    case "OptimisticLockException":
+    case "com.amazonaws.shield#OptimisticLockException":
+      throw await de_OptimisticLockExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.shield#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteProtectionGroupCommandError");
+var de_DeleteSubscriptionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteSubscriptionCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DeleteSubscriptionCommand");
+var de_DeleteSubscriptionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalErrorException":
+    case "com.amazonaws.shield#InternalErrorException":
+      throw await de_InternalErrorExceptionRes(parsedOutput, context);
+    case "LockedSubscriptionException":
+    case "com.amazonaws.shield#LockedSubscriptionException":
+      throw await de_LockedSubscriptionExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.shield#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteSubscriptionCommandError");
+var de_DescribeAttackCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeAttackCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DescribeAttackResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeAttackCommand");
+var de_DescribeAttackCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.shield#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalErrorException":
+    case "com.amazonaws.shield#InternalErrorException":
+      throw await de_InternalErrorExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeAttackCommandError");
+var de_DescribeAttackStatisticsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeAttackStatisticsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DescribeAttackStatisticsResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeAttackStatisticsCommand");
+var de_DescribeAttackStatisticsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalErrorException":
+    case "com.amazonaws.shield#InternalErrorException":
+      throw await de_InternalErrorExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeAttackStatisticsCommandError");
+var de_DescribeDRTAccessCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeDRTAccessCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeDRTAccessCommand");
+var de_DescribeDRTAccessCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalErrorException":
+    case "com.amazonaws.shield#InternalErrorException":
+      throw await de_InternalErrorExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.shield#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeDRTAccessCommandError");
+var de_DescribeEmergencyContactSettingsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeEmergencyContactSettingsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeEmergencyContactSettingsCommand");
+var de_DescribeEmergencyContactSettingsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalErrorException":
+    case "com.amazonaws.shield#InternalErrorException":
+      throw await de_InternalErrorExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.shield#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeEmergencyContactSettingsCommandError");
+var de_DescribeProtectionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeProtectionCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeProtectionCommand");
+var de_DescribeProtectionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalErrorException":
+    case "com.amazonaws.shield#InternalErrorException":
+      throw await de_InternalErrorExceptionRes(parsedOutput, context);
+    case "InvalidParameterException":
+    case "com.amazonaws.shield#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.shield#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeProtectionCommandError");
+var de_DescribeProtectionGroupCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeProtectionGroupCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeProtectionGroupCommand");
+var de_DescribeProtectionGroupCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalErrorException":
+    case "com.amazonaws.shield#InternalErrorException":
+      throw await de_InternalErrorExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.shield#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeProtectionGroupCommandError");
+var de_DescribeSubscriptionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeSubscriptionCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DescribeSubscriptionResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeSubscriptionCommand");
+var de_DescribeSubscriptionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalErrorException":
+    case "com.amazonaws.shield#InternalErrorException":
+      throw await de_InternalErrorExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.shield#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeSubscriptionCommandError");
+var de_DisableApplicationLayerAutomaticResponseCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DisableApplicationLayerAutomaticResponseCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DisableApplicationLayerAutomaticResponseCommand");
+var de_DisableApplicationLayerAutomaticResponseCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalErrorException":
+    case "com.amazonaws.shield#InternalErrorException":
+      throw await de_InternalErrorExceptionRes(parsedOutput, context);
+    case "InvalidOperationException":
+    case "com.amazonaws.shield#InvalidOperationException":
+      throw await de_InvalidOperationExceptionRes(parsedOutput, context);
+    case "InvalidParameterException":
+    case "com.amazonaws.shield#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "OptimisticLockException":
+    case "com.amazonaws.shield#OptimisticLockException":
+      throw await de_OptimisticLockExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.shield#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DisableApplicationLayerAutomaticResponseCommandError");
+var de_DisableProactiveEngagementCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DisableProactiveEngagementCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DisableProactiveEngagementCommand");
+var de_DisableProactiveEngagementCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalErrorException":
+    case "com.amazonaws.shield#InternalErrorException":
+      throw await de_InternalErrorExceptionRes(parsedOutput, context);
+    case "InvalidOperationException":
+    case "com.amazonaws.shield#InvalidOperationException":
+      throw await de_InvalidOperationExceptionRes(parsedOutput, context);
+    case "InvalidParameterException":
+    case "com.amazonaws.shield#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "OptimisticLockException":
+    case "com.amazonaws.shield#OptimisticLockException":
+      throw await de_OptimisticLockExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.shield#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DisableProactiveEngagementCommandError");
+var de_DisassociateDRTLogBucketCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DisassociateDRTLogBucketCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DisassociateDRTLogBucketCommand");
+var de_DisassociateDRTLogBucketCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedForDependencyException":
+    case "com.amazonaws.shield#AccessDeniedForDependencyException":
+      throw await de_AccessDeniedForDependencyExceptionRes(parsedOutput, context);
+    case "InternalErrorException":
+    case "com.amazonaws.shield#InternalErrorException":
+      throw await de_InternalErrorExceptionRes(parsedOutput, context);
+    case "InvalidOperationException":
+    case "com.amazonaws.shield#InvalidOperationException":
+      throw await de_InvalidOperationExceptionRes(parsedOutput, context);
+    case "NoAssociatedRoleException":
+    case "com.amazonaws.shield#NoAssociatedRoleException":
+      throw await de_NoAssociatedRoleExceptionRes(parsedOutput, context);
+    case "OptimisticLockException":
+    case "com.amazonaws.shield#OptimisticLockException":
+      throw await de_OptimisticLockExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.shield#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DisassociateDRTLogBucketCommandError");
+var de_DisassociateDRTRoleCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DisassociateDRTRoleCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DisassociateDRTRoleCommand");
+var de_DisassociateDRTRoleCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalErrorException":
+    case "com.amazonaws.shield#InternalErrorException":
+      throw await de_InternalErrorExceptionRes(parsedOutput, context);
+    case "InvalidOperationException":
+    case "com.amazonaws.shield#InvalidOperationException":
+      throw await de_InvalidOperationExceptionRes(parsedOutput, context);
+    case "OptimisticLockException":
+    case "com.amazonaws.shield#OptimisticLockException":
+      throw await de_OptimisticLockExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.shield#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DisassociateDRTRoleCommandError");
+var de_DisassociateHealthCheckCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DisassociateHealthCheckCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DisassociateHealthCheckCommand");
+var de_DisassociateHealthCheckCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalErrorException":
+    case "com.amazonaws.shield#InternalErrorException":
+      throw await de_InternalErrorExceptionRes(parsedOutput, context);
+    case "InvalidParameterException":
+    case "com.amazonaws.shield#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "InvalidResourceException":
+    case "com.amazonaws.shield#InvalidResourceException":
+      throw await de_InvalidResourceExceptionRes(parsedOutput, context);
+    case "OptimisticLockException":
+    case "com.amazonaws.shield#OptimisticLockException":
+      throw await de_OptimisticLockExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.shield#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DisassociateHealthCheckCommandError");
+var de_EnableApplicationLayerAutomaticResponseCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_EnableApplicationLayerAutomaticResponseCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_EnableApplicationLayerAutomaticResponseCommand");
+var de_EnableApplicationLayerAutomaticResponseCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalErrorException":
+    case "com.amazonaws.shield#InternalErrorException":
+      throw await de_InternalErrorExceptionRes(parsedOutput, context);
+    case "InvalidOperationException":
+    case "com.amazonaws.shield#InvalidOperationException":
+      throw await de_InvalidOperationExceptionRes(parsedOutput, context);
+    case "InvalidParameterException":
+    case "com.amazonaws.shield#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "LimitsExceededException":
+    case "com.amazonaws.shield#LimitsExceededException":
+      throw await de_LimitsExceededExceptionRes(parsedOutput, context);
+    case "OptimisticLockException":
+    case "com.amazonaws.shield#OptimisticLockException":
+      throw await de_OptimisticLockExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.shield#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_EnableApplicationLayerAutomaticResponseCommandError");
+var de_EnableProactiveEngagementCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_EnableProactiveEngagementCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_EnableProactiveEngagementCommand");
+var de_EnableProactiveEngagementCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalErrorException":
+    case "com.amazonaws.shield#InternalErrorException":
+      throw await de_InternalErrorExceptionRes(parsedOutput, context);
+    case "InvalidOperationException":
+    case "com.amazonaws.shield#InvalidOperationException":
+      throw await de_InvalidOperationExceptionRes(parsedOutput, context);
+    case "InvalidParameterException":
+    case "com.amazonaws.shield#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "OptimisticLockException":
+    case "com.amazonaws.shield#OptimisticLockException":
+      throw await de_OptimisticLockExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.shield#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_EnableProactiveEngagementCommandError");
+var de_GetSubscriptionStateCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetSubscriptionStateCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_GetSubscriptionStateCommand");
+var de_GetSubscriptionStateCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalErrorException":
+    case "com.amazonaws.shield#InternalErrorException":
+      throw await de_InternalErrorExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetSubscriptionStateCommandError");
+var de_ListAttacksCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListAttacksCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_ListAttacksResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListAttacksCommand");
+var de_ListAttacksCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalErrorException":
+    case "com.amazonaws.shield#InternalErrorException":
+      throw await de_InternalErrorExceptionRes(parsedOutput, context);
+    case "InvalidOperationException":
+    case "com.amazonaws.shield#InvalidOperationException":
+      throw await de_InvalidOperationExceptionRes(parsedOutput, context);
+    case "InvalidParameterException":
+    case "com.amazonaws.shield#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListAttacksCommandError");
+var de_ListProtectionGroupsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListProtectionGroupsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListProtectionGroupsCommand");
+var de_ListProtectionGroupsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalErrorException":
+    case "com.amazonaws.shield#InternalErrorException":
+      throw await de_InternalErrorExceptionRes(parsedOutput, context);
+    case "InvalidPaginationTokenException":
+    case "com.amazonaws.shield#InvalidPaginationTokenException":
+      throw await de_InvalidPaginationTokenExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.shield#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListProtectionGroupsCommandError");
+var de_ListProtectionsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListProtectionsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListProtectionsCommand");
+var de_ListProtectionsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalErrorException":
+    case "com.amazonaws.shield#InternalErrorException":
+      throw await de_InternalErrorExceptionRes(parsedOutput, context);
+    case "InvalidPaginationTokenException":
+    case "com.amazonaws.shield#InvalidPaginationTokenException":
+      throw await de_InvalidPaginationTokenExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.shield#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListProtectionsCommandError");
+var de_ListResourcesInProtectionGroupCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListResourcesInProtectionGroupCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListResourcesInProtectionGroupCommand");
+var de_ListResourcesInProtectionGroupCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalErrorException":
+    case "com.amazonaws.shield#InternalErrorException":
+      throw await de_InternalErrorExceptionRes(parsedOutput, context);
+    case "InvalidPaginationTokenException":
+    case "com.amazonaws.shield#InvalidPaginationTokenException":
+      throw await de_InvalidPaginationTokenExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.shield#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListResourcesInProtectionGroupCommandError");
+var de_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListTagsForResourceCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListTagsForResourceCommand");
+var de_ListTagsForResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalErrorException":
+    case "com.amazonaws.shield#InternalErrorException":
+      throw await de_InternalErrorExceptionRes(parsedOutput, context);
+    case "InvalidResourceException":
+    case "com.amazonaws.shield#InvalidResourceException":
+      throw await de_InvalidResourceExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.shield#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListTagsForResourceCommandError");
+var de_TagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_TagResourceCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_TagResourceCommand");
+var de_TagResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalErrorException":
+    case "com.amazonaws.shield#InternalErrorException":
+      throw await de_InternalErrorExceptionRes(parsedOutput, context);
+    case "InvalidParameterException":
+    case "com.amazonaws.shield#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "InvalidResourceException":
+    case "com.amazonaws.shield#InvalidResourceException":
+      throw await de_InvalidResourceExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.shield#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_TagResourceCommandError");
+var de_UntagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UntagResourceCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_UntagResourceCommand");
+var de_UntagResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalErrorException":
+    case "com.amazonaws.shield#InternalErrorException":
+      throw await de_InternalErrorExceptionRes(parsedOutput, context);
+    case "InvalidParameterException":
+    case "com.amazonaws.shield#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "InvalidResourceException":
+    case "com.amazonaws.shield#InvalidResourceException":
+      throw await de_InvalidResourceExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.shield#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UntagResourceCommandError");
+var de_UpdateApplicationLayerAutomaticResponseCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UpdateApplicationLayerAutomaticResponseCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_UpdateApplicationLayerAutomaticResponseCommand");
+var de_UpdateApplicationLayerAutomaticResponseCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalErrorException":
+    case "com.amazonaws.shield#InternalErrorException":
+      throw await de_InternalErrorExceptionRes(parsedOutput, context);
+    case "InvalidOperationException":
+    case "com.amazonaws.shield#InvalidOperationException":
+      throw await de_InvalidOperationExceptionRes(parsedOutput, context);
+    case "InvalidParameterException":
+    case "com.amazonaws.shield#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "OptimisticLockException":
+    case "com.amazonaws.shield#OptimisticLockException":
+      throw await de_OptimisticLockExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.shield#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateApplicationLayerAutomaticResponseCommandError");
+var de_UpdateEmergencyContactSettingsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UpdateEmergencyContactSettingsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_UpdateEmergencyContactSettingsCommand");
+var de_UpdateEmergencyContactSettingsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalErrorException":
+    case "com.amazonaws.shield#InternalErrorException":
+      throw await de_InternalErrorExceptionRes(parsedOutput, context);
+    case "InvalidParameterException":
+    case "com.amazonaws.shield#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "OptimisticLockException":
+    case "com.amazonaws.shield#OptimisticLockException":
+      throw await de_OptimisticLockExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.shield#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateEmergencyContactSettingsCommandError");
+var de_UpdateProtectionGroupCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UpdateProtectionGroupCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_UpdateProtectionGroupCommand");
+var de_UpdateProtectionGroupCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalErrorException":
+    case "com.amazonaws.shield#InternalErrorException":
+      throw await de_InternalErrorExceptionRes(parsedOutput, context);
+    case "InvalidParameterException":
+    case "com.amazonaws.shield#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "OptimisticLockException":
+    case "com.amazonaws.shield#OptimisticLockException":
+      throw await de_OptimisticLockExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.shield#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateProtectionGroupCommandError");
+var de_UpdateSubscriptionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UpdateSubscriptionCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_UpdateSubscriptionCommand");
+var de_UpdateSubscriptionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalErrorException":
+    case "com.amazonaws.shield#InternalErrorException":
+      throw await de_InternalErrorExceptionRes(parsedOutput, context);
+    case "InvalidParameterException":
+    case "com.amazonaws.shield#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "LockedSubscriptionException":
+    case "com.amazonaws.shield#LockedSubscriptionException":
+      throw await de_LockedSubscriptionExceptionRes(parsedOutput, context);
+    case "OptimisticLockException":
+    case "com.amazonaws.shield#OptimisticLockException":
+      throw await de_OptimisticLockExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.shield#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateSubscriptionCommandError");
+var de_AccessDeniedExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new AccessDeniedException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_AccessDeniedExceptionRes");
+var de_AccessDeniedForDependencyExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new AccessDeniedForDependencyException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_AccessDeniedForDependencyExceptionRes");
+var de_InternalErrorExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new InternalErrorException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_InternalErrorExceptionRes");
+var de_InvalidOperationExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new InvalidOperationException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_InvalidOperationExceptionRes");
+var de_InvalidPaginationTokenExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new InvalidPaginationTokenException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_InvalidPaginationTokenExceptionRes");
+var de_InvalidParameterExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new InvalidParameterException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_InvalidParameterExceptionRes");
+var de_InvalidResourceExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new InvalidResourceException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_InvalidResourceExceptionRes");
+var de_LimitsExceededExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new LimitsExceededException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_LimitsExceededExceptionRes");
+var de_LockedSubscriptionExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new LockedSubscriptionException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_LockedSubscriptionExceptionRes");
+var de_NoAssociatedRoleExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new NoAssociatedRoleException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_NoAssociatedRoleExceptionRes");
+var de_OptimisticLockExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new OptimisticLockException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_OptimisticLockExceptionRes");
+var de_ResourceAlreadyExistsExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new ResourceAlreadyExistsException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_ResourceAlreadyExistsExceptionRes");
+var de_ResourceNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new ResourceNotFoundException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_ResourceNotFoundExceptionRes");
+var se_ListAttacksRequest = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    EndTime: (_) => se_TimeRange(_, context),
+    MaxResults: [],
+    NextToken: [],
+    ResourceArns: import_smithy_client._json,
+    StartTime: (_) => se_TimeRange(_, context)
+  });
+}, "se_ListAttacksRequest");
+var se_TimeRange = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    FromInclusive: (_) => Math.round(_.getTime() / 1e3),
+    ToExclusive: (_) => Math.round(_.getTime() / 1e3)
+  });
+}, "se_TimeRange");
+var de_AttackDetail = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    AttackCounters: (_) => de_SummarizedCounterList(_, context),
+    AttackId: import_smithy_client.expectString,
+    AttackProperties: import_smithy_client._json,
+    EndTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    Mitigations: import_smithy_client._json,
+    ResourceArn: import_smithy_client.expectString,
+    StartTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    SubResources: (_) => de_SubResourceSummaryList(_, context)
+  });
+}, "de_AttackDetail");
+var de_AttackStatisticsDataItem = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    AttackCount: import_smithy_client.expectLong,
+    AttackVolume: (_) => de_AttackVolume(_, context)
+  });
+}, "de_AttackStatisticsDataItem");
+var de_AttackStatisticsDataList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_AttackStatisticsDataItem(entry, context);
+  });
+  return retVal;
+}, "de_AttackStatisticsDataList");
+var de_AttackSummaries = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_AttackSummary(entry, context);
+  });
+  return retVal;
+}, "de_AttackSummaries");
+var de_AttackSummary = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    AttackId: import_smithy_client.expectString,
+    AttackVectors: import_smithy_client._json,
+    EndTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    ResourceArn: import_smithy_client.expectString,
+    StartTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_)))
+  });
+}, "de_AttackSummary");
+var de_AttackVolume = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    BitsPerSecond: (_) => de_AttackVolumeStatistics(_, context),
+    PacketsPerSecond: (_) => de_AttackVolumeStatistics(_, context),
+    RequestsPerSecond: (_) => de_AttackVolumeStatistics(_, context)
+  });
+}, "de_AttackVolume");
+var de_AttackVolumeStatistics = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Max: import_smithy_client.limitedParseDouble
+  });
+}, "de_AttackVolumeStatistics");
+var de_DescribeAttackResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Attack: (_) => de_AttackDetail(_, context)
+  });
+}, "de_DescribeAttackResponse");
+var de_DescribeAttackStatisticsResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    DataItems: (_) => de_AttackStatisticsDataList(_, context),
+    TimeRange: (_) => de_TimeRange(_, context)
+  });
+}, "de_DescribeAttackStatisticsResponse");
+var de_DescribeSubscriptionResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Subscription: (_) => de_Subscription(_, context)
+  });
+}, "de_DescribeSubscriptionResponse");
+var de_ListAttacksResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    AttackSummaries: (_) => de_AttackSummaries(_, context),
+    NextToken: import_smithy_client.expectString
+  });
+}, "de_ListAttacksResponse");
+var de_SubResourceSummary = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    AttackVectors: (_) => de_SummarizedAttackVectorList(_, context),
+    Counters: (_) => de_SummarizedCounterList(_, context),
+    Id: import_smithy_client.expectString,
+    Type: import_smithy_client.expectString
+  });
+}, "de_SubResourceSummary");
+var de_SubResourceSummaryList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_SubResourceSummary(entry, context);
+  });
+  return retVal;
+}, "de_SubResourceSummaryList");
+var de_Subscription = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    AutoRenew: import_smithy_client.expectString,
+    EndTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    Limits: import_smithy_client._json,
+    ProactiveEngagementStatus: import_smithy_client.expectString,
+    StartTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    SubscriptionArn: import_smithy_client.expectString,
+    SubscriptionLimits: import_smithy_client._json,
+    TimeCommitmentInSeconds: import_smithy_client.expectLong
+  });
+}, "de_Subscription");
+var de_SummarizedAttackVector = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    VectorCounters: (_) => de_SummarizedCounterList(_, context),
+    VectorType: import_smithy_client.expectString
+  });
+}, "de_SummarizedAttackVector");
+var de_SummarizedAttackVectorList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_SummarizedAttackVector(entry, context);
+  });
+  return retVal;
+}, "de_SummarizedAttackVectorList");
+var de_SummarizedCounter = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Average: import_smithy_client.limitedParseDouble,
+    Max: import_smithy_client.limitedParseDouble,
+    N: import_smithy_client.expectInt32,
+    Name: import_smithy_client.expectString,
+    Sum: import_smithy_client.limitedParseDouble,
+    Unit: import_smithy_client.expectString
+  });
+}, "de_SummarizedCounter");
+var de_SummarizedCounterList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_SummarizedCounter(entry, context);
+  });
+  return retVal;
+}, "de_SummarizedCounterList");
+var de_TimeRange = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    FromInclusive: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    ToExclusive: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_)))
+  });
+}, "de_TimeRange");
+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 throwDefaultError = (0, import_smithy_client.withBaseException)(ShieldServiceException);
+var buildHttpRpcRequest = /* @__PURE__ */ __name(async (context, headers, path, resolvedHostname, body) => {
+  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+  const contents = {
+    protocol,
+    hostname,
+    port,
+    method: "POST",
+    path: basePath.endsWith("/") ? basePath.slice(0, -1) + path : basePath + path,
+    headers
+  };
+  if (resolvedHostname !== void 0) {
+    contents.hostname = resolvedHostname;
+  }
+  if (body !== void 0) {
+    contents.body = body;
+  }
+  return new import_protocol_http.HttpRequest(contents);
+}, "buildHttpRpcRequest");
+function sharedHeaders(operation) {
+  return {
+    "content-type": "application/x-amz-json-1.1",
+    "x-amz-target": `AWSShield_20160616.${operation}`
+  };
+}
+__name(sharedHeaders, "sharedHeaders");
+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/AssociateDRTLogBucketCommand.ts
+var _AssociateDRTLogBucketCommand = class _AssociateDRTLogBucketCommand 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("AWSShield_20160616", "AssociateDRTLogBucket", {}).n("ShieldClient", "AssociateDRTLogBucketCommand").f(void 0, void 0).ser(se_AssociateDRTLogBucketCommand).de(de_AssociateDRTLogBucketCommand).build() {
+};
+__name(_AssociateDRTLogBucketCommand, "AssociateDRTLogBucketCommand");
+var AssociateDRTLogBucketCommand = _AssociateDRTLogBucketCommand;
+
+// src/commands/AssociateDRTRoleCommand.ts
+
+
+
+
+var _AssociateDRTRoleCommand = class _AssociateDRTRoleCommand 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("AWSShield_20160616", "AssociateDRTRole", {}).n("ShieldClient", "AssociateDRTRoleCommand").f(void 0, void 0).ser(se_AssociateDRTRoleCommand).de(de_AssociateDRTRoleCommand).build() {
+};
+__name(_AssociateDRTRoleCommand, "AssociateDRTRoleCommand");
+var AssociateDRTRoleCommand = _AssociateDRTRoleCommand;
+
+// src/commands/AssociateHealthCheckCommand.ts
+
+
+
+
+var _AssociateHealthCheckCommand = class _AssociateHealthCheckCommand 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("AWSShield_20160616", "AssociateHealthCheck", {}).n("ShieldClient", "AssociateHealthCheckCommand").f(void 0, void 0).ser(se_AssociateHealthCheckCommand).de(de_AssociateHealthCheckCommand).build() {
+};
+__name(_AssociateHealthCheckCommand, "AssociateHealthCheckCommand");
+var AssociateHealthCheckCommand = _AssociateHealthCheckCommand;
+
+// src/commands/AssociateProactiveEngagementDetailsCommand.ts
+
+
+
+
+var _AssociateProactiveEngagementDetailsCommand = class _AssociateProactiveEngagementDetailsCommand 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("AWSShield_20160616", "AssociateProactiveEngagementDetails", {}).n("ShieldClient", "AssociateProactiveEngagementDetailsCommand").f(void 0, void 0).ser(se_AssociateProactiveEngagementDetailsCommand).de(de_AssociateProactiveEngagementDetailsCommand).build() {
+};
+__name(_AssociateProactiveEngagementDetailsCommand, "AssociateProactiveEngagementDetailsCommand");
+var AssociateProactiveEngagementDetailsCommand = _AssociateProactiveEngagementDetailsCommand;
+
+// src/commands/CreateProtectionCommand.ts
+
+
+
+
+var _CreateProtectionCommand = class _CreateProtectionCommand 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("AWSShield_20160616", "CreateProtection", {}).n("ShieldClient", "CreateProtectionCommand").f(void 0, void 0).ser(se_CreateProtectionCommand).de(de_CreateProtectionCommand).build() {
+};
+__name(_CreateProtectionCommand, "CreateProtectionCommand");
+var CreateProtectionCommand = _CreateProtectionCommand;
+
+// src/commands/CreateProtectionGroupCommand.ts
+
+
+
+
+var _CreateProtectionGroupCommand = class _CreateProtectionGroupCommand 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("AWSShield_20160616", "CreateProtectionGroup", {}).n("ShieldClient", "CreateProtectionGroupCommand").f(void 0, void 0).ser(se_CreateProtectionGroupCommand).de(de_CreateProtectionGroupCommand).build() {
+};
+__name(_CreateProtectionGroupCommand, "CreateProtectionGroupCommand");
+var CreateProtectionGroupCommand = _CreateProtectionGroupCommand;
+
+// src/commands/CreateSubscriptionCommand.ts
+
+
+
+
+var _CreateSubscriptionCommand = class _CreateSubscriptionCommand 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("AWSShield_20160616", "CreateSubscription", {}).n("ShieldClient", "CreateSubscriptionCommand").f(void 0, void 0).ser(se_CreateSubscriptionCommand).de(de_CreateSubscriptionCommand).build() {
+};
+__name(_CreateSubscriptionCommand, "CreateSubscriptionCommand");
+var CreateSubscriptionCommand = _CreateSubscriptionCommand;
+
+// src/commands/DeleteProtectionCommand.ts
+
+
+
+
+var _DeleteProtectionCommand = class _DeleteProtectionCommand 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("AWSShield_20160616", "DeleteProtection", {}).n("ShieldClient", "DeleteProtectionCommand").f(void 0, void 0).ser(se_DeleteProtectionCommand).de(de_DeleteProtectionCommand).build() {
+};
+__name(_DeleteProtectionCommand, "DeleteProtectionCommand");
+var DeleteProtectionCommand = _DeleteProtectionCommand;
+
+// src/commands/DeleteProtectionGroupCommand.ts
+
+
+
+
+var _DeleteProtectionGroupCommand = class _DeleteProtectionGroupCommand 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("AWSShield_20160616", "DeleteProtectionGroup", {}).n("ShieldClient", "DeleteProtectionGroupCommand").f(void 0, void 0).ser(se_DeleteProtectionGroupCommand).de(de_DeleteProtectionGroupCommand).build() {
+};
+__name(_DeleteProtectionGroupCommand, "DeleteProtectionGroupCommand");
+var DeleteProtectionGroupCommand = _DeleteProtectionGroupCommand;
+
+// src/commands/DeleteSubscriptionCommand.ts
+
+
+
+
+var _DeleteSubscriptionCommand = class _DeleteSubscriptionCommand 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("AWSShield_20160616", "DeleteSubscription", {}).n("ShieldClient", "DeleteSubscriptionCommand").f(void 0, void 0).ser(se_DeleteSubscriptionCommand).de(de_DeleteSubscriptionCommand).build() {
+};
+__name(_DeleteSubscriptionCommand, "DeleteSubscriptionCommand");
+var DeleteSubscriptionCommand = _DeleteSubscriptionCommand;
+
+// src/commands/DescribeAttackCommand.ts
+
+
+
+
+var _DescribeAttackCommand = class _DescribeAttackCommand 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("AWSShield_20160616", "DescribeAttack", {}).n("ShieldClient", "DescribeAttackCommand").f(void 0, void 0).ser(se_DescribeAttackCommand).de(de_DescribeAttackCommand).build() {
+};
+__name(_DescribeAttackCommand, "DescribeAttackCommand");
+var DescribeAttackCommand = _DescribeAttackCommand;
+
+// src/commands/DescribeAttackStatisticsCommand.ts
+
+
+
+
+var _DescribeAttackStatisticsCommand = class _DescribeAttackStatisticsCommand 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("AWSShield_20160616", "DescribeAttackStatistics", {}).n("ShieldClient", "DescribeAttackStatisticsCommand").f(void 0, void 0).ser(se_DescribeAttackStatisticsCommand).de(de_DescribeAttackStatisticsCommand).build() {
+};
+__name(_DescribeAttackStatisticsCommand, "DescribeAttackStatisticsCommand");
+var DescribeAttackStatisticsCommand = _DescribeAttackStatisticsCommand;
+
+// src/commands/DescribeDRTAccessCommand.ts
+
+
+
+
+var _DescribeDRTAccessCommand = class _DescribeDRTAccessCommand 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("AWSShield_20160616", "DescribeDRTAccess", {}).n("ShieldClient", "DescribeDRTAccessCommand").f(void 0, void 0).ser(se_DescribeDRTAccessCommand).de(de_DescribeDRTAccessCommand).build() {
+};
+__name(_DescribeDRTAccessCommand, "DescribeDRTAccessCommand");
+var DescribeDRTAccessCommand = _DescribeDRTAccessCommand;
+
+// src/commands/DescribeEmergencyContactSettingsCommand.ts
+
+
+
+
+var _DescribeEmergencyContactSettingsCommand = class _DescribeEmergencyContactSettingsCommand 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("AWSShield_20160616", "DescribeEmergencyContactSettings", {}).n("ShieldClient", "DescribeEmergencyContactSettingsCommand").f(void 0, void 0).ser(se_DescribeEmergencyContactSettingsCommand).de(de_DescribeEmergencyContactSettingsCommand).build() {
+};
+__name(_DescribeEmergencyContactSettingsCommand, "DescribeEmergencyContactSettingsCommand");
+var DescribeEmergencyContactSettingsCommand = _DescribeEmergencyContactSettingsCommand;
+
+// src/commands/DescribeProtectionCommand.ts
+
+
+
+
+var _DescribeProtectionCommand = class _DescribeProtectionCommand 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("AWSShield_20160616", "DescribeProtection", {}).n("ShieldClient", "DescribeProtectionCommand").f(void 0, void 0).ser(se_DescribeProtectionCommand).de(de_DescribeProtectionCommand).build() {
+};
+__name(_DescribeProtectionCommand, "DescribeProtectionCommand");
+var DescribeProtectionCommand = _DescribeProtectionCommand;
+
+// src/commands/DescribeProtectionGroupCommand.ts
+
+
+
+
+var _DescribeProtectionGroupCommand = class _DescribeProtectionGroupCommand 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("AWSShield_20160616", "DescribeProtectionGroup", {}).n("ShieldClient", "DescribeProtectionGroupCommand").f(void 0, void 0).ser(se_DescribeProtectionGroupCommand).de(de_DescribeProtectionGroupCommand).build() {
+};
+__name(_DescribeProtectionGroupCommand, "DescribeProtectionGroupCommand");
+var DescribeProtectionGroupCommand = _DescribeProtectionGroupCommand;
+
+// src/commands/DescribeSubscriptionCommand.ts
+
+
+
+
+var _DescribeSubscriptionCommand = class _DescribeSubscriptionCommand 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("AWSShield_20160616", "DescribeSubscription", {}).n("ShieldClient", "DescribeSubscriptionCommand").f(void 0, void 0).ser(se_DescribeSubscriptionCommand).de(de_DescribeSubscriptionCommand).build() {
+};
+__name(_DescribeSubscriptionCommand, "DescribeSubscriptionCommand");
+var DescribeSubscriptionCommand = _DescribeSubscriptionCommand;
+
+// src/commands/DisableApplicationLayerAutomaticResponseCommand.ts
+
+
+
+
+var _DisableApplicationLayerAutomaticResponseCommand = class _DisableApplicationLayerAutomaticResponseCommand 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("AWSShield_20160616", "DisableApplicationLayerAutomaticResponse", {}).n("ShieldClient", "DisableApplicationLayerAutomaticResponseCommand").f(void 0, void 0).ser(se_DisableApplicationLayerAutomaticResponseCommand).de(de_DisableApplicationLayerAutomaticResponseCommand).build() {
+};
+__name(_DisableApplicationLayerAutomaticResponseCommand, "DisableApplicationLayerAutomaticResponseCommand");
+var DisableApplicationLayerAutomaticResponseCommand = _DisableApplicationLayerAutomaticResponseCommand;
+
+// src/commands/DisableProactiveEngagementCommand.ts
+
+
+
+
+var _DisableProactiveEngagementCommand = class _DisableProactiveEngagementCommand 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("AWSShield_20160616", "DisableProactiveEngagement", {}).n("ShieldClient", "DisableProactiveEngagementCommand").f(void 0, void 0).ser(se_DisableProactiveEngagementCommand).de(de_DisableProactiveEngagementCommand).build() {
+};
+__name(_DisableProactiveEngagementCommand, "DisableProactiveEngagementCommand");
+var DisableProactiveEngagementCommand = _DisableProactiveEngagementCommand;
+
+// src/commands/DisassociateDRTLogBucketCommand.ts
+
+
+
+
+var _DisassociateDRTLogBucketCommand = class _DisassociateDRTLogBucketCommand 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("AWSShield_20160616", "DisassociateDRTLogBucket", {}).n("ShieldClient", "DisassociateDRTLogBucketCommand").f(void 0, void 0).ser(se_DisassociateDRTLogBucketCommand).de(de_DisassociateDRTLogBucketCommand).build() {
+};
+__name(_DisassociateDRTLogBucketCommand, "DisassociateDRTLogBucketCommand");
+var DisassociateDRTLogBucketCommand = _DisassociateDRTLogBucketCommand;
+
+// src/commands/DisassociateDRTRoleCommand.ts
+
+
+
+
+var _DisassociateDRTRoleCommand = class _DisassociateDRTRoleCommand 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("AWSShield_20160616", "DisassociateDRTRole", {}).n("ShieldClient", "DisassociateDRTRoleCommand").f(void 0, void 0).ser(se_DisassociateDRTRoleCommand).de(de_DisassociateDRTRoleCommand).build() {
+};
+__name(_DisassociateDRTRoleCommand, "DisassociateDRTRoleCommand");
+var DisassociateDRTRoleCommand = _DisassociateDRTRoleCommand;
+
+// src/commands/DisassociateHealthCheckCommand.ts
+
+
+
+
+var _DisassociateHealthCheckCommand = class _DisassociateHealthCheckCommand 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("AWSShield_20160616", "DisassociateHealthCheck", {}).n("ShieldClient", "DisassociateHealthCheckCommand").f(void 0, void 0).ser(se_DisassociateHealthCheckCommand).de(de_DisassociateHealthCheckCommand).build() {
+};
+__name(_DisassociateHealthCheckCommand, "DisassociateHealthCheckCommand");
+var DisassociateHealthCheckCommand = _DisassociateHealthCheckCommand;
+
+// src/commands/EnableApplicationLayerAutomaticResponseCommand.ts
+
+
+
+
+var _EnableApplicationLayerAutomaticResponseCommand = class _EnableApplicationLayerAutomaticResponseCommand 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("AWSShield_20160616", "EnableApplicationLayerAutomaticResponse", {}).n("ShieldClient", "EnableApplicationLayerAutomaticResponseCommand").f(void 0, void 0).ser(se_EnableApplicationLayerAutomaticResponseCommand).de(de_EnableApplicationLayerAutomaticResponseCommand).build() {
+};
+__name(_EnableApplicationLayerAutomaticResponseCommand, "EnableApplicationLayerAutomaticResponseCommand");
+var EnableApplicationLayerAutomaticResponseCommand = _EnableApplicationLayerAutomaticResponseCommand;
+
+// src/commands/EnableProactiveEngagementCommand.ts
+
+
+
+
+var _EnableProactiveEngagementCommand = class _EnableProactiveEngagementCommand 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("AWSShield_20160616", "EnableProactiveEngagement", {}).n("ShieldClient", "EnableProactiveEngagementCommand").f(void 0, void 0).ser(se_EnableProactiveEngagementCommand).de(de_EnableProactiveEngagementCommand).build() {
+};
+__name(_EnableProactiveEngagementCommand, "EnableProactiveEngagementCommand");
+var EnableProactiveEngagementCommand = _EnableProactiveEngagementCommand;
+
+// src/commands/GetSubscriptionStateCommand.ts
+
+
+
+
+var _GetSubscriptionStateCommand = class _GetSubscriptionStateCommand 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("AWSShield_20160616", "GetSubscriptionState", {}).n("ShieldClient", "GetSubscriptionStateCommand").f(void 0, void 0).ser(se_GetSubscriptionStateCommand).de(de_GetSubscriptionStateCommand).build() {
+};
+__name(_GetSubscriptionStateCommand, "GetSubscriptionStateCommand");
+var GetSubscriptionStateCommand = _GetSubscriptionStateCommand;
+
+// src/commands/ListAttacksCommand.ts
+
+
+
+
+var _ListAttacksCommand = class _ListAttacksCommand 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("AWSShield_20160616", "ListAttacks", {}).n("ShieldClient", "ListAttacksCommand").f(void 0, void 0).ser(se_ListAttacksCommand).de(de_ListAttacksCommand).build() {
+};
+__name(_ListAttacksCommand, "ListAttacksCommand");
+var ListAttacksCommand = _ListAttacksCommand;
+
+// src/commands/ListProtectionGroupsCommand.ts
+
+
+
+
+var _ListProtectionGroupsCommand = class _ListProtectionGroupsCommand 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("AWSShield_20160616", "ListProtectionGroups", {}).n("ShieldClient", "ListProtectionGroupsCommand").f(void 0, void 0).ser(se_ListProtectionGroupsCommand).de(de_ListProtectionGroupsCommand).build() {
+};
+__name(_ListProtectionGroupsCommand, "ListProtectionGroupsCommand");
+var ListProtectionGroupsCommand = _ListProtectionGroupsCommand;
+
+// src/commands/ListProtectionsCommand.ts
+
+
+
+
+var _ListProtectionsCommand = class _ListProtectionsCommand 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("AWSShield_20160616", "ListProtections", {}).n("ShieldClient", "ListProtectionsCommand").f(void 0, void 0).ser(se_ListProtectionsCommand).de(de_ListProtectionsCommand).build() {
+};
+__name(_ListProtectionsCommand, "ListProtectionsCommand");
+var ListProtectionsCommand = _ListProtectionsCommand;
+
+// src/commands/ListResourcesInProtectionGroupCommand.ts
+
+
+
+
+var _ListResourcesInProtectionGroupCommand = class _ListResourcesInProtectionGroupCommand 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("AWSShield_20160616", "ListResourcesInProtectionGroup", {}).n("ShieldClient", "ListResourcesInProtectionGroupCommand").f(void 0, void 0).ser(se_ListResourcesInProtectionGroupCommand).de(de_ListResourcesInProtectionGroupCommand).build() {
+};
+__name(_ListResourcesInProtectionGroupCommand, "ListResourcesInProtectionGroupCommand");
+var ListResourcesInProtectionGroupCommand = _ListResourcesInProtectionGroupCommand;
+
+// src/commands/ListTagsForResourceCommand.ts
+
+
+
+
+var _ListTagsForResourceCommand = class _ListTagsForResourceCommand 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("AWSShield_20160616", "ListTagsForResource", {}).n("ShieldClient", "ListTagsForResourceCommand").f(void 0, void 0).ser(se_ListTagsForResourceCommand).de(de_ListTagsForResourceCommand).build() {
+};
+__name(_ListTagsForResourceCommand, "ListTagsForResourceCommand");
+var ListTagsForResourceCommand = _ListTagsForResourceCommand;
+
+// src/commands/TagResourceCommand.ts
+
+
+
+
+var _TagResourceCommand = class _TagResourceCommand 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("AWSShield_20160616", "TagResource", {}).n("ShieldClient", "TagResourceCommand").f(void 0, void 0).ser(se_TagResourceCommand).de(de_TagResourceCommand).build() {
+};
+__name(_TagResourceCommand, "TagResourceCommand");
+var TagResourceCommand = _TagResourceCommand;
+
+// src/commands/UntagResourceCommand.ts
+
+
+
+
+var _UntagResourceCommand = class _UntagResourceCommand 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("AWSShield_20160616", "UntagResource", {}).n("ShieldClient", "UntagResourceCommand").f(void 0, void 0).ser(se_UntagResourceCommand).de(de_UntagResourceCommand).build() {
+};
+__name(_UntagResourceCommand, "UntagResourceCommand");
+var UntagResourceCommand = _UntagResourceCommand;
+
+// src/commands/UpdateApplicationLayerAutomaticResponseCommand.ts
+
+
+
+
+var _UpdateApplicationLayerAutomaticResponseCommand = class _UpdateApplicationLayerAutomaticResponseCommand 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("AWSShield_20160616", "UpdateApplicationLayerAutomaticResponse", {}).n("ShieldClient", "UpdateApplicationLayerAutomaticResponseCommand").f(void 0, void 0).ser(se_UpdateApplicationLayerAutomaticResponseCommand).de(de_UpdateApplicationLayerAutomaticResponseCommand).build() {
+};
+__name(_UpdateApplicationLayerAutomaticResponseCommand, "UpdateApplicationLayerAutomaticResponseCommand");
+var UpdateApplicationLayerAutomaticResponseCommand = _UpdateApplicationLayerAutomaticResponseCommand;
+
+// src/commands/UpdateEmergencyContactSettingsCommand.ts
+
+
+
+
+var _UpdateEmergencyContactSettingsCommand = class _UpdateEmergencyContactSettingsCommand 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("AWSShield_20160616", "UpdateEmergencyContactSettings", {}).n("ShieldClient", "UpdateEmergencyContactSettingsCommand").f(void 0, void 0).ser(se_UpdateEmergencyContactSettingsCommand).de(de_UpdateEmergencyContactSettingsCommand).build() {
+};
+__name(_UpdateEmergencyContactSettingsCommand, "UpdateEmergencyContactSettingsCommand");
+var UpdateEmergencyContactSettingsCommand = _UpdateEmergencyContactSettingsCommand;
+
+// src/commands/UpdateProtectionGroupCommand.ts
+
+
+
+
+var _UpdateProtectionGroupCommand = class _UpdateProtectionGroupCommand 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("AWSShield_20160616", "UpdateProtectionGroup", {}).n("ShieldClient", "UpdateProtectionGroupCommand").f(void 0, void 0).ser(se_UpdateProtectionGroupCommand).de(de_UpdateProtectionGroupCommand).build() {
+};
+__name(_UpdateProtectionGroupCommand, "UpdateProtectionGroupCommand");
+var UpdateProtectionGroupCommand = _UpdateProtectionGroupCommand;
+
+// src/commands/UpdateSubscriptionCommand.ts
+
+
+
+
+var _UpdateSubscriptionCommand = class _UpdateSubscriptionCommand 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("AWSShield_20160616", "UpdateSubscription", {}).n("ShieldClient", "UpdateSubscriptionCommand").f(void 0, void 0).ser(se_UpdateSubscriptionCommand).de(de_UpdateSubscriptionCommand).build() {
+};
+__name(_UpdateSubscriptionCommand, "UpdateSubscriptionCommand");
+var UpdateSubscriptionCommand = _UpdateSubscriptionCommand;
+
+// src/Shield.ts
+var commands = {
+  AssociateDRTLogBucketCommand,
+  AssociateDRTRoleCommand,
+  AssociateHealthCheckCommand,
+  AssociateProactiveEngagementDetailsCommand,
+  CreateProtectionCommand,
+  CreateProtectionGroupCommand,
+  CreateSubscriptionCommand,
+  DeleteProtectionCommand,
+  DeleteProtectionGroupCommand,
+  DeleteSubscriptionCommand,
+  DescribeAttackCommand,
+  DescribeAttackStatisticsCommand,
+  DescribeDRTAccessCommand,
+  DescribeEmergencyContactSettingsCommand,
+  DescribeProtectionCommand,
+  DescribeProtectionGroupCommand,
+  DescribeSubscriptionCommand,
+  DisableApplicationLayerAutomaticResponseCommand,
+  DisableProactiveEngagementCommand,
+  DisassociateDRTLogBucketCommand,
+  DisassociateDRTRoleCommand,
+  DisassociateHealthCheckCommand,
+  EnableApplicationLayerAutomaticResponseCommand,
+  EnableProactiveEngagementCommand,
+  GetSubscriptionStateCommand,
+  ListAttacksCommand,
+  ListProtectionGroupsCommand,
+  ListProtectionsCommand,
+  ListResourcesInProtectionGroupCommand,
+  ListTagsForResourceCommand,
+  TagResourceCommand,
+  UntagResourceCommand,
+  UpdateApplicationLayerAutomaticResponseCommand,
+  UpdateEmergencyContactSettingsCommand,
+  UpdateProtectionGroupCommand,
+  UpdateSubscriptionCommand
+};
+var _Shield = class _Shield extends ShieldClient {
+};
+__name(_Shield, "Shield");
+var Shield = _Shield;
+(0, import_smithy_client.createAggregatedClient)(commands, Shield);
+
+// src/pagination/ListAttacksPaginator.ts
+var import_core = require("@smithy/core");
+var paginateListAttacks = (0, import_core.createPaginator)(ShieldClient, ListAttacksCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/pagination/ListProtectionGroupsPaginator.ts
+
+var paginateListProtectionGroups = (0, import_core.createPaginator)(ShieldClient, ListProtectionGroupsCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/pagination/ListProtectionsPaginator.ts
+
+var paginateListProtections = (0, import_core.createPaginator)(ShieldClient, ListProtectionsCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/pagination/ListResourcesInProtectionGroupPaginator.ts
+
+var paginateListResourcesInProtectionGroup = (0, import_core.createPaginator)(ShieldClient, ListResourcesInProtectionGroupCommand, "NextToken", "NextToken", "MaxResults");
+
+// 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 = {
+  AccessDeniedException,
+  AccessDeniedForDependencyException,
+  ApplicationLayerAutomaticResponseStatus,
+  AssociateDRTLogBucketCommand,
+  AssociateDRTRoleCommand,
+  AssociateHealthCheckCommand,
+  AssociateProactiveEngagementDetailsCommand,
+  AttackLayer,
+  AttackPropertyIdentifier,
+  AutoRenew,
+  CreateProtectionCommand,
+  CreateProtectionGroupCommand,
+  CreateSubscriptionCommand,
+  DeleteProtectionCommand,
+  DeleteProtectionGroupCommand,
+  DeleteSubscriptionCommand,
+  DescribeAttackCommand,
+  DescribeAttackStatisticsCommand,
+  DescribeDRTAccessCommand,
+  DescribeEmergencyContactSettingsCommand,
+  DescribeProtectionCommand,
+  DescribeProtectionGroupCommand,
+  DescribeSubscriptionCommand,
+  DisableApplicationLayerAutomaticResponseCommand,
+  DisableProactiveEngagementCommand,
+  DisassociateDRTLogBucketCommand,
+  DisassociateDRTRoleCommand,
+  DisassociateHealthCheckCommand,
+  EnableApplicationLayerAutomaticResponseCommand,
+  EnableProactiveEngagementCommand,
+  GetSubscriptionStateCommand,
+  InternalErrorException,
+  InvalidOperationException,
+  InvalidPaginationTokenException,
+  InvalidParameterException,
+  InvalidResourceException,
+  LimitsExceededException,
+  ListAttacksCommand,
+  ListProtectionGroupsCommand,
+  ListProtectionsCommand,
+  ListResourcesInProtectionGroupCommand,
+  ListTagsForResourceCommand,
+  LockedSubscriptionException,
+  NoAssociatedRoleException,
+  OptimisticLockException,
+  ProactiveEngagementStatus,
+  ProtectedResourceType,
+  ProtectionGroupAggregation,
+  ProtectionGroupPattern,
+  ResourceAlreadyExistsException,
+  ResourceNotFoundException,
+  Shield,
+  ShieldClient,
+  ShieldServiceException,
+  SubResourceType,
+  SubscriptionState,
+  TagResourceCommand,
+  Unit,
+  UntagResourceCommand,
+  UpdateApplicationLayerAutomaticResponseCommand,
+  UpdateEmergencyContactSettingsCommand,
+  UpdateProtectionGroupCommand,
+  UpdateSubscriptionCommand,
+  ValidationExceptionReason,
+  __Client,
+  paginateListAttacks,
+  paginateListProtectionGroups,
+  paginateListProtections,
+  paginateListResourcesInProtectionGroup
+});