@aws-sdk/client-shield 3.303.0 → 3.309.0

package/dist-es/protocols/Aws_json1_1.js

@@ -2,344 +2,344 @@ import { HttpRequest as __HttpRequest } from "@aws-sdk/protocol-http";
 import { decorateServiceException as __decorateServiceException, expectInt32 as __expectInt32, expectLong as __expectLong, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectString as __expectString, limitedParseDouble as __limitedParseDouble, parseEpochTimestamp as __parseEpochTimestamp, throwDefaultError, } from "@aws-sdk/smithy-client";
 import { AccessDeniedException, AccessDeniedForDependencyException, InternalErrorException, InvalidOperationException, InvalidPaginationTokenException, InvalidParameterException, InvalidResourceException, LimitsExceededException, LockedSubscriptionException, NoAssociatedRoleException, OptimisticLockException, ResourceAlreadyExistsException, ResourceNotFoundException, } from "../models/models_0";
 import { ShieldServiceException as __BaseException } from "../models/ShieldServiceException";
-export const serializeAws_json1_1AssociateDRTLogBucketCommand = async (input, context) => {
+export const se_AssociateDRTLogBucketCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "AWSShield_20160616.AssociateDRTLogBucket",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1AssociateDRTLogBucketRequest(input, context));
+    body = JSON.stringify(se_AssociateDRTLogBucketRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1AssociateDRTRoleCommand = async (input, context) => {
+export const se_AssociateDRTRoleCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "AWSShield_20160616.AssociateDRTRole",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1AssociateDRTRoleRequest(input, context));
+    body = JSON.stringify(se_AssociateDRTRoleRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1AssociateHealthCheckCommand = async (input, context) => {
+export const se_AssociateHealthCheckCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "AWSShield_20160616.AssociateHealthCheck",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1AssociateHealthCheckRequest(input, context));
+    body = JSON.stringify(se_AssociateHealthCheckRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1AssociateProactiveEngagementDetailsCommand = async (input, context) => {
+export const se_AssociateProactiveEngagementDetailsCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "AWSShield_20160616.AssociateProactiveEngagementDetails",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1AssociateProactiveEngagementDetailsRequest(input, context));
+    body = JSON.stringify(se_AssociateProactiveEngagementDetailsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1CreateProtectionCommand = async (input, context) => {
+export const se_CreateProtectionCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "AWSShield_20160616.CreateProtection",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1CreateProtectionRequest(input, context));
+    body = JSON.stringify(se_CreateProtectionRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1CreateProtectionGroupCommand = async (input, context) => {
+export const se_CreateProtectionGroupCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "AWSShield_20160616.CreateProtectionGroup",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1CreateProtectionGroupRequest(input, context));
+    body = JSON.stringify(se_CreateProtectionGroupRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1CreateSubscriptionCommand = async (input, context) => {
+export const se_CreateSubscriptionCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "AWSShield_20160616.CreateSubscription",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1CreateSubscriptionRequest(input, context));
+    body = JSON.stringify(se_CreateSubscriptionRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1DeleteProtectionCommand = async (input, context) => {
+export const se_DeleteProtectionCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "AWSShield_20160616.DeleteProtection",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1DeleteProtectionRequest(input, context));
+    body = JSON.stringify(se_DeleteProtectionRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1DeleteProtectionGroupCommand = async (input, context) => {
+export const se_DeleteProtectionGroupCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "AWSShield_20160616.DeleteProtectionGroup",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1DeleteProtectionGroupRequest(input, context));
+    body = JSON.stringify(se_DeleteProtectionGroupRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1DeleteSubscriptionCommand = async (input, context) => {
+export const se_DeleteSubscriptionCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "AWSShield_20160616.DeleteSubscription",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1DeleteSubscriptionRequest(input, context));
+    body = JSON.stringify(se_DeleteSubscriptionRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1DescribeAttackCommand = async (input, context) => {
+export const se_DescribeAttackCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "AWSShield_20160616.DescribeAttack",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1DescribeAttackRequest(input, context));
+    body = JSON.stringify(se_DescribeAttackRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1DescribeAttackStatisticsCommand = async (input, context) => {
+export const se_DescribeAttackStatisticsCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "AWSShield_20160616.DescribeAttackStatistics",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1DescribeAttackStatisticsRequest(input, context));
+    body = JSON.stringify(se_DescribeAttackStatisticsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1DescribeDRTAccessCommand = async (input, context) => {
+export const se_DescribeDRTAccessCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "AWSShield_20160616.DescribeDRTAccess",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1DescribeDRTAccessRequest(input, context));
+    body = JSON.stringify(se_DescribeDRTAccessRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1DescribeEmergencyContactSettingsCommand = async (input, context) => {
+export const se_DescribeEmergencyContactSettingsCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "AWSShield_20160616.DescribeEmergencyContactSettings",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1DescribeEmergencyContactSettingsRequest(input, context));
+    body = JSON.stringify(se_DescribeEmergencyContactSettingsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1DescribeProtectionCommand = async (input, context) => {
+export const se_DescribeProtectionCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "AWSShield_20160616.DescribeProtection",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1DescribeProtectionRequest(input, context));
+    body = JSON.stringify(se_DescribeProtectionRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1DescribeProtectionGroupCommand = async (input, context) => {
+export const se_DescribeProtectionGroupCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "AWSShield_20160616.DescribeProtectionGroup",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1DescribeProtectionGroupRequest(input, context));
+    body = JSON.stringify(se_DescribeProtectionGroupRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1DescribeSubscriptionCommand = async (input, context) => {
+export const se_DescribeSubscriptionCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "AWSShield_20160616.DescribeSubscription",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1DescribeSubscriptionRequest(input, context));
+    body = JSON.stringify(se_DescribeSubscriptionRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1DisableApplicationLayerAutomaticResponseCommand = async (input, context) => {
+export const se_DisableApplicationLayerAutomaticResponseCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "AWSShield_20160616.DisableApplicationLayerAutomaticResponse",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1DisableApplicationLayerAutomaticResponseRequest(input, context));
+    body = JSON.stringify(se_DisableApplicationLayerAutomaticResponseRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1DisableProactiveEngagementCommand = async (input, context) => {
+export const se_DisableProactiveEngagementCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "AWSShield_20160616.DisableProactiveEngagement",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1DisableProactiveEngagementRequest(input, context));
+    body = JSON.stringify(se_DisableProactiveEngagementRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1DisassociateDRTLogBucketCommand = async (input, context) => {
+export const se_DisassociateDRTLogBucketCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "AWSShield_20160616.DisassociateDRTLogBucket",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1DisassociateDRTLogBucketRequest(input, context));
+    body = JSON.stringify(se_DisassociateDRTLogBucketRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1DisassociateDRTRoleCommand = async (input, context) => {
+export const se_DisassociateDRTRoleCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "AWSShield_20160616.DisassociateDRTRole",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1DisassociateDRTRoleRequest(input, context));
+    body = JSON.stringify(se_DisassociateDRTRoleRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1DisassociateHealthCheckCommand = async (input, context) => {
+export const se_DisassociateHealthCheckCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "AWSShield_20160616.DisassociateHealthCheck",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1DisassociateHealthCheckRequest(input, context));
+    body = JSON.stringify(se_DisassociateHealthCheckRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1EnableApplicationLayerAutomaticResponseCommand = async (input, context) => {
+export const se_EnableApplicationLayerAutomaticResponseCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "AWSShield_20160616.EnableApplicationLayerAutomaticResponse",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1EnableApplicationLayerAutomaticResponseRequest(input, context));
+    body = JSON.stringify(se_EnableApplicationLayerAutomaticResponseRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1EnableProactiveEngagementCommand = async (input, context) => {
+export const se_EnableProactiveEngagementCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "AWSShield_20160616.EnableProactiveEngagement",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1EnableProactiveEngagementRequest(input, context));
+    body = JSON.stringify(se_EnableProactiveEngagementRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1GetSubscriptionStateCommand = async (input, context) => {
+export const se_GetSubscriptionStateCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "AWSShield_20160616.GetSubscriptionState",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1GetSubscriptionStateRequest(input, context));
+    body = JSON.stringify(se_GetSubscriptionStateRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1ListAttacksCommand = async (input, context) => {
+export const se_ListAttacksCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "AWSShield_20160616.ListAttacks",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1ListAttacksRequest(input, context));
+    body = JSON.stringify(se_ListAttacksRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1ListProtectionGroupsCommand = async (input, context) => {
+export const se_ListProtectionGroupsCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "AWSShield_20160616.ListProtectionGroups",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1ListProtectionGroupsRequest(input, context));
+    body = JSON.stringify(se_ListProtectionGroupsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1ListProtectionsCommand = async (input, context) => {
+export const se_ListProtectionsCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "AWSShield_20160616.ListProtections",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1ListProtectionsRequest(input, context));
+    body = JSON.stringify(se_ListProtectionsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1ListResourcesInProtectionGroupCommand = async (input, context) => {
+export const se_ListResourcesInProtectionGroupCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "AWSShield_20160616.ListResourcesInProtectionGroup",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1ListResourcesInProtectionGroupRequest(input, context));
+    body = JSON.stringify(se_ListResourcesInProtectionGroupRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1ListTagsForResourceCommand = async (input, context) => {
+export const se_ListTagsForResourceCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "AWSShield_20160616.ListTagsForResource",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1ListTagsForResourceRequest(input, context));
+    body = JSON.stringify(se_ListTagsForResourceRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1TagResourceCommand = async (input, context) => {
+export const se_TagResourceCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "AWSShield_20160616.TagResource",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1TagResourceRequest(input, context));
+    body = JSON.stringify(se_TagResourceRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1UntagResourceCommand = async (input, context) => {
+export const se_UntagResourceCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "AWSShield_20160616.UntagResource",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1UntagResourceRequest(input, context));
+    body = JSON.stringify(se_UntagResourceRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1UpdateApplicationLayerAutomaticResponseCommand = async (input, context) => {
+export const se_UpdateApplicationLayerAutomaticResponseCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "AWSShield_20160616.UpdateApplicationLayerAutomaticResponse",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1UpdateApplicationLayerAutomaticResponseRequest(input, context));
+    body = JSON.stringify(se_UpdateApplicationLayerAutomaticResponseRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1UpdateEmergencyContactSettingsCommand = async (input, context) => {
+export const se_UpdateEmergencyContactSettingsCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "AWSShield_20160616.UpdateEmergencyContactSettings",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1UpdateEmergencyContactSettingsRequest(input, context));
+    body = JSON.stringify(se_UpdateEmergencyContactSettingsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1UpdateProtectionGroupCommand = async (input, context) => {
+export const se_UpdateProtectionGroupCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "AWSShield_20160616.UpdateProtectionGroup",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1UpdateProtectionGroupRequest(input, context));
+    body = JSON.stringify(se_UpdateProtectionGroupRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1UpdateSubscriptionCommand = async (input, context) => {
+export const se_UpdateSubscriptionCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "AWSShield_20160616.UpdateSubscription",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1UpdateSubscriptionRequest(input, context));
+    body = JSON.stringify(se_UpdateSubscriptionRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const deserializeAws_json1_1AssociateDRTLogBucketCommand = async (output, context) => {
+export const de_AssociateDRTLogBucketCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1AssociateDRTLogBucketCommandError(output, context);
+        return de_AssociateDRTLogBucketCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1AssociateDRTLogBucketResponse(data, context);
+    contents = de_AssociateDRTLogBucketResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1AssociateDRTLogBucketCommandError = async (output, context) => {
+const de_AssociateDRTLogBucketCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -348,28 +348,28 @@ const deserializeAws_json1_1AssociateDRTLogBucketCommandError = async (output, c
     switch (errorCode) {
         case "AccessDeniedForDependencyException":
         case "com.amazonaws.shield#AccessDeniedForDependencyException":
-            throw await deserializeAws_json1_1AccessDeniedForDependencyExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedForDependencyExceptionRes(parsedOutput, context);
         case "InternalErrorException":
         case "com.amazonaws.shield#InternalErrorException":
-            throw await deserializeAws_json1_1InternalErrorExceptionResponse(parsedOutput, context);
+            throw await de_InternalErrorExceptionRes(parsedOutput, context);
         case "InvalidOperationException":
         case "com.amazonaws.shield#InvalidOperationException":
-            throw await deserializeAws_json1_1InvalidOperationExceptionResponse(parsedOutput, context);
+            throw await de_InvalidOperationExceptionRes(parsedOutput, context);
         case "InvalidParameterException":
         case "com.amazonaws.shield#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "LimitsExceededException":
         case "com.amazonaws.shield#LimitsExceededException":
-            throw await deserializeAws_json1_1LimitsExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitsExceededExceptionRes(parsedOutput, context);
         case "NoAssociatedRoleException":
         case "com.amazonaws.shield#NoAssociatedRoleException":
-            throw await deserializeAws_json1_1NoAssociatedRoleExceptionResponse(parsedOutput, context);
+            throw await de_NoAssociatedRoleExceptionRes(parsedOutput, context);
         case "OptimisticLockException":
         case "com.amazonaws.shield#OptimisticLockException":
-            throw await deserializeAws_json1_1OptimisticLockExceptionResponse(parsedOutput, context);
+            throw await de_OptimisticLockExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.shield#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -380,20 +380,20 @@ const deserializeAws_json1_1AssociateDRTLogBucketCommandError = async (output, c
             });
     }
 };
-export const deserializeAws_json1_1AssociateDRTRoleCommand = async (output, context) => {
+export const de_AssociateDRTRoleCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1AssociateDRTRoleCommandError(output, context);
+        return de_AssociateDRTRoleCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1AssociateDRTRoleResponse(data, context);
+    contents = de_AssociateDRTRoleResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1AssociateDRTRoleCommandError = async (output, context) => {
+const de_AssociateDRTRoleCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -402,22 +402,22 @@ const deserializeAws_json1_1AssociateDRTRoleCommandError = async (output, contex
     switch (errorCode) {
         case "AccessDeniedForDependencyException":
         case "com.amazonaws.shield#AccessDeniedForDependencyException":
-            throw await deserializeAws_json1_1AccessDeniedForDependencyExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedForDependencyExceptionRes(parsedOutput, context);
         case "InternalErrorException":
         case "com.amazonaws.shield#InternalErrorException":
-            throw await deserializeAws_json1_1InternalErrorExceptionResponse(parsedOutput, context);
+            throw await de_InternalErrorExceptionRes(parsedOutput, context);
         case "InvalidOperationException":
         case "com.amazonaws.shield#InvalidOperationException":
-            throw await deserializeAws_json1_1InvalidOperationExceptionResponse(parsedOutput, context);
+            throw await de_InvalidOperationExceptionRes(parsedOutput, context);
         case "InvalidParameterException":
         case "com.amazonaws.shield#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "OptimisticLockException":
         case "com.amazonaws.shield#OptimisticLockException":
-            throw await deserializeAws_json1_1OptimisticLockExceptionResponse(parsedOutput, context);
+            throw await de_OptimisticLockExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.shield#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -428,20 +428,20 @@ const deserializeAws_json1_1AssociateDRTRoleCommandError = async (output, contex
             });
     }
 };
-export const deserializeAws_json1_1AssociateHealthCheckCommand = async (output, context) => {
+export const de_AssociateHealthCheckCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1AssociateHealthCheckCommandError(output, context);
+        return de_AssociateHealthCheckCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1AssociateHealthCheckResponse(data, context);
+    contents = de_AssociateHealthCheckResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1AssociateHealthCheckCommandError = async (output, context) => {
+const de_AssociateHealthCheckCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -450,22 +450,22 @@ const deserializeAws_json1_1AssociateHealthCheckCommandError = async (output, co
     switch (errorCode) {
         case "InternalErrorException":
         case "com.amazonaws.shield#InternalErrorException":
-            throw await deserializeAws_json1_1InternalErrorExceptionResponse(parsedOutput, context);
+            throw await de_InternalErrorExceptionRes(parsedOutput, context);
         case "InvalidParameterException":
         case "com.amazonaws.shield#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "InvalidResourceException":
         case "com.amazonaws.shield#InvalidResourceException":
-            throw await deserializeAws_json1_1InvalidResourceExceptionResponse(parsedOutput, context);
+            throw await de_InvalidResourceExceptionRes(parsedOutput, context);
         case "LimitsExceededException":
         case "com.amazonaws.shield#LimitsExceededException":
-            throw await deserializeAws_json1_1LimitsExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitsExceededExceptionRes(parsedOutput, context);
         case "OptimisticLockException":
         case "com.amazonaws.shield#OptimisticLockException":
-            throw await deserializeAws_json1_1OptimisticLockExceptionResponse(parsedOutput, context);
+            throw await de_OptimisticLockExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.shield#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -476,20 +476,20 @@ const deserializeAws_json1_1AssociateHealthCheckCommandError = async (output, co
             });
     }
 };
-export const deserializeAws_json1_1AssociateProactiveEngagementDetailsCommand = async (output, context) => {
+export const de_AssociateProactiveEngagementDetailsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1AssociateProactiveEngagementDetailsCommandError(output, context);
+        return de_AssociateProactiveEngagementDetailsCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1AssociateProactiveEngagementDetailsResponse(data, context);
+    contents = de_AssociateProactiveEngagementDetailsResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1AssociateProactiveEngagementDetailsCommandError = async (output, context) => {
+const de_AssociateProactiveEngagementDetailsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -498,19 +498,19 @@ const deserializeAws_json1_1AssociateProactiveEngagementDetailsCommandError = as
     switch (errorCode) {
         case "InternalErrorException":
         case "com.amazonaws.shield#InternalErrorException":
-            throw await deserializeAws_json1_1InternalErrorExceptionResponse(parsedOutput, context);
+            throw await de_InternalErrorExceptionRes(parsedOutput, context);
         case "InvalidOperationException":
         case "com.amazonaws.shield#InvalidOperationException":
-            throw await deserializeAws_json1_1InvalidOperationExceptionResponse(parsedOutput, context);
+            throw await de_InvalidOperationExceptionRes(parsedOutput, context);
         case "InvalidParameterException":
         case "com.amazonaws.shield#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "OptimisticLockException":
         case "com.amazonaws.shield#OptimisticLockException":
-            throw await deserializeAws_json1_1OptimisticLockExceptionResponse(parsedOutput, context);
+            throw await de_OptimisticLockExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.shield#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -521,20 +521,20 @@ const deserializeAws_json1_1AssociateProactiveEngagementDetailsCommandError = as
             });
     }
 };
-export const deserializeAws_json1_1CreateProtectionCommand = async (output, context) => {
+export const de_CreateProtectionCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1CreateProtectionCommandError(output, context);
+        return de_CreateProtectionCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1CreateProtectionResponse(data, context);
+    contents = de_CreateProtectionResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1CreateProtectionCommandError = async (output, context) => {
+const de_CreateProtectionCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -543,28 +543,28 @@ const deserializeAws_json1_1CreateProtectionCommandError = async (output, contex
     switch (errorCode) {
         case "InternalErrorException":
         case "com.amazonaws.shield#InternalErrorException":
-            throw await deserializeAws_json1_1InternalErrorExceptionResponse(parsedOutput, context);
+            throw await de_InternalErrorExceptionRes(parsedOutput, context);
         case "InvalidOperationException":
         case "com.amazonaws.shield#InvalidOperationException":
-            throw await deserializeAws_json1_1InvalidOperationExceptionResponse(parsedOutput, context);
+            throw await de_InvalidOperationExceptionRes(parsedOutput, context);
         case "InvalidParameterException":
         case "com.amazonaws.shield#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "InvalidResourceException":
         case "com.amazonaws.shield#InvalidResourceException":
-            throw await deserializeAws_json1_1InvalidResourceExceptionResponse(parsedOutput, context);
+            throw await de_InvalidResourceExceptionRes(parsedOutput, context);
         case "LimitsExceededException":
         case "com.amazonaws.shield#LimitsExceededException":
-            throw await deserializeAws_json1_1LimitsExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitsExceededExceptionRes(parsedOutput, context);
         case "OptimisticLockException":
         case "com.amazonaws.shield#OptimisticLockException":
-            throw await deserializeAws_json1_1OptimisticLockExceptionResponse(parsedOutput, context);
+            throw await de_OptimisticLockExceptionRes(parsedOutput, context);
         case "ResourceAlreadyExistsException":
         case "com.amazonaws.shield#ResourceAlreadyExistsException":
-            throw await deserializeAws_json1_1ResourceAlreadyExistsExceptionResponse(parsedOutput, context);
+            throw await de_ResourceAlreadyExistsExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.shield#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -575,20 +575,20 @@ const deserializeAws_json1_1CreateProtectionCommandError = async (output, contex
             });
     }
 };
-export const deserializeAws_json1_1CreateProtectionGroupCommand = async (output, context) => {
+export const de_CreateProtectionGroupCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1CreateProtectionGroupCommandError(output, context);
+        return de_CreateProtectionGroupCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1CreateProtectionGroupResponse(data, context);
+    contents = de_CreateProtectionGroupResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1CreateProtectionGroupCommandError = async (output, context) => {
+const de_CreateProtectionGroupCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -597,22 +597,22 @@ const deserializeAws_json1_1CreateProtectionGroupCommandError = async (output, c
     switch (errorCode) {
         case "InternalErrorException":
         case "com.amazonaws.shield#InternalErrorException":
-            throw await deserializeAws_json1_1InternalErrorExceptionResponse(parsedOutput, context);
+            throw await de_InternalErrorExceptionRes(parsedOutput, context);
         case "InvalidParameterException":
         case "com.amazonaws.shield#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "LimitsExceededException":
         case "com.amazonaws.shield#LimitsExceededException":
-            throw await deserializeAws_json1_1LimitsExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitsExceededExceptionRes(parsedOutput, context);
         case "OptimisticLockException":
         case "com.amazonaws.shield#OptimisticLockException":
-            throw await deserializeAws_json1_1OptimisticLockExceptionResponse(parsedOutput, context);
+            throw await de_OptimisticLockExceptionRes(parsedOutput, context);
         case "ResourceAlreadyExistsException":
         case "com.amazonaws.shield#ResourceAlreadyExistsException":
-            throw await deserializeAws_json1_1ResourceAlreadyExistsExceptionResponse(parsedOutput, context);
+            throw await de_ResourceAlreadyExistsExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.shield#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -623,20 +623,20 @@ const deserializeAws_json1_1CreateProtectionGroupCommandError = async (output, c
             });
     }
 };
-export const deserializeAws_json1_1CreateSubscriptionCommand = async (output, context) => {
+export const de_CreateSubscriptionCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1CreateSubscriptionCommandError(output, context);
+        return de_CreateSubscriptionCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1CreateSubscriptionResponse(data, context);
+    contents = de_CreateSubscriptionResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1CreateSubscriptionCommandError = async (output, context) => {
+const de_CreateSubscriptionCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -645,10 +645,10 @@ const deserializeAws_json1_1CreateSubscriptionCommandError = async (output, cont
     switch (errorCode) {
         case "InternalErrorException":
         case "com.amazonaws.shield#InternalErrorException":
-            throw await deserializeAws_json1_1InternalErrorExceptionResponse(parsedOutput, context);
+            throw await de_InternalErrorExceptionRes(parsedOutput, context);
         case "ResourceAlreadyExistsException":
         case "com.amazonaws.shield#ResourceAlreadyExistsException":
-            throw await deserializeAws_json1_1ResourceAlreadyExistsExceptionResponse(parsedOutput, context);
+            throw await de_ResourceAlreadyExistsExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -659,20 +659,20 @@ const deserializeAws_json1_1CreateSubscriptionCommandError = async (output, cont
             });
     }
 };
-export const deserializeAws_json1_1DeleteProtectionCommand = async (output, context) => {
+export const de_DeleteProtectionCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1DeleteProtectionCommandError(output, context);
+        return de_DeleteProtectionCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1DeleteProtectionResponse(data, context);
+    contents = de_DeleteProtectionResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1DeleteProtectionCommandError = async (output, context) => {
+const de_DeleteProtectionCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -681,13 +681,13 @@ const deserializeAws_json1_1DeleteProtectionCommandError = async (output, contex
     switch (errorCode) {
         case "InternalErrorException":
         case "com.amazonaws.shield#InternalErrorException":
-            throw await deserializeAws_json1_1InternalErrorExceptionResponse(parsedOutput, context);
+            throw await de_InternalErrorExceptionRes(parsedOutput, context);
         case "OptimisticLockException":
         case "com.amazonaws.shield#OptimisticLockException":
-            throw await deserializeAws_json1_1OptimisticLockExceptionResponse(parsedOutput, context);
+            throw await de_OptimisticLockExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.shield#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -698,20 +698,20 @@ const deserializeAws_json1_1DeleteProtectionCommandError = async (output, contex
             });
     }
 };
-export const deserializeAws_json1_1DeleteProtectionGroupCommand = async (output, context) => {
+export const de_DeleteProtectionGroupCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1DeleteProtectionGroupCommandError(output, context);
+        return de_DeleteProtectionGroupCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1DeleteProtectionGroupResponse(data, context);
+    contents = de_DeleteProtectionGroupResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1DeleteProtectionGroupCommandError = async (output, context) => {
+const de_DeleteProtectionGroupCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -720,13 +720,13 @@ const deserializeAws_json1_1DeleteProtectionGroupCommandError = async (output, c
     switch (errorCode) {
         case "InternalErrorException":
         case "com.amazonaws.shield#InternalErrorException":
-            throw await deserializeAws_json1_1InternalErrorExceptionResponse(parsedOutput, context);
+            throw await de_InternalErrorExceptionRes(parsedOutput, context);
         case "OptimisticLockException":
         case "com.amazonaws.shield#OptimisticLockException":
-            throw await deserializeAws_json1_1OptimisticLockExceptionResponse(parsedOutput, context);
+            throw await de_OptimisticLockExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.shield#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -737,20 +737,20 @@ const deserializeAws_json1_1DeleteProtectionGroupCommandError = async (output, c
             });
     }
 };
-export const deserializeAws_json1_1DeleteSubscriptionCommand = async (output, context) => {
+export const de_DeleteSubscriptionCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1DeleteSubscriptionCommandError(output, context);
+        return de_DeleteSubscriptionCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1DeleteSubscriptionResponse(data, context);
+    contents = de_DeleteSubscriptionResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1DeleteSubscriptionCommandError = async (output, context) => {
+const de_DeleteSubscriptionCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -759,13 +759,13 @@ const deserializeAws_json1_1DeleteSubscriptionCommandError = async (output, cont
     switch (errorCode) {
         case "InternalErrorException":
         case "com.amazonaws.shield#InternalErrorException":
-            throw await deserializeAws_json1_1InternalErrorExceptionResponse(parsedOutput, context);
+            throw await de_InternalErrorExceptionRes(parsedOutput, context);
         case "LockedSubscriptionException":
         case "com.amazonaws.shield#LockedSubscriptionException":
-            throw await deserializeAws_json1_1LockedSubscriptionExceptionResponse(parsedOutput, context);
+            throw await de_LockedSubscriptionExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.shield#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -776,20 +776,20 @@ const deserializeAws_json1_1DeleteSubscriptionCommandError = async (output, cont
             });
     }
 };
-export const deserializeAws_json1_1DescribeAttackCommand = async (output, context) => {
+export const de_DescribeAttackCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1DescribeAttackCommandError(output, context);
+        return de_DescribeAttackCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1DescribeAttackResponse(data, context);
+    contents = de_DescribeAttackResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1DescribeAttackCommandError = async (output, context) => {
+const de_DescribeAttackCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -798,10 +798,10 @@ const deserializeAws_json1_1DescribeAttackCommandError = async (output, context)
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.shield#AccessDeniedException":
-            throw await deserializeAws_json1_1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "InternalErrorException":
         case "com.amazonaws.shield#InternalErrorException":
-            throw await deserializeAws_json1_1InternalErrorExceptionResponse(parsedOutput, context);
+            throw await de_InternalErrorExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -812,20 +812,20 @@ const deserializeAws_json1_1DescribeAttackCommandError = async (output, context)
             });
     }
 };
-export const deserializeAws_json1_1DescribeAttackStatisticsCommand = async (output, context) => {
+export const de_DescribeAttackStatisticsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1DescribeAttackStatisticsCommandError(output, context);
+        return de_DescribeAttackStatisticsCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1DescribeAttackStatisticsResponse(data, context);
+    contents = de_DescribeAttackStatisticsResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1DescribeAttackStatisticsCommandError = async (output, context) => {
+const de_DescribeAttackStatisticsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -834,7 +834,7 @@ const deserializeAws_json1_1DescribeAttackStatisticsCommandError = async (output
     switch (errorCode) {
         case "InternalErrorException":
         case "com.amazonaws.shield#InternalErrorException":
-            throw await deserializeAws_json1_1InternalErrorExceptionResponse(parsedOutput, context);
+            throw await de_InternalErrorExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -845,20 +845,20 @@ const deserializeAws_json1_1DescribeAttackStatisticsCommandError = async (output
             });
     }
 };
-export const deserializeAws_json1_1DescribeDRTAccessCommand = async (output, context) => {
+export const de_DescribeDRTAccessCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1DescribeDRTAccessCommandError(output, context);
+        return de_DescribeDRTAccessCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1DescribeDRTAccessResponse(data, context);
+    contents = de_DescribeDRTAccessResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1DescribeDRTAccessCommandError = async (output, context) => {
+const de_DescribeDRTAccessCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -867,10 +867,10 @@ const deserializeAws_json1_1DescribeDRTAccessCommandError = async (output, conte
     switch (errorCode) {
         case "InternalErrorException":
         case "com.amazonaws.shield#InternalErrorException":
-            throw await deserializeAws_json1_1InternalErrorExceptionResponse(parsedOutput, context);
+            throw await de_InternalErrorExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.shield#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -881,20 +881,20 @@ const deserializeAws_json1_1DescribeDRTAccessCommandError = async (output, conte
             });
     }
 };
-export const deserializeAws_json1_1DescribeEmergencyContactSettingsCommand = async (output, context) => {
+export const de_DescribeEmergencyContactSettingsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1DescribeEmergencyContactSettingsCommandError(output, context);
+        return de_DescribeEmergencyContactSettingsCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1DescribeEmergencyContactSettingsResponse(data, context);
+    contents = de_DescribeEmergencyContactSettingsResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1DescribeEmergencyContactSettingsCommandError = async (output, context) => {
+const de_DescribeEmergencyContactSettingsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -903,10 +903,10 @@ const deserializeAws_json1_1DescribeEmergencyContactSettingsCommandError = async
     switch (errorCode) {
         case "InternalErrorException":
         case "com.amazonaws.shield#InternalErrorException":
-            throw await deserializeAws_json1_1InternalErrorExceptionResponse(parsedOutput, context);
+            throw await de_InternalErrorExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.shield#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -917,20 +917,20 @@ const deserializeAws_json1_1DescribeEmergencyContactSettingsCommandError = async
             });
     }
 };
-export const deserializeAws_json1_1DescribeProtectionCommand = async (output, context) => {
+export const de_DescribeProtectionCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1DescribeProtectionCommandError(output, context);
+        return de_DescribeProtectionCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1DescribeProtectionResponse(data, context);
+    contents = de_DescribeProtectionResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1DescribeProtectionCommandError = async (output, context) => {
+const de_DescribeProtectionCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -939,13 +939,13 @@ const deserializeAws_json1_1DescribeProtectionCommandError = async (output, cont
     switch (errorCode) {
         case "InternalErrorException":
         case "com.amazonaws.shield#InternalErrorException":
-            throw await deserializeAws_json1_1InternalErrorExceptionResponse(parsedOutput, context);
+            throw await de_InternalErrorExceptionRes(parsedOutput, context);
         case "InvalidParameterException":
         case "com.amazonaws.shield#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.shield#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -956,20 +956,20 @@ const deserializeAws_json1_1DescribeProtectionCommandError = async (output, cont
             });
     }
 };
-export const deserializeAws_json1_1DescribeProtectionGroupCommand = async (output, context) => {
+export const de_DescribeProtectionGroupCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1DescribeProtectionGroupCommandError(output, context);
+        return de_DescribeProtectionGroupCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1DescribeProtectionGroupResponse(data, context);
+    contents = de_DescribeProtectionGroupResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1DescribeProtectionGroupCommandError = async (output, context) => {
+const de_DescribeProtectionGroupCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -978,10 +978,10 @@ const deserializeAws_json1_1DescribeProtectionGroupCommandError = async (output,
     switch (errorCode) {
         case "InternalErrorException":
         case "com.amazonaws.shield#InternalErrorException":
-            throw await deserializeAws_json1_1InternalErrorExceptionResponse(parsedOutput, context);
+            throw await de_InternalErrorExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.shield#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -992,20 +992,20 @@ const deserializeAws_json1_1DescribeProtectionGroupCommandError = async (output,
             });
     }
 };
-export const deserializeAws_json1_1DescribeSubscriptionCommand = async (output, context) => {
+export const de_DescribeSubscriptionCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1DescribeSubscriptionCommandError(output, context);
+        return de_DescribeSubscriptionCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1DescribeSubscriptionResponse(data, context);
+    contents = de_DescribeSubscriptionResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1DescribeSubscriptionCommandError = async (output, context) => {
+const de_DescribeSubscriptionCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1014,10 +1014,10 @@ const deserializeAws_json1_1DescribeSubscriptionCommandError = async (output, co
     switch (errorCode) {
         case "InternalErrorException":
         case "com.amazonaws.shield#InternalErrorException":
-            throw await deserializeAws_json1_1InternalErrorExceptionResponse(parsedOutput, context);
+            throw await de_InternalErrorExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.shield#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1028,20 +1028,20 @@ const deserializeAws_json1_1DescribeSubscriptionCommandError = async (output, co
             });
     }
 };
-export const deserializeAws_json1_1DisableApplicationLayerAutomaticResponseCommand = async (output, context) => {
+export const de_DisableApplicationLayerAutomaticResponseCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1DisableApplicationLayerAutomaticResponseCommandError(output, context);
+        return de_DisableApplicationLayerAutomaticResponseCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1DisableApplicationLayerAutomaticResponseResponse(data, context);
+    contents = de_DisableApplicationLayerAutomaticResponseResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1DisableApplicationLayerAutomaticResponseCommandError = async (output, context) => {
+const de_DisableApplicationLayerAutomaticResponseCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1050,19 +1050,19 @@ const deserializeAws_json1_1DisableApplicationLayerAutomaticResponseCommandError
     switch (errorCode) {
         case "InternalErrorException":
         case "com.amazonaws.shield#InternalErrorException":
-            throw await deserializeAws_json1_1InternalErrorExceptionResponse(parsedOutput, context);
+            throw await de_InternalErrorExceptionRes(parsedOutput, context);
         case "InvalidOperationException":
         case "com.amazonaws.shield#InvalidOperationException":
-            throw await deserializeAws_json1_1InvalidOperationExceptionResponse(parsedOutput, context);
+            throw await de_InvalidOperationExceptionRes(parsedOutput, context);
         case "InvalidParameterException":
         case "com.amazonaws.shield#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "OptimisticLockException":
         case "com.amazonaws.shield#OptimisticLockException":
-            throw await deserializeAws_json1_1OptimisticLockExceptionResponse(parsedOutput, context);
+            throw await de_OptimisticLockExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.shield#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1073,20 +1073,20 @@ const deserializeAws_json1_1DisableApplicationLayerAutomaticResponseCommandError
             });
     }
 };
-export const deserializeAws_json1_1DisableProactiveEngagementCommand = async (output, context) => {
+export const de_DisableProactiveEngagementCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1DisableProactiveEngagementCommandError(output, context);
+        return de_DisableProactiveEngagementCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1DisableProactiveEngagementResponse(data, context);
+    contents = de_DisableProactiveEngagementResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1DisableProactiveEngagementCommandError = async (output, context) => {
+const de_DisableProactiveEngagementCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1095,19 +1095,19 @@ const deserializeAws_json1_1DisableProactiveEngagementCommandError = async (outp
     switch (errorCode) {
         case "InternalErrorException":
         case "com.amazonaws.shield#InternalErrorException":
-            throw await deserializeAws_json1_1InternalErrorExceptionResponse(parsedOutput, context);
+            throw await de_InternalErrorExceptionRes(parsedOutput, context);
         case "InvalidOperationException":
         case "com.amazonaws.shield#InvalidOperationException":
-            throw await deserializeAws_json1_1InvalidOperationExceptionResponse(parsedOutput, context);
+            throw await de_InvalidOperationExceptionRes(parsedOutput, context);
         case "InvalidParameterException":
         case "com.amazonaws.shield#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "OptimisticLockException":
         case "com.amazonaws.shield#OptimisticLockException":
-            throw await deserializeAws_json1_1OptimisticLockExceptionResponse(parsedOutput, context);
+            throw await de_OptimisticLockExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.shield#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1118,20 +1118,20 @@ const deserializeAws_json1_1DisableProactiveEngagementCommandError = async (outp
             });
     }
 };
-export const deserializeAws_json1_1DisassociateDRTLogBucketCommand = async (output, context) => {
+export const de_DisassociateDRTLogBucketCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1DisassociateDRTLogBucketCommandError(output, context);
+        return de_DisassociateDRTLogBucketCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1DisassociateDRTLogBucketResponse(data, context);
+    contents = de_DisassociateDRTLogBucketResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1DisassociateDRTLogBucketCommandError = async (output, context) => {
+const de_DisassociateDRTLogBucketCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1140,22 +1140,22 @@ const deserializeAws_json1_1DisassociateDRTLogBucketCommandError = async (output
     switch (errorCode) {
         case "AccessDeniedForDependencyException":
         case "com.amazonaws.shield#AccessDeniedForDependencyException":
-            throw await deserializeAws_json1_1AccessDeniedForDependencyExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedForDependencyExceptionRes(parsedOutput, context);
         case "InternalErrorException":
         case "com.amazonaws.shield#InternalErrorException":
-            throw await deserializeAws_json1_1InternalErrorExceptionResponse(parsedOutput, context);
+            throw await de_InternalErrorExceptionRes(parsedOutput, context);
         case "InvalidOperationException":
         case "com.amazonaws.shield#InvalidOperationException":
-            throw await deserializeAws_json1_1InvalidOperationExceptionResponse(parsedOutput, context);
+            throw await de_InvalidOperationExceptionRes(parsedOutput, context);
         case "NoAssociatedRoleException":
         case "com.amazonaws.shield#NoAssociatedRoleException":
-            throw await deserializeAws_json1_1NoAssociatedRoleExceptionResponse(parsedOutput, context);
+            throw await de_NoAssociatedRoleExceptionRes(parsedOutput, context);
         case "OptimisticLockException":
         case "com.amazonaws.shield#OptimisticLockException":
-            throw await deserializeAws_json1_1OptimisticLockExceptionResponse(parsedOutput, context);
+            throw await de_OptimisticLockExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.shield#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1166,20 +1166,20 @@ const deserializeAws_json1_1DisassociateDRTLogBucketCommandError = async (output
             });
     }
 };
-export const deserializeAws_json1_1DisassociateDRTRoleCommand = async (output, context) => {
+export const de_DisassociateDRTRoleCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1DisassociateDRTRoleCommandError(output, context);
+        return de_DisassociateDRTRoleCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1DisassociateDRTRoleResponse(data, context);
+    contents = de_DisassociateDRTRoleResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1DisassociateDRTRoleCommandError = async (output, context) => {
+const de_DisassociateDRTRoleCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1188,16 +1188,16 @@ const deserializeAws_json1_1DisassociateDRTRoleCommandError = async (output, con
     switch (errorCode) {
         case "InternalErrorException":
         case "com.amazonaws.shield#InternalErrorException":
-            throw await deserializeAws_json1_1InternalErrorExceptionResponse(parsedOutput, context);
+            throw await de_InternalErrorExceptionRes(parsedOutput, context);
         case "InvalidOperationException":
         case "com.amazonaws.shield#InvalidOperationException":
-            throw await deserializeAws_json1_1InvalidOperationExceptionResponse(parsedOutput, context);
+            throw await de_InvalidOperationExceptionRes(parsedOutput, context);
         case "OptimisticLockException":
         case "com.amazonaws.shield#OptimisticLockException":
-            throw await deserializeAws_json1_1OptimisticLockExceptionResponse(parsedOutput, context);
+            throw await de_OptimisticLockExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.shield#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1208,20 +1208,20 @@ const deserializeAws_json1_1DisassociateDRTRoleCommandError = async (output, con
             });
     }
 };
-export const deserializeAws_json1_1DisassociateHealthCheckCommand = async (output, context) => {
+export const de_DisassociateHealthCheckCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1DisassociateHealthCheckCommandError(output, context);
+        return de_DisassociateHealthCheckCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1DisassociateHealthCheckResponse(data, context);
+    contents = de_DisassociateHealthCheckResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1DisassociateHealthCheckCommandError = async (output, context) => {
+const de_DisassociateHealthCheckCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1230,19 +1230,19 @@ const deserializeAws_json1_1DisassociateHealthCheckCommandError = async (output,
     switch (errorCode) {
         case "InternalErrorException":
         case "com.amazonaws.shield#InternalErrorException":
-            throw await deserializeAws_json1_1InternalErrorExceptionResponse(parsedOutput, context);
+            throw await de_InternalErrorExceptionRes(parsedOutput, context);
         case "InvalidParameterException":
         case "com.amazonaws.shield#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "InvalidResourceException":
         case "com.amazonaws.shield#InvalidResourceException":
-            throw await deserializeAws_json1_1InvalidResourceExceptionResponse(parsedOutput, context);
+            throw await de_InvalidResourceExceptionRes(parsedOutput, context);
         case "OptimisticLockException":
         case "com.amazonaws.shield#OptimisticLockException":
-            throw await deserializeAws_json1_1OptimisticLockExceptionResponse(parsedOutput, context);
+            throw await de_OptimisticLockExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.shield#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1253,20 +1253,20 @@ const deserializeAws_json1_1DisassociateHealthCheckCommandError = async (output,
             });
     }
 };
-export const deserializeAws_json1_1EnableApplicationLayerAutomaticResponseCommand = async (output, context) => {
+export const de_EnableApplicationLayerAutomaticResponseCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1EnableApplicationLayerAutomaticResponseCommandError(output, context);
+        return de_EnableApplicationLayerAutomaticResponseCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1EnableApplicationLayerAutomaticResponseResponse(data, context);
+    contents = de_EnableApplicationLayerAutomaticResponseResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1EnableApplicationLayerAutomaticResponseCommandError = async (output, context) => {
+const de_EnableApplicationLayerAutomaticResponseCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1275,22 +1275,22 @@ const deserializeAws_json1_1EnableApplicationLayerAutomaticResponseCommandError
     switch (errorCode) {
         case "InternalErrorException":
         case "com.amazonaws.shield#InternalErrorException":
-            throw await deserializeAws_json1_1InternalErrorExceptionResponse(parsedOutput, context);
+            throw await de_InternalErrorExceptionRes(parsedOutput, context);
         case "InvalidOperationException":
         case "com.amazonaws.shield#InvalidOperationException":
-            throw await deserializeAws_json1_1InvalidOperationExceptionResponse(parsedOutput, context);
+            throw await de_InvalidOperationExceptionRes(parsedOutput, context);
         case "InvalidParameterException":
         case "com.amazonaws.shield#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "LimitsExceededException":
         case "com.amazonaws.shield#LimitsExceededException":
-            throw await deserializeAws_json1_1LimitsExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitsExceededExceptionRes(parsedOutput, context);
         case "OptimisticLockException":
         case "com.amazonaws.shield#OptimisticLockException":
-            throw await deserializeAws_json1_1OptimisticLockExceptionResponse(parsedOutput, context);
+            throw await de_OptimisticLockExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.shield#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1301,20 +1301,20 @@ const deserializeAws_json1_1EnableApplicationLayerAutomaticResponseCommandError
             });
     }
 };
-export const deserializeAws_json1_1EnableProactiveEngagementCommand = async (output, context) => {
+export const de_EnableProactiveEngagementCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1EnableProactiveEngagementCommandError(output, context);
+        return de_EnableProactiveEngagementCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1EnableProactiveEngagementResponse(data, context);
+    contents = de_EnableProactiveEngagementResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1EnableProactiveEngagementCommandError = async (output, context) => {
+const de_EnableProactiveEngagementCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1323,19 +1323,19 @@ const deserializeAws_json1_1EnableProactiveEngagementCommandError = async (outpu
     switch (errorCode) {
         case "InternalErrorException":
         case "com.amazonaws.shield#InternalErrorException":
-            throw await deserializeAws_json1_1InternalErrorExceptionResponse(parsedOutput, context);
+            throw await de_InternalErrorExceptionRes(parsedOutput, context);
         case "InvalidOperationException":
         case "com.amazonaws.shield#InvalidOperationException":
-            throw await deserializeAws_json1_1InvalidOperationExceptionResponse(parsedOutput, context);
+            throw await de_InvalidOperationExceptionRes(parsedOutput, context);
         case "InvalidParameterException":
         case "com.amazonaws.shield#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "OptimisticLockException":
         case "com.amazonaws.shield#OptimisticLockException":
-            throw await deserializeAws_json1_1OptimisticLockExceptionResponse(parsedOutput, context);
+            throw await de_OptimisticLockExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.shield#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1346,20 +1346,20 @@ const deserializeAws_json1_1EnableProactiveEngagementCommandError = async (outpu
             });
     }
 };
-export const deserializeAws_json1_1GetSubscriptionStateCommand = async (output, context) => {
+export const de_GetSubscriptionStateCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1GetSubscriptionStateCommandError(output, context);
+        return de_GetSubscriptionStateCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1GetSubscriptionStateResponse(data, context);
+    contents = de_GetSubscriptionStateResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1GetSubscriptionStateCommandError = async (output, context) => {
+const de_GetSubscriptionStateCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1368,7 +1368,7 @@ const deserializeAws_json1_1GetSubscriptionStateCommandError = async (output, co
     switch (errorCode) {
         case "InternalErrorException":
         case "com.amazonaws.shield#InternalErrorException":
-            throw await deserializeAws_json1_1InternalErrorExceptionResponse(parsedOutput, context);
+            throw await de_InternalErrorExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1379,20 +1379,20 @@ const deserializeAws_json1_1GetSubscriptionStateCommandError = async (output, co
             });
     }
 };
-export const deserializeAws_json1_1ListAttacksCommand = async (output, context) => {
+export const de_ListAttacksCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1ListAttacksCommandError(output, context);
+        return de_ListAttacksCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1ListAttacksResponse(data, context);
+    contents = de_ListAttacksResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1ListAttacksCommandError = async (output, context) => {
+const de_ListAttacksCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1401,13 +1401,13 @@ const deserializeAws_json1_1ListAttacksCommandError = async (output, context) =>
     switch (errorCode) {
         case "InternalErrorException":
         case "com.amazonaws.shield#InternalErrorException":
-            throw await deserializeAws_json1_1InternalErrorExceptionResponse(parsedOutput, context);
+            throw await de_InternalErrorExceptionRes(parsedOutput, context);
         case "InvalidOperationException":
         case "com.amazonaws.shield#InvalidOperationException":
-            throw await deserializeAws_json1_1InvalidOperationExceptionResponse(parsedOutput, context);
+            throw await de_InvalidOperationExceptionRes(parsedOutput, context);
         case "InvalidParameterException":
         case "com.amazonaws.shield#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1418,20 +1418,20 @@ const deserializeAws_json1_1ListAttacksCommandError = async (output, context) =>
             });
     }
 };
-export const deserializeAws_json1_1ListProtectionGroupsCommand = async (output, context) => {
+export const de_ListProtectionGroupsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1ListProtectionGroupsCommandError(output, context);
+        return de_ListProtectionGroupsCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1ListProtectionGroupsResponse(data, context);
+    contents = de_ListProtectionGroupsResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1ListProtectionGroupsCommandError = async (output, context) => {
+const de_ListProtectionGroupsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1440,13 +1440,13 @@ const deserializeAws_json1_1ListProtectionGroupsCommandError = async (output, co
     switch (errorCode) {
         case "InternalErrorException":
         case "com.amazonaws.shield#InternalErrorException":
-            throw await deserializeAws_json1_1InternalErrorExceptionResponse(parsedOutput, context);
+            throw await de_InternalErrorExceptionRes(parsedOutput, context);
         case "InvalidPaginationTokenException":
         case "com.amazonaws.shield#InvalidPaginationTokenException":
-            throw await deserializeAws_json1_1InvalidPaginationTokenExceptionResponse(parsedOutput, context);
+            throw await de_InvalidPaginationTokenExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.shield#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1457,20 +1457,20 @@ const deserializeAws_json1_1ListProtectionGroupsCommandError = async (output, co
             });
     }
 };
-export const deserializeAws_json1_1ListProtectionsCommand = async (output, context) => {
+export const de_ListProtectionsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1ListProtectionsCommandError(output, context);
+        return de_ListProtectionsCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1ListProtectionsResponse(data, context);
+    contents = de_ListProtectionsResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1ListProtectionsCommandError = async (output, context) => {
+const de_ListProtectionsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1479,13 +1479,13 @@ const deserializeAws_json1_1ListProtectionsCommandError = async (output, context
     switch (errorCode) {
         case "InternalErrorException":
         case "com.amazonaws.shield#InternalErrorException":
-            throw await deserializeAws_json1_1InternalErrorExceptionResponse(parsedOutput, context);
+            throw await de_InternalErrorExceptionRes(parsedOutput, context);
         case "InvalidPaginationTokenException":
         case "com.amazonaws.shield#InvalidPaginationTokenException":
-            throw await deserializeAws_json1_1InvalidPaginationTokenExceptionResponse(parsedOutput, context);
+            throw await de_InvalidPaginationTokenExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.shield#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1496,20 +1496,20 @@ const deserializeAws_json1_1ListProtectionsCommandError = async (output, context
             });
     }
 };
-export const deserializeAws_json1_1ListResourcesInProtectionGroupCommand = async (output, context) => {
+export const de_ListResourcesInProtectionGroupCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1ListResourcesInProtectionGroupCommandError(output, context);
+        return de_ListResourcesInProtectionGroupCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1ListResourcesInProtectionGroupResponse(data, context);
+    contents = de_ListResourcesInProtectionGroupResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1ListResourcesInProtectionGroupCommandError = async (output, context) => {
+const de_ListResourcesInProtectionGroupCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1518,13 +1518,13 @@ const deserializeAws_json1_1ListResourcesInProtectionGroupCommandError = async (
     switch (errorCode) {
         case "InternalErrorException":
         case "com.amazonaws.shield#InternalErrorException":
-            throw await deserializeAws_json1_1InternalErrorExceptionResponse(parsedOutput, context);
+            throw await de_InternalErrorExceptionRes(parsedOutput, context);
         case "InvalidPaginationTokenException":
         case "com.amazonaws.shield#InvalidPaginationTokenException":
-            throw await deserializeAws_json1_1InvalidPaginationTokenExceptionResponse(parsedOutput, context);
+            throw await de_InvalidPaginationTokenExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.shield#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1535,20 +1535,20 @@ const deserializeAws_json1_1ListResourcesInProtectionGroupCommandError = async (
             });
     }
 };
-export const deserializeAws_json1_1ListTagsForResourceCommand = async (output, context) => {
+export const de_ListTagsForResourceCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1ListTagsForResourceCommandError(output, context);
+        return de_ListTagsForResourceCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1ListTagsForResourceResponse(data, context);
+    contents = de_ListTagsForResourceResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1ListTagsForResourceCommandError = async (output, context) => {
+const de_ListTagsForResourceCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1557,13 +1557,13 @@ const deserializeAws_json1_1ListTagsForResourceCommandError = async (output, con
     switch (errorCode) {
         case "InternalErrorException":
         case "com.amazonaws.shield#InternalErrorException":
-            throw await deserializeAws_json1_1InternalErrorExceptionResponse(parsedOutput, context);
+            throw await de_InternalErrorExceptionRes(parsedOutput, context);
         case "InvalidResourceException":
         case "com.amazonaws.shield#InvalidResourceException":
-            throw await deserializeAws_json1_1InvalidResourceExceptionResponse(parsedOutput, context);
+            throw await de_InvalidResourceExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.shield#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1574,20 +1574,20 @@ const deserializeAws_json1_1ListTagsForResourceCommandError = async (output, con
             });
     }
 };
-export const deserializeAws_json1_1TagResourceCommand = async (output, context) => {
+export const de_TagResourceCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1TagResourceCommandError(output, context);
+        return de_TagResourceCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1TagResourceResponse(data, context);
+    contents = de_TagResourceResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1TagResourceCommandError = async (output, context) => {
+const de_TagResourceCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1596,16 +1596,16 @@ const deserializeAws_json1_1TagResourceCommandError = async (output, context) =>
     switch (errorCode) {
         case "InternalErrorException":
         case "com.amazonaws.shield#InternalErrorException":
-            throw await deserializeAws_json1_1InternalErrorExceptionResponse(parsedOutput, context);
+            throw await de_InternalErrorExceptionRes(parsedOutput, context);
         case "InvalidParameterException":
         case "com.amazonaws.shield#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "InvalidResourceException":
         case "com.amazonaws.shield#InvalidResourceException":
-            throw await deserializeAws_json1_1InvalidResourceExceptionResponse(parsedOutput, context);
+            throw await de_InvalidResourceExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.shield#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1616,20 +1616,20 @@ const deserializeAws_json1_1TagResourceCommandError = async (output, context) =>
             });
     }
 };
-export const deserializeAws_json1_1UntagResourceCommand = async (output, context) => {
+export const de_UntagResourceCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1UntagResourceCommandError(output, context);
+        return de_UntagResourceCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1UntagResourceResponse(data, context);
+    contents = de_UntagResourceResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1UntagResourceCommandError = async (output, context) => {
+const de_UntagResourceCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1638,16 +1638,16 @@ const deserializeAws_json1_1UntagResourceCommandError = async (output, context)
     switch (errorCode) {
         case "InternalErrorException":
         case "com.amazonaws.shield#InternalErrorException":
-            throw await deserializeAws_json1_1InternalErrorExceptionResponse(parsedOutput, context);
+            throw await de_InternalErrorExceptionRes(parsedOutput, context);
         case "InvalidParameterException":
         case "com.amazonaws.shield#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "InvalidResourceException":
         case "com.amazonaws.shield#InvalidResourceException":
-            throw await deserializeAws_json1_1InvalidResourceExceptionResponse(parsedOutput, context);
+            throw await de_InvalidResourceExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.shield#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1658,20 +1658,20 @@ const deserializeAws_json1_1UntagResourceCommandError = async (output, context)
             });
     }
 };
-export const deserializeAws_json1_1UpdateApplicationLayerAutomaticResponseCommand = async (output, context) => {
+export const de_UpdateApplicationLayerAutomaticResponseCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1UpdateApplicationLayerAutomaticResponseCommandError(output, context);
+        return de_UpdateApplicationLayerAutomaticResponseCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1UpdateApplicationLayerAutomaticResponseResponse(data, context);
+    contents = de_UpdateApplicationLayerAutomaticResponseResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1UpdateApplicationLayerAutomaticResponseCommandError = async (output, context) => {
+const de_UpdateApplicationLayerAutomaticResponseCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1680,19 +1680,19 @@ const deserializeAws_json1_1UpdateApplicationLayerAutomaticResponseCommandError
     switch (errorCode) {
         case "InternalErrorException":
         case "com.amazonaws.shield#InternalErrorException":
-            throw await deserializeAws_json1_1InternalErrorExceptionResponse(parsedOutput, context);
+            throw await de_InternalErrorExceptionRes(parsedOutput, context);
         case "InvalidOperationException":
         case "com.amazonaws.shield#InvalidOperationException":
-            throw await deserializeAws_json1_1InvalidOperationExceptionResponse(parsedOutput, context);
+            throw await de_InvalidOperationExceptionRes(parsedOutput, context);
         case "InvalidParameterException":
         case "com.amazonaws.shield#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "OptimisticLockException":
         case "com.amazonaws.shield#OptimisticLockException":
-            throw await deserializeAws_json1_1OptimisticLockExceptionResponse(parsedOutput, context);
+            throw await de_OptimisticLockExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.shield#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1703,20 +1703,20 @@ const deserializeAws_json1_1UpdateApplicationLayerAutomaticResponseCommandError
             });
     }
 };
-export const deserializeAws_json1_1UpdateEmergencyContactSettingsCommand = async (output, context) => {
+export const de_UpdateEmergencyContactSettingsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1UpdateEmergencyContactSettingsCommandError(output, context);
+        return de_UpdateEmergencyContactSettingsCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1UpdateEmergencyContactSettingsResponse(data, context);
+    contents = de_UpdateEmergencyContactSettingsResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1UpdateEmergencyContactSettingsCommandError = async (output, context) => {
+const de_UpdateEmergencyContactSettingsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1725,16 +1725,16 @@ const deserializeAws_json1_1UpdateEmergencyContactSettingsCommandError = async (
     switch (errorCode) {
         case "InternalErrorException":
         case "com.amazonaws.shield#InternalErrorException":
-            throw await deserializeAws_json1_1InternalErrorExceptionResponse(parsedOutput, context);
+            throw await de_InternalErrorExceptionRes(parsedOutput, context);
         case "InvalidParameterException":
         case "com.amazonaws.shield#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "OptimisticLockException":
         case "com.amazonaws.shield#OptimisticLockException":
-            throw await deserializeAws_json1_1OptimisticLockExceptionResponse(parsedOutput, context);
+            throw await de_OptimisticLockExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.shield#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1745,20 +1745,20 @@ const deserializeAws_json1_1UpdateEmergencyContactSettingsCommandError = async (
             });
     }
 };
-export const deserializeAws_json1_1UpdateProtectionGroupCommand = async (output, context) => {
+export const de_UpdateProtectionGroupCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1UpdateProtectionGroupCommandError(output, context);
+        return de_UpdateProtectionGroupCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1UpdateProtectionGroupResponse(data, context);
+    contents = de_UpdateProtectionGroupResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1UpdateProtectionGroupCommandError = async (output, context) => {
+const de_UpdateProtectionGroupCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1767,16 +1767,16 @@ const deserializeAws_json1_1UpdateProtectionGroupCommandError = async (output, c
     switch (errorCode) {
         case "InternalErrorException":
         case "com.amazonaws.shield#InternalErrorException":
-            throw await deserializeAws_json1_1InternalErrorExceptionResponse(parsedOutput, context);
+            throw await de_InternalErrorExceptionRes(parsedOutput, context);
         case "InvalidParameterException":
         case "com.amazonaws.shield#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "OptimisticLockException":
         case "com.amazonaws.shield#OptimisticLockException":
-            throw await deserializeAws_json1_1OptimisticLockExceptionResponse(parsedOutput, context);
+            throw await de_OptimisticLockExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.shield#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1787,20 +1787,20 @@ const deserializeAws_json1_1UpdateProtectionGroupCommandError = async (output, c
             });
     }
 };
-export const deserializeAws_json1_1UpdateSubscriptionCommand = async (output, context) => {
+export const de_UpdateSubscriptionCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1UpdateSubscriptionCommandError(output, context);
+        return de_UpdateSubscriptionCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1UpdateSubscriptionResponse(data, context);
+    contents = de_UpdateSubscriptionResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1UpdateSubscriptionCommandError = async (output, context) => {
+const de_UpdateSubscriptionCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1809,19 +1809,19 @@ const deserializeAws_json1_1UpdateSubscriptionCommandError = async (output, cont
     switch (errorCode) {
         case "InternalErrorException":
         case "com.amazonaws.shield#InternalErrorException":
-            throw await deserializeAws_json1_1InternalErrorExceptionResponse(parsedOutput, context);
+            throw await de_InternalErrorExceptionRes(parsedOutput, context);
         case "InvalidParameterException":
         case "com.amazonaws.shield#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "LockedSubscriptionException":
         case "com.amazonaws.shield#LockedSubscriptionException":
-            throw await deserializeAws_json1_1LockedSubscriptionExceptionResponse(parsedOutput, context);
+            throw await de_LockedSubscriptionExceptionRes(parsedOutput, context);
         case "OptimisticLockException":
         case "com.amazonaws.shield#OptimisticLockException":
-            throw await deserializeAws_json1_1OptimisticLockExceptionResponse(parsedOutput, context);
+            throw await de_OptimisticLockExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.shield#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1832,717 +1832,689 @@ const deserializeAws_json1_1UpdateSubscriptionCommandError = async (output, cont
             });
     }
 };
-const deserializeAws_json1_1AccessDeniedExceptionResponse = async (parsedOutput, context) => {
+const de_AccessDeniedExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_1AccessDeniedException(body, context);
+    const deserialized = de_AccessDeniedException(body, context);
     const exception = new AccessDeniedException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_json1_1AccessDeniedForDependencyExceptionResponse = async (parsedOutput, context) => {
+const de_AccessDeniedForDependencyExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_1AccessDeniedForDependencyException(body, context);
+    const deserialized = de_AccessDeniedForDependencyException(body, context);
     const exception = new AccessDeniedForDependencyException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_json1_1InternalErrorExceptionResponse = async (parsedOutput, context) => {
+const de_InternalErrorExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_1InternalErrorException(body, context);
+    const deserialized = de_InternalErrorException(body, context);
     const exception = new InternalErrorException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_json1_1InvalidOperationExceptionResponse = async (parsedOutput, context) => {
+const de_InvalidOperationExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_1InvalidOperationException(body, context);
+    const deserialized = de_InvalidOperationException(body, context);
     const exception = new InvalidOperationException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_json1_1InvalidPaginationTokenExceptionResponse = async (parsedOutput, context) => {
+const de_InvalidPaginationTokenExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_1InvalidPaginationTokenException(body, context);
+    const deserialized = de_InvalidPaginationTokenException(body, context);
     const exception = new InvalidPaginationTokenException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_json1_1InvalidParameterExceptionResponse = async (parsedOutput, context) => {
+const de_InvalidParameterExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_1InvalidParameterException(body, context);
+    const deserialized = de_InvalidParameterException(body, context);
     const exception = new InvalidParameterException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_json1_1InvalidResourceExceptionResponse = async (parsedOutput, context) => {
+const de_InvalidResourceExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_1InvalidResourceException(body, context);
+    const deserialized = de_InvalidResourceException(body, context);
     const exception = new InvalidResourceException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_json1_1LimitsExceededExceptionResponse = async (parsedOutput, context) => {
+const de_LimitsExceededExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_1LimitsExceededException(body, context);
+    const deserialized = de_LimitsExceededException(body, context);
     const exception = new LimitsExceededException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_json1_1LockedSubscriptionExceptionResponse = async (parsedOutput, context) => {
+const de_LockedSubscriptionExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_1LockedSubscriptionException(body, context);
+    const deserialized = de_LockedSubscriptionException(body, context);
     const exception = new LockedSubscriptionException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_json1_1NoAssociatedRoleExceptionResponse = async (parsedOutput, context) => {
+const de_NoAssociatedRoleExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_1NoAssociatedRoleException(body, context);
+    const deserialized = de_NoAssociatedRoleException(body, context);
     const exception = new NoAssociatedRoleException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_json1_1OptimisticLockExceptionResponse = async (parsedOutput, context) => {
+const de_OptimisticLockExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_1OptimisticLockException(body, context);
+    const deserialized = de_OptimisticLockException(body, context);
     const exception = new OptimisticLockException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_json1_1ResourceAlreadyExistsExceptionResponse = async (parsedOutput, context) => {
+const de_ResourceAlreadyExistsExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_1ResourceAlreadyExistsException(body, context);
+    const deserialized = de_ResourceAlreadyExistsException(body, context);
     const exception = new ResourceAlreadyExistsException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_json1_1ResourceNotFoundExceptionResponse = async (parsedOutput, context) => {
+const de_ResourceNotFoundExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_1ResourceNotFoundException(body, context);
+    const deserialized = de_ResourceNotFoundException(body, context);
     const exception = new ResourceNotFoundException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const serializeAws_json1_1AssociateDRTLogBucketRequest = (input, context) => {
+const se_AssociateDRTLogBucketRequest = (input, context) => {
     return {
         ...(input.LogBucket != null && { LogBucket: input.LogBucket }),
     };
 };
-const serializeAws_json1_1AssociateDRTRoleRequest = (input, context) => {
+const se_AssociateDRTRoleRequest = (input, context) => {
     return {
         ...(input.RoleArn != null && { RoleArn: input.RoleArn }),
     };
 };
-const serializeAws_json1_1AssociateHealthCheckRequest = (input, context) => {
+const se_AssociateHealthCheckRequest = (input, context) => {
     return {
         ...(input.HealthCheckArn != null && { HealthCheckArn: input.HealthCheckArn }),
         ...(input.ProtectionId != null && { ProtectionId: input.ProtectionId }),
     };
 };
-const serializeAws_json1_1AssociateProactiveEngagementDetailsRequest = (input, context) => {
+const se_AssociateProactiveEngagementDetailsRequest = (input, context) => {
     return {
         ...(input.EmergencyContactList != null && {
-            EmergencyContactList: serializeAws_json1_1EmergencyContactList(input.EmergencyContactList, context),
+            EmergencyContactList: se_EmergencyContactList(input.EmergencyContactList, context),
         }),
     };
 };
-const serializeAws_json1_1BlockAction = (input, context) => {
+const se_BlockAction = (input, context) => {
     return {};
 };
-const serializeAws_json1_1CountAction = (input, context) => {
+const se_CountAction = (input, context) => {
     return {};
 };
-const serializeAws_json1_1CreateProtectionGroupRequest = (input, context) => {
+const se_CreateProtectionGroupRequest = (input, context) => {
     return {
         ...(input.Aggregation != null && { Aggregation: input.Aggregation }),
-        ...(input.Members != null && { Members: serializeAws_json1_1ProtectionGroupMembers(input.Members, context) }),
+        ...(input.Members != null && { Members: se_ProtectionGroupMembers(input.Members, context) }),
         ...(input.Pattern != null && { Pattern: input.Pattern }),
         ...(input.ProtectionGroupId != null && { ProtectionGroupId: input.ProtectionGroupId }),
         ...(input.ResourceType != null && { ResourceType: input.ResourceType }),
-        ...(input.Tags != null && { Tags: serializeAws_json1_1TagList(input.Tags, context) }),
+        ...(input.Tags != null && { Tags: se_TagList(input.Tags, context) }),
     };
 };
-const serializeAws_json1_1CreateProtectionRequest = (input, context) => {
+const se_CreateProtectionRequest = (input, context) => {
     return {
         ...(input.Name != null && { Name: input.Name }),
         ...(input.ResourceArn != null && { ResourceArn: input.ResourceArn }),
-        ...(input.Tags != null && { Tags: serializeAws_json1_1TagList(input.Tags, context) }),
+        ...(input.Tags != null && { Tags: se_TagList(input.Tags, context) }),
     };
 };
-const serializeAws_json1_1CreateSubscriptionRequest = (input, context) => {
+const se_CreateSubscriptionRequest = (input, context) => {
     return {};
 };
-const serializeAws_json1_1DeleteProtectionGroupRequest = (input, context) => {
+const se_DeleteProtectionGroupRequest = (input, context) => {
     return {
         ...(input.ProtectionGroupId != null && { ProtectionGroupId: input.ProtectionGroupId }),
     };
 };
-const serializeAws_json1_1DeleteProtectionRequest = (input, context) => {
+const se_DeleteProtectionRequest = (input, context) => {
     return {
         ...(input.ProtectionId != null && { ProtectionId: input.ProtectionId }),
     };
 };
-const serializeAws_json1_1DeleteSubscriptionRequest = (input, context) => {
+const se_DeleteSubscriptionRequest = (input, context) => {
     return {};
 };
-const serializeAws_json1_1DescribeAttackRequest = (input, context) => {
+const se_DescribeAttackRequest = (input, context) => {
     return {
         ...(input.AttackId != null && { AttackId: input.AttackId }),
     };
 };
-const serializeAws_json1_1DescribeAttackStatisticsRequest = (input, context) => {
+const se_DescribeAttackStatisticsRequest = (input, context) => {
     return {};
 };
-const serializeAws_json1_1DescribeDRTAccessRequest = (input, context) => {
+const se_DescribeDRTAccessRequest = (input, context) => {
     return {};
 };
-const serializeAws_json1_1DescribeEmergencyContactSettingsRequest = (input, context) => {
+const se_DescribeEmergencyContactSettingsRequest = (input, context) => {
     return {};
 };
-const serializeAws_json1_1DescribeProtectionGroupRequest = (input, context) => {
+const se_DescribeProtectionGroupRequest = (input, context) => {
     return {
         ...(input.ProtectionGroupId != null && { ProtectionGroupId: input.ProtectionGroupId }),
     };
 };
-const serializeAws_json1_1DescribeProtectionRequest = (input, context) => {
+const se_DescribeProtectionRequest = (input, context) => {
     return {
         ...(input.ProtectionId != null && { ProtectionId: input.ProtectionId }),
         ...(input.ResourceArn != null && { ResourceArn: input.ResourceArn }),
     };
 };
-const serializeAws_json1_1DescribeSubscriptionRequest = (input, context) => {
+const se_DescribeSubscriptionRequest = (input, context) => {
     return {};
 };
-const serializeAws_json1_1DisableApplicationLayerAutomaticResponseRequest = (input, context) => {
+const se_DisableApplicationLayerAutomaticResponseRequest = (input, context) => {
     return {
         ...(input.ResourceArn != null && { ResourceArn: input.ResourceArn }),
     };
 };
-const serializeAws_json1_1DisableProactiveEngagementRequest = (input, context) => {
+const se_DisableProactiveEngagementRequest = (input, context) => {
     return {};
 };
-const serializeAws_json1_1DisassociateDRTLogBucketRequest = (input, context) => {
+const se_DisassociateDRTLogBucketRequest = (input, context) => {
     return {
         ...(input.LogBucket != null && { LogBucket: input.LogBucket }),
     };
 };
-const serializeAws_json1_1DisassociateDRTRoleRequest = (input, context) => {
+const se_DisassociateDRTRoleRequest = (input, context) => {
     return {};
 };
-const serializeAws_json1_1DisassociateHealthCheckRequest = (input, context) => {
+const se_DisassociateHealthCheckRequest = (input, context) => {
     return {
         ...(input.HealthCheckArn != null && { HealthCheckArn: input.HealthCheckArn }),
         ...(input.ProtectionId != null && { ProtectionId: input.ProtectionId }),
     };
 };
-const serializeAws_json1_1EmergencyContact = (input, context) => {
+const se_EmergencyContact = (input, context) => {
     return {
         ...(input.ContactNotes != null && { ContactNotes: input.ContactNotes }),
         ...(input.EmailAddress != null && { EmailAddress: input.EmailAddress }),
         ...(input.PhoneNumber != null && { PhoneNumber: input.PhoneNumber }),
     };
 };
-const serializeAws_json1_1EmergencyContactList = (input, context) => {
+const se_EmergencyContactList = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
-        return serializeAws_json1_1EmergencyContact(entry, context);
+        return se_EmergencyContact(entry, context);
     });
 };
-const serializeAws_json1_1EnableApplicationLayerAutomaticResponseRequest = (input, context) => {
+const se_EnableApplicationLayerAutomaticResponseRequest = (input, context) => {
     return {
-        ...(input.Action != null && { Action: serializeAws_json1_1ResponseAction(input.Action, context) }),
+        ...(input.Action != null && { Action: se_ResponseAction(input.Action, context) }),
         ...(input.ResourceArn != null && { ResourceArn: input.ResourceArn }),
     };
 };
-const serializeAws_json1_1EnableProactiveEngagementRequest = (input, context) => {
+const se_EnableProactiveEngagementRequest = (input, context) => {
     return {};
 };
-const serializeAws_json1_1GetSubscriptionStateRequest = (input, context) => {
+const se_GetSubscriptionStateRequest = (input, context) => {
     return {};
 };
-const serializeAws_json1_1InclusionProtectionFilters = (input, context) => {
+const se_InclusionProtectionFilters = (input, context) => {
     return {
-        ...(input.ProtectionNames != null && {
-            ProtectionNames: serializeAws_json1_1ProtectionNameFilters(input.ProtectionNames, context),
-        }),
-        ...(input.ResourceArns != null && {
-            ResourceArns: serializeAws_json1_1ResourceArnFilters(input.ResourceArns, context),
-        }),
+        ...(input.ProtectionNames != null && { ProtectionNames: se_ProtectionNameFilters(input.ProtectionNames, context) }),
+        ...(input.ResourceArns != null && { ResourceArns: se_ResourceArnFilters(input.ResourceArns, context) }),
         ...(input.ResourceTypes != null && {
-            ResourceTypes: serializeAws_json1_1ProtectedResourceTypeFilters(input.ResourceTypes, context),
+            ResourceTypes: se_ProtectedResourceTypeFilters(input.ResourceTypes, context),
         }),
     };
 };
-const serializeAws_json1_1InclusionProtectionGroupFilters = (input, context) => {
+const se_InclusionProtectionGroupFilters = (input, context) => {
     return {
         ...(input.Aggregations != null && {
-            Aggregations: serializeAws_json1_1ProtectionGroupAggregationFilters(input.Aggregations, context),
-        }),
-        ...(input.Patterns != null && {
-            Patterns: serializeAws_json1_1ProtectionGroupPatternFilters(input.Patterns, context),
+            Aggregations: se_ProtectionGroupAggregationFilters(input.Aggregations, context),
         }),
+        ...(input.Patterns != null && { Patterns: se_ProtectionGroupPatternFilters(input.Patterns, context) }),
         ...(input.ProtectionGroupIds != null && {
-            ProtectionGroupIds: serializeAws_json1_1ProtectionGroupIdFilters(input.ProtectionGroupIds, context),
+            ProtectionGroupIds: se_ProtectionGroupIdFilters(input.ProtectionGroupIds, context),
         }),
         ...(input.ResourceTypes != null && {
-            ResourceTypes: serializeAws_json1_1ProtectedResourceTypeFilters(input.ResourceTypes, context),
+            ResourceTypes: se_ProtectedResourceTypeFilters(input.ResourceTypes, context),
         }),
     };
 };
-const serializeAws_json1_1ListAttacksRequest = (input, context) => {
+const se_ListAttacksRequest = (input, context) => {
     return {
-        ...(input.EndTime != null && { EndTime: serializeAws_json1_1TimeRange(input.EndTime, context) }),
+        ...(input.EndTime != null && { EndTime: se_TimeRange(input.EndTime, context) }),
         ...(input.MaxResults != null && { MaxResults: input.MaxResults }),
         ...(input.NextToken != null && { NextToken: input.NextToken }),
-        ...(input.ResourceArns != null && {
-            ResourceArns: serializeAws_json1_1ResourceArnFilterList(input.ResourceArns, context),
-        }),
-        ...(input.StartTime != null && { StartTime: serializeAws_json1_1TimeRange(input.StartTime, context) }),
+        ...(input.ResourceArns != null && { ResourceArns: se_ResourceArnFilterList(input.ResourceArns, context) }),
+        ...(input.StartTime != null && { StartTime: se_TimeRange(input.StartTime, context) }),
     };
 };
-const serializeAws_json1_1ListProtectionGroupsRequest = (input, context) => {
+const se_ListProtectionGroupsRequest = (input, context) => {
     return {
         ...(input.InclusionFilters != null && {
-            InclusionFilters: serializeAws_json1_1InclusionProtectionGroupFilters(input.InclusionFilters, context),
+            InclusionFilters: se_InclusionProtectionGroupFilters(input.InclusionFilters, context),
         }),
         ...(input.MaxResults != null && { MaxResults: input.MaxResults }),
         ...(input.NextToken != null && { NextToken: input.NextToken }),
     };
 };
-const serializeAws_json1_1ListProtectionsRequest = (input, context) => {
+const se_ListProtectionsRequest = (input, context) => {
     return {
         ...(input.InclusionFilters != null && {
-            InclusionFilters: serializeAws_json1_1InclusionProtectionFilters(input.InclusionFilters, context),
+            InclusionFilters: se_InclusionProtectionFilters(input.InclusionFilters, context),
         }),
         ...(input.MaxResults != null && { MaxResults: input.MaxResults }),
         ...(input.NextToken != null && { NextToken: input.NextToken }),
     };
 };
-const serializeAws_json1_1ListResourcesInProtectionGroupRequest = (input, context) => {
+const se_ListResourcesInProtectionGroupRequest = (input, context) => {
     return {
         ...(input.MaxResults != null && { MaxResults: input.MaxResults }),
         ...(input.NextToken != null && { NextToken: input.NextToken }),
         ...(input.ProtectionGroupId != null && { ProtectionGroupId: input.ProtectionGroupId }),
     };
 };
-const serializeAws_json1_1ListTagsForResourceRequest = (input, context) => {
+const se_ListTagsForResourceRequest = (input, context) => {
     return {
         ...(input.ResourceARN != null && { ResourceARN: input.ResourceARN }),
     };
 };
-const serializeAws_json1_1ProtectedResourceTypeFilters = (input, context) => {
+const se_ProtectedResourceTypeFilters = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
         return entry;
     });
 };
-const serializeAws_json1_1ProtectionGroupAggregationFilters = (input, context) => {
+const se_ProtectionGroupAggregationFilters = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
         return entry;
     });
 };
-const serializeAws_json1_1ProtectionGroupIdFilters = (input, context) => {
+const se_ProtectionGroupIdFilters = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
         return entry;
     });
 };
-const serializeAws_json1_1ProtectionGroupMembers = (input, context) => {
+const se_ProtectionGroupMembers = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
         return entry;
     });
 };
-const serializeAws_json1_1ProtectionGroupPatternFilters = (input, context) => {
+const se_ProtectionGroupPatternFilters = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
         return entry;
     });
 };
-const serializeAws_json1_1ProtectionNameFilters = (input, context) => {
+const se_ProtectionNameFilters = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
         return entry;
     });
 };
-const serializeAws_json1_1ResourceArnFilterList = (input, context) => {
+const se_ResourceArnFilterList = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
         return entry;
     });
 };
-const serializeAws_json1_1ResourceArnFilters = (input, context) => {
+const se_ResourceArnFilters = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
         return entry;
     });
 };
-const serializeAws_json1_1ResponseAction = (input, context) => {
+const se_ResponseAction = (input, context) => {
     return {
-        ...(input.Block != null && { Block: serializeAws_json1_1BlockAction(input.Block, context) }),
-        ...(input.Count != null && { Count: serializeAws_json1_1CountAction(input.Count, context) }),
+        ...(input.Block != null && { Block: se_BlockAction(input.Block, context) }),
+        ...(input.Count != null && { Count: se_CountAction(input.Count, context) }),
     };
 };
-const serializeAws_json1_1Tag = (input, context) => {
+const se_Tag = (input, context) => {
     return {
         ...(input.Key != null && { Key: input.Key }),
         ...(input.Value != null && { Value: input.Value }),
     };
 };
-const serializeAws_json1_1TagKeyList = (input, context) => {
+const se_TagKeyList = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
         return entry;
     });
 };
-const serializeAws_json1_1TagList = (input, context) => {
+const se_TagList = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
-        return serializeAws_json1_1Tag(entry, context);
+        return se_Tag(entry, context);
     });
 };
-const serializeAws_json1_1TagResourceRequest = (input, context) => {
+const se_TagResourceRequest = (input, context) => {
     return {
         ...(input.ResourceARN != null && { ResourceARN: input.ResourceARN }),
-        ...(input.Tags != null && { Tags: serializeAws_json1_1TagList(input.Tags, context) }),
+        ...(input.Tags != null && { Tags: se_TagList(input.Tags, context) }),
     };
 };
-const serializeAws_json1_1TimeRange = (input, context) => {
+const se_TimeRange = (input, context) => {
     return {
         ...(input.FromInclusive != null && { FromInclusive: Math.round(input.FromInclusive.getTime() / 1000) }),
         ...(input.ToExclusive != null && { ToExclusive: Math.round(input.ToExclusive.getTime() / 1000) }),
     };
 };
-const serializeAws_json1_1UntagResourceRequest = (input, context) => {
+const se_UntagResourceRequest = (input, context) => {
     return {
         ...(input.ResourceARN != null && { ResourceARN: input.ResourceARN }),
-        ...(input.TagKeys != null && { TagKeys: serializeAws_json1_1TagKeyList(input.TagKeys, context) }),
+        ...(input.TagKeys != null && { TagKeys: se_TagKeyList(input.TagKeys, context) }),
     };
 };
-const serializeAws_json1_1UpdateApplicationLayerAutomaticResponseRequest = (input, context) => {
+const se_UpdateApplicationLayerAutomaticResponseRequest = (input, context) => {
     return {
-        ...(input.Action != null && { Action: serializeAws_json1_1ResponseAction(input.Action, context) }),
+        ...(input.Action != null && { Action: se_ResponseAction(input.Action, context) }),
         ...(input.ResourceArn != null && { ResourceArn: input.ResourceArn }),
     };
 };
-const serializeAws_json1_1UpdateEmergencyContactSettingsRequest = (input, context) => {
+const se_UpdateEmergencyContactSettingsRequest = (input, context) => {
     return {
         ...(input.EmergencyContactList != null && {
-            EmergencyContactList: serializeAws_json1_1EmergencyContactList(input.EmergencyContactList, context),
+            EmergencyContactList: se_EmergencyContactList(input.EmergencyContactList, context),
         }),
     };
 };
-const serializeAws_json1_1UpdateProtectionGroupRequest = (input, context) => {
+const se_UpdateProtectionGroupRequest = (input, context) => {
     return {
         ...(input.Aggregation != null && { Aggregation: input.Aggregation }),
-        ...(input.Members != null && { Members: serializeAws_json1_1ProtectionGroupMembers(input.Members, context) }),
+        ...(input.Members != null && { Members: se_ProtectionGroupMembers(input.Members, context) }),
         ...(input.Pattern != null && { Pattern: input.Pattern }),
         ...(input.ProtectionGroupId != null && { ProtectionGroupId: input.ProtectionGroupId }),
         ...(input.ResourceType != null && { ResourceType: input.ResourceType }),
     };
 };
-const serializeAws_json1_1UpdateSubscriptionRequest = (input, context) => {
+const se_UpdateSubscriptionRequest = (input, context) => {
     return {
         ...(input.AutoRenew != null && { AutoRenew: input.AutoRenew }),
     };
 };
-const deserializeAws_json1_1AccessDeniedException = (output, context) => {
+const de_AccessDeniedException = (output, context) => {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_1AccessDeniedForDependencyException = (output, context) => {
+const de_AccessDeniedForDependencyException = (output, context) => {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_1ApplicationLayerAutomaticResponseConfiguration = (output, context) => {
+const de_ApplicationLayerAutomaticResponseConfiguration = (output, context) => {
     return {
-        Action: output.Action != null ? deserializeAws_json1_1ResponseAction(output.Action, context) : undefined,
+        Action: output.Action != null ? de_ResponseAction(output.Action, context) : undefined,
         Status: __expectString(output.Status),
     };
 };
-const deserializeAws_json1_1AssociateDRTLogBucketResponse = (output, context) => {
+const de_AssociateDRTLogBucketResponse = (output, context) => {
     return {};
 };
-const deserializeAws_json1_1AssociateDRTRoleResponse = (output, context) => {
+const de_AssociateDRTRoleResponse = (output, context) => {
     return {};
 };
-const deserializeAws_json1_1AssociateHealthCheckResponse = (output, context) => {
+const de_AssociateHealthCheckResponse = (output, context) => {
     return {};
 };
-const deserializeAws_json1_1AssociateProactiveEngagementDetailsResponse = (output, context) => {
+const de_AssociateProactiveEngagementDetailsResponse = (output, context) => {
     return {};
 };
-const deserializeAws_json1_1AttackDetail = (output, context) => {
+const de_AttackDetail = (output, context) => {
     return {
-        AttackCounters: output.AttackCounters != null
-            ? deserializeAws_json1_1SummarizedCounterList(output.AttackCounters, context)
-            : undefined,
+        AttackCounters: output.AttackCounters != null ? de_SummarizedCounterList(output.AttackCounters, context) : undefined,
         AttackId: __expectString(output.AttackId),
-        AttackProperties: output.AttackProperties != null
-            ? deserializeAws_json1_1AttackProperties(output.AttackProperties, context)
-            : undefined,
+        AttackProperties: output.AttackProperties != null ? de_AttackProperties(output.AttackProperties, context) : undefined,
         EndTime: output.EndTime != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.EndTime))) : undefined,
-        Mitigations: output.Mitigations != null ? deserializeAws_json1_1MitigationList(output.Mitigations, context) : undefined,
+        Mitigations: output.Mitigations != null ? de_MitigationList(output.Mitigations, context) : undefined,
         ResourceArn: __expectString(output.ResourceArn),
         StartTime: output.StartTime != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.StartTime))) : undefined,
-        SubResources: output.SubResources != null
-            ? deserializeAws_json1_1SubResourceSummaryList(output.SubResources, context)
-            : undefined,
+        SubResources: output.SubResources != null ? de_SubResourceSummaryList(output.SubResources, context) : undefined,
     };
 };
-const deserializeAws_json1_1AttackProperties = (output, context) => {
+const de_AttackProperties = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_json1_1AttackProperty(entry, context);
+        return de_AttackProperty(entry, context);
     });
     return retVal;
 };
-const deserializeAws_json1_1AttackProperty = (output, context) => {
+const de_AttackProperty = (output, context) => {
     return {
         AttackLayer: __expectString(output.AttackLayer),
         AttackPropertyIdentifier: __expectString(output.AttackPropertyIdentifier),
-        TopContributors: output.TopContributors != null
-            ? deserializeAws_json1_1TopContributors(output.TopContributors, context)
-            : undefined,
+        TopContributors: output.TopContributors != null ? de_TopContributors(output.TopContributors, context) : undefined,
         Total: __expectLong(output.Total),
         Unit: __expectString(output.Unit),
     };
 };
-const deserializeAws_json1_1AttackStatisticsDataItem = (output, context) => {
+const de_AttackStatisticsDataItem = (output, context) => {
     return {
         AttackCount: __expectLong(output.AttackCount),
-        AttackVolume: output.AttackVolume != null ? deserializeAws_json1_1AttackVolume(output.AttackVolume, context) : undefined,
+        AttackVolume: output.AttackVolume != null ? de_AttackVolume(output.AttackVolume, context) : undefined,
     };
 };
-const deserializeAws_json1_1AttackStatisticsDataList = (output, context) => {
+const de_AttackStatisticsDataList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_json1_1AttackStatisticsDataItem(entry, context);
+        return de_AttackStatisticsDataItem(entry, context);
     });
     return retVal;
 };
-const deserializeAws_json1_1AttackSummaries = (output, context) => {
+const de_AttackSummaries = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_json1_1AttackSummary(entry, context);
+        return de_AttackSummary(entry, context);
     });
     return retVal;
 };
-const deserializeAws_json1_1AttackSummary = (output, context) => {
+const de_AttackSummary = (output, context) => {
     return {
         AttackId: __expectString(output.AttackId),
-        AttackVectors: output.AttackVectors != null
-            ? deserializeAws_json1_1AttackVectorDescriptionList(output.AttackVectors, context)
-            : undefined,
+        AttackVectors: output.AttackVectors != null ? de_AttackVectorDescriptionList(output.AttackVectors, context) : undefined,
         EndTime: output.EndTime != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.EndTime))) : undefined,
         ResourceArn: __expectString(output.ResourceArn),
         StartTime: output.StartTime != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.StartTime))) : undefined,
     };
 };
-const deserializeAws_json1_1AttackVectorDescription = (output, context) => {
+const de_AttackVectorDescription = (output, context) => {
     return {
         VectorType: __expectString(output.VectorType),
     };
 };
-const deserializeAws_json1_1AttackVectorDescriptionList = (output, context) => {
+const de_AttackVectorDescriptionList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_json1_1AttackVectorDescription(entry, context);
+        return de_AttackVectorDescription(entry, context);
     });
     return retVal;
 };
-const deserializeAws_json1_1AttackVolume = (output, context) => {
+const de_AttackVolume = (output, context) => {
     return {
-        BitsPerSecond: output.BitsPerSecond != null
-            ? deserializeAws_json1_1AttackVolumeStatistics(output.BitsPerSecond, context)
-            : undefined,
-        PacketsPerSecond: output.PacketsPerSecond != null
-            ? deserializeAws_json1_1AttackVolumeStatistics(output.PacketsPerSecond, context)
-            : undefined,
-        RequestsPerSecond: output.RequestsPerSecond != null
-            ? deserializeAws_json1_1AttackVolumeStatistics(output.RequestsPerSecond, context)
-            : undefined,
+        BitsPerSecond: output.BitsPerSecond != null ? de_AttackVolumeStatistics(output.BitsPerSecond, context) : undefined,
+        PacketsPerSecond: output.PacketsPerSecond != null ? de_AttackVolumeStatistics(output.PacketsPerSecond, context) : undefined,
+        RequestsPerSecond: output.RequestsPerSecond != null ? de_AttackVolumeStatistics(output.RequestsPerSecond, context) : undefined,
     };
 };
-const deserializeAws_json1_1AttackVolumeStatistics = (output, context) => {
+const de_AttackVolumeStatistics = (output, context) => {
     return {
         Max: __limitedParseDouble(output.Max),
     };
 };
-const deserializeAws_json1_1BlockAction = (output, context) => {
+const de_BlockAction = (output, context) => {
     return {};
 };
-const deserializeAws_json1_1Contributor = (output, context) => {
+const de_Contributor = (output, context) => {
     return {
         Name: __expectString(output.Name),
         Value: __expectLong(output.Value),
     };
 };
-const deserializeAws_json1_1CountAction = (output, context) => {
+const de_CountAction = (output, context) => {
     return {};
 };
-const deserializeAws_json1_1CreateProtectionGroupResponse = (output, context) => {
+const de_CreateProtectionGroupResponse = (output, context) => {
     return {};
 };
-const deserializeAws_json1_1CreateProtectionResponse = (output, context) => {
+const de_CreateProtectionResponse = (output, context) => {
     return {
         ProtectionId: __expectString(output.ProtectionId),
     };
 };
-const deserializeAws_json1_1CreateSubscriptionResponse = (output, context) => {
+const de_CreateSubscriptionResponse = (output, context) => {
     return {};
 };
-const deserializeAws_json1_1DeleteProtectionGroupResponse = (output, context) => {
+const de_DeleteProtectionGroupResponse = (output, context) => {
     return {};
 };
-const deserializeAws_json1_1DeleteProtectionResponse = (output, context) => {
+const de_DeleteProtectionResponse = (output, context) => {
     return {};
 };
-const deserializeAws_json1_1DeleteSubscriptionResponse = (output, context) => {
+const de_DeleteSubscriptionResponse = (output, context) => {
     return {};
 };
-const deserializeAws_json1_1DescribeAttackResponse = (output, context) => {
+const de_DescribeAttackResponse = (output, context) => {
     return {
-        Attack: output.Attack != null ? deserializeAws_json1_1AttackDetail(output.Attack, context) : undefined,
+        Attack: output.Attack != null ? de_AttackDetail(output.Attack, context) : undefined,
     };
 };
-const deserializeAws_json1_1DescribeAttackStatisticsResponse = (output, context) => {
+const de_DescribeAttackStatisticsResponse = (output, context) => {
     return {
-        DataItems: output.DataItems != null ? deserializeAws_json1_1AttackStatisticsDataList(output.DataItems, context) : undefined,
-        TimeRange: output.TimeRange != null ? deserializeAws_json1_1TimeRange(output.TimeRange, context) : undefined,
+        DataItems: output.DataItems != null ? de_AttackStatisticsDataList(output.DataItems, context) : undefined,
+        TimeRange: output.TimeRange != null ? de_TimeRange(output.TimeRange, context) : undefined,
     };
 };
-const deserializeAws_json1_1DescribeDRTAccessResponse = (output, context) => {
+const de_DescribeDRTAccessResponse = (output, context) => {
     return {
-        LogBucketList: output.LogBucketList != null ? deserializeAws_json1_1LogBucketList(output.LogBucketList, context) : undefined,
+        LogBucketList: output.LogBucketList != null ? de_LogBucketList(output.LogBucketList, context) : undefined,
         RoleArn: __expectString(output.RoleArn),
     };
 };
-const deserializeAws_json1_1DescribeEmergencyContactSettingsResponse = (output, context) => {
+const de_DescribeEmergencyContactSettingsResponse = (output, context) => {
     return {
-        EmergencyContactList: output.EmergencyContactList != null
-            ? deserializeAws_json1_1EmergencyContactList(output.EmergencyContactList, context)
-            : undefined,
+        EmergencyContactList: output.EmergencyContactList != null ? de_EmergencyContactList(output.EmergencyContactList, context) : undefined,
     };
 };
-const deserializeAws_json1_1DescribeProtectionGroupResponse = (output, context) => {
+const de_DescribeProtectionGroupResponse = (output, context) => {
     return {
-        ProtectionGroup: output.ProtectionGroup != null
-            ? deserializeAws_json1_1ProtectionGroup(output.ProtectionGroup, context)
-            : undefined,
+        ProtectionGroup: output.ProtectionGroup != null ? de_ProtectionGroup(output.ProtectionGroup, context) : undefined,
     };
 };
-const deserializeAws_json1_1DescribeProtectionResponse = (output, context) => {
+const de_DescribeProtectionResponse = (output, context) => {
     return {
-        Protection: output.Protection != null ? deserializeAws_json1_1Protection(output.Protection, context) : undefined,
+        Protection: output.Protection != null ? de_Protection(output.Protection, context) : undefined,
     };
 };
-const deserializeAws_json1_1DescribeSubscriptionResponse = (output, context) => {
+const de_DescribeSubscriptionResponse = (output, context) => {
     return {
-        Subscription: output.Subscription != null ? deserializeAws_json1_1Subscription(output.Subscription, context) : undefined,
+        Subscription: output.Subscription != null ? de_Subscription(output.Subscription, context) : undefined,
     };
 };
-const deserializeAws_json1_1DisableApplicationLayerAutomaticResponseResponse = (output, context) => {
+const de_DisableApplicationLayerAutomaticResponseResponse = (output, context) => {
     return {};
 };
-const deserializeAws_json1_1DisableProactiveEngagementResponse = (output, context) => {
+const de_DisableProactiveEngagementResponse = (output, context) => {
     return {};
 };
-const deserializeAws_json1_1DisassociateDRTLogBucketResponse = (output, context) => {
+const de_DisassociateDRTLogBucketResponse = (output, context) => {
     return {};
 };
-const deserializeAws_json1_1DisassociateDRTRoleResponse = (output, context) => {
+const de_DisassociateDRTRoleResponse = (output, context) => {
     return {};
 };
-const deserializeAws_json1_1DisassociateHealthCheckResponse = (output, context) => {
+const de_DisassociateHealthCheckResponse = (output, context) => {
     return {};
 };
-const deserializeAws_json1_1EmergencyContact = (output, context) => {
+const de_EmergencyContact = (output, context) => {
     return {
         ContactNotes: __expectString(output.ContactNotes),
         EmailAddress: __expectString(output.EmailAddress),
         PhoneNumber: __expectString(output.PhoneNumber),
     };
 };
-const deserializeAws_json1_1EmergencyContactList = (output, context) => {
+const de_EmergencyContactList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_json1_1EmergencyContact(entry, context);
+        return de_EmergencyContact(entry, context);
     });
     return retVal;
 };
-const deserializeAws_json1_1EnableApplicationLayerAutomaticResponseResponse = (output, context) => {
+const de_EnableApplicationLayerAutomaticResponseResponse = (output, context) => {
     return {};
 };
-const deserializeAws_json1_1EnableProactiveEngagementResponse = (output, context) => {
+const de_EnableProactiveEngagementResponse = (output, context) => {
     return {};
 };
-const deserializeAws_json1_1GetSubscriptionStateResponse = (output, context) => {
+const de_GetSubscriptionStateResponse = (output, context) => {
     return {
         SubscriptionState: __expectString(output.SubscriptionState),
     };
 };
-const deserializeAws_json1_1HealthCheckIds = (output, context) => {
+const de_HealthCheckIds = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
@@ -2553,96 +2525,92 @@ const deserializeAws_json1_1HealthCheckIds = (output, context) => {
     });
     return retVal;
 };
-const deserializeAws_json1_1InternalErrorException = (output, context) => {
+const de_InternalErrorException = (output, context) => {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_1InvalidOperationException = (output, context) => {
+const de_InvalidOperationException = (output, context) => {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_1InvalidPaginationTokenException = (output, context) => {
+const de_InvalidPaginationTokenException = (output, context) => {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_1InvalidParameterException = (output, context) => {
+const de_InvalidParameterException = (output, context) => {
     return {
-        fields: output.fields != null ? deserializeAws_json1_1ValidationExceptionFieldList(output.fields, context) : undefined,
+        fields: output.fields != null ? de_ValidationExceptionFieldList(output.fields, context) : undefined,
         message: __expectString(output.message),
         reason: __expectString(output.reason),
     };
 };
-const deserializeAws_json1_1InvalidResourceException = (output, context) => {
+const de_InvalidResourceException = (output, context) => {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_1Limit = (output, context) => {
+const de_Limit = (output, context) => {
     return {
         Max: __expectLong(output.Max),
         Type: __expectString(output.Type),
     };
 };
-const deserializeAws_json1_1Limits = (output, context) => {
+const de_Limits = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_json1_1Limit(entry, context);
+        return de_Limit(entry, context);
     });
     return retVal;
 };
-const deserializeAws_json1_1LimitsExceededException = (output, context) => {
+const de_LimitsExceededException = (output, context) => {
     return {
         Limit: __expectLong(output.Limit),
         Type: __expectString(output.Type),
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_1ListAttacksResponse = (output, context) => {
+const de_ListAttacksResponse = (output, context) => {
     return {
-        AttackSummaries: output.AttackSummaries != null
-            ? deserializeAws_json1_1AttackSummaries(output.AttackSummaries, context)
-            : undefined,
+        AttackSummaries: output.AttackSummaries != null ? de_AttackSummaries(output.AttackSummaries, context) : undefined,
         NextToken: __expectString(output.NextToken),
     };
 };
-const deserializeAws_json1_1ListProtectionGroupsResponse = (output, context) => {
+const de_ListProtectionGroupsResponse = (output, context) => {
     return {
         NextToken: __expectString(output.NextToken),
-        ProtectionGroups: output.ProtectionGroups != null
-            ? deserializeAws_json1_1ProtectionGroups(output.ProtectionGroups, context)
-            : undefined,
+        ProtectionGroups: output.ProtectionGroups != null ? de_ProtectionGroups(output.ProtectionGroups, context) : undefined,
     };
 };
-const deserializeAws_json1_1ListProtectionsResponse = (output, context) => {
+const de_ListProtectionsResponse = (output, context) => {
     return {
         NextToken: __expectString(output.NextToken),
-        Protections: output.Protections != null ? deserializeAws_json1_1Protections(output.Protections, context) : undefined,
+        Protections: output.Protections != null ? de_Protections(output.Protections, context) : undefined,
     };
 };
-const deserializeAws_json1_1ListResourcesInProtectionGroupResponse = (output, context) => {
+const de_ListResourcesInProtectionGroupResponse = (output, context) => {
     return {
         NextToken: __expectString(output.NextToken),
-        ResourceArns: output.ResourceArns != null ? deserializeAws_json1_1ResourceArnList(output.ResourceArns, context) : undefined,
+        ResourceArns: output.ResourceArns != null ? de_ResourceArnList(output.ResourceArns, context) : undefined,
     };
 };
-const deserializeAws_json1_1ListTagsForResourceResponse = (output, context) => {
+const de_ListTagsForResourceResponse = (output, context) => {
     return {
-        Tags: output.Tags != null ? deserializeAws_json1_1TagList(output.Tags, context) : undefined,
+        Tags: output.Tags != null ? de_TagList(output.Tags, context) : undefined,
     };
 };
-const deserializeAws_json1_1LockedSubscriptionException = (output, context) => {
+const de_LockedSubscriptionException = (output, context) => {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_1LogBucketList = (output, context) => {
+const de_LogBucketList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
@@ -2653,68 +2621,68 @@ const deserializeAws_json1_1LogBucketList = (output, context) => {
     });
     return retVal;
 };
-const deserializeAws_json1_1Mitigation = (output, context) => {
+const de_Mitigation = (output, context) => {
     return {
         MitigationName: __expectString(output.MitigationName),
     };
 };
-const deserializeAws_json1_1MitigationList = (output, context) => {
+const de_MitigationList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_json1_1Mitigation(entry, context);
+        return de_Mitigation(entry, context);
     });
     return retVal;
 };
-const deserializeAws_json1_1NoAssociatedRoleException = (output, context) => {
+const de_NoAssociatedRoleException = (output, context) => {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_1OptimisticLockException = (output, context) => {
+const de_OptimisticLockException = (output, context) => {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_1Protection = (output, context) => {
+const de_Protection = (output, context) => {
     return {
         ApplicationLayerAutomaticResponseConfiguration: output.ApplicationLayerAutomaticResponseConfiguration != null
-            ? deserializeAws_json1_1ApplicationLayerAutomaticResponseConfiguration(output.ApplicationLayerAutomaticResponseConfiguration, context)
+            ? de_ApplicationLayerAutomaticResponseConfiguration(output.ApplicationLayerAutomaticResponseConfiguration, context)
             : undefined,
-        HealthCheckIds: output.HealthCheckIds != null ? deserializeAws_json1_1HealthCheckIds(output.HealthCheckIds, context) : undefined,
+        HealthCheckIds: output.HealthCheckIds != null ? de_HealthCheckIds(output.HealthCheckIds, context) : undefined,
         Id: __expectString(output.Id),
         Name: __expectString(output.Name),
         ProtectionArn: __expectString(output.ProtectionArn),
         ResourceArn: __expectString(output.ResourceArn),
     };
 };
-const deserializeAws_json1_1ProtectionGroup = (output, context) => {
+const de_ProtectionGroup = (output, context) => {
     return {
         Aggregation: __expectString(output.Aggregation),
-        Members: output.Members != null ? deserializeAws_json1_1ProtectionGroupMembers(output.Members, context) : undefined,
+        Members: output.Members != null ? de_ProtectionGroupMembers(output.Members, context) : undefined,
         Pattern: __expectString(output.Pattern),
         ProtectionGroupArn: __expectString(output.ProtectionGroupArn),
         ProtectionGroupId: __expectString(output.ProtectionGroupId),
         ResourceType: __expectString(output.ResourceType),
     };
 };
-const deserializeAws_json1_1ProtectionGroupArbitraryPatternLimits = (output, context) => {
+const de_ProtectionGroupArbitraryPatternLimits = (output, context) => {
     return {
         MaxMembers: __expectLong(output.MaxMembers),
     };
 };
-const deserializeAws_json1_1ProtectionGroupLimits = (output, context) => {
+const de_ProtectionGroupLimits = (output, context) => {
     return {
         MaxProtectionGroups: __expectLong(output.MaxProtectionGroups),
         PatternTypeLimits: output.PatternTypeLimits != null
-            ? deserializeAws_json1_1ProtectionGroupPatternTypeLimits(output.PatternTypeLimits, context)
+            ? de_ProtectionGroupPatternTypeLimits(output.PatternTypeLimits, context)
             : undefined,
     };
 };
-const deserializeAws_json1_1ProtectionGroupMembers = (output, context) => {
+const de_ProtectionGroupMembers = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
@@ -2725,49 +2693,47 @@ const deserializeAws_json1_1ProtectionGroupMembers = (output, context) => {
     });
     return retVal;
 };
-const deserializeAws_json1_1ProtectionGroupPatternTypeLimits = (output, context) => {
+const de_ProtectionGroupPatternTypeLimits = (output, context) => {
     return {
         ArbitraryPatternLimits: output.ArbitraryPatternLimits != null
-            ? deserializeAws_json1_1ProtectionGroupArbitraryPatternLimits(output.ArbitraryPatternLimits, context)
+            ? de_ProtectionGroupArbitraryPatternLimits(output.ArbitraryPatternLimits, context)
             : undefined,
     };
 };
-const deserializeAws_json1_1ProtectionGroups = (output, context) => {
+const de_ProtectionGroups = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_json1_1ProtectionGroup(entry, context);
+        return de_ProtectionGroup(entry, context);
     });
     return retVal;
 };
-const deserializeAws_json1_1ProtectionLimits = (output, context) => {
+const de_ProtectionLimits = (output, context) => {
     return {
-        ProtectedResourceTypeLimits: output.ProtectedResourceTypeLimits != null
-            ? deserializeAws_json1_1Limits(output.ProtectedResourceTypeLimits, context)
-            : undefined,
+        ProtectedResourceTypeLimits: output.ProtectedResourceTypeLimits != null ? de_Limits(output.ProtectedResourceTypeLimits, context) : undefined,
     };
 };
-const deserializeAws_json1_1Protections = (output, context) => {
+const de_Protections = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_json1_1Protection(entry, context);
+        return de_Protection(entry, context);
     });
     return retVal;
 };
-const deserializeAws_json1_1ResourceAlreadyExistsException = (output, context) => {
+const de_ResourceAlreadyExistsException = (output, context) => {
     return {
         message: __expectString(output.message),
         resourceType: __expectString(output.resourceType),
     };
 };
-const deserializeAws_json1_1ResourceArnList = (output, context) => {
+const de_ResourceArnList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
@@ -2778,83 +2744,75 @@ const deserializeAws_json1_1ResourceArnList = (output, context) => {
     });
     return retVal;
 };
-const deserializeAws_json1_1ResourceNotFoundException = (output, context) => {
+const de_ResourceNotFoundException = (output, context) => {
     return {
         message: __expectString(output.message),
         resourceType: __expectString(output.resourceType),
     };
 };
-const deserializeAws_json1_1ResponseAction = (output, context) => {
+const de_ResponseAction = (output, context) => {
     return {
-        Block: output.Block != null ? deserializeAws_json1_1BlockAction(output.Block, context) : undefined,
-        Count: output.Count != null ? deserializeAws_json1_1CountAction(output.Count, context) : undefined,
+        Block: output.Block != null ? de_BlockAction(output.Block, context) : undefined,
+        Count: output.Count != null ? de_CountAction(output.Count, context) : undefined,
     };
 };
-const deserializeAws_json1_1SubResourceSummary = (output, context) => {
+const de_SubResourceSummary = (output, context) => {
     return {
-        AttackVectors: output.AttackVectors != null
-            ? deserializeAws_json1_1SummarizedAttackVectorList(output.AttackVectors, context)
-            : undefined,
-        Counters: output.Counters != null ? deserializeAws_json1_1SummarizedCounterList(output.Counters, context) : undefined,
+        AttackVectors: output.AttackVectors != null ? de_SummarizedAttackVectorList(output.AttackVectors, context) : undefined,
+        Counters: output.Counters != null ? de_SummarizedCounterList(output.Counters, context) : undefined,
         Id: __expectString(output.Id),
         Type: __expectString(output.Type),
     };
 };
-const deserializeAws_json1_1SubResourceSummaryList = (output, context) => {
+const de_SubResourceSummaryList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_json1_1SubResourceSummary(entry, context);
+        return de_SubResourceSummary(entry, context);
     });
     return retVal;
 };
-const deserializeAws_json1_1Subscription = (output, context) => {
+const de_Subscription = (output, context) => {
     return {
         AutoRenew: __expectString(output.AutoRenew),
         EndTime: output.EndTime != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.EndTime))) : undefined,
-        Limits: output.Limits != null ? deserializeAws_json1_1Limits(output.Limits, context) : undefined,
+        Limits: output.Limits != null ? de_Limits(output.Limits, context) : undefined,
         ProactiveEngagementStatus: __expectString(output.ProactiveEngagementStatus),
         StartTime: output.StartTime != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.StartTime))) : undefined,
         SubscriptionArn: __expectString(output.SubscriptionArn),
-        SubscriptionLimits: output.SubscriptionLimits != null
-            ? deserializeAws_json1_1SubscriptionLimits(output.SubscriptionLimits, context)
-            : undefined,
+        SubscriptionLimits: output.SubscriptionLimits != null ? de_SubscriptionLimits(output.SubscriptionLimits, context) : undefined,
         TimeCommitmentInSeconds: __expectLong(output.TimeCommitmentInSeconds),
     };
 };
-const deserializeAws_json1_1SubscriptionLimits = (output, context) => {
+const de_SubscriptionLimits = (output, context) => {
     return {
         ProtectionGroupLimits: output.ProtectionGroupLimits != null
-            ? deserializeAws_json1_1ProtectionGroupLimits(output.ProtectionGroupLimits, context)
-            : undefined,
-        ProtectionLimits: output.ProtectionLimits != null
-            ? deserializeAws_json1_1ProtectionLimits(output.ProtectionLimits, context)
+            ? de_ProtectionGroupLimits(output.ProtectionGroupLimits, context)
             : undefined,
+        ProtectionLimits: output.ProtectionLimits != null ? de_ProtectionLimits(output.ProtectionLimits, context) : undefined,
     };
 };
-const deserializeAws_json1_1SummarizedAttackVector = (output, context) => {
+const de_SummarizedAttackVector = (output, context) => {
     return {
-        VectorCounters: output.VectorCounters != null
-            ? deserializeAws_json1_1SummarizedCounterList(output.VectorCounters, context)
-            : undefined,
+        VectorCounters: output.VectorCounters != null ? de_SummarizedCounterList(output.VectorCounters, context) : undefined,
         VectorType: __expectString(output.VectorType),
     };
 };
-const deserializeAws_json1_1SummarizedAttackVectorList = (output, context) => {
+const de_SummarizedAttackVectorList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_json1_1SummarizedAttackVector(entry, context);
+        return de_SummarizedAttackVector(entry, context);
     });
     return retVal;
 };
-const deserializeAws_json1_1SummarizedCounter = (output, context) => {
+const de_SummarizedCounter = (output, context) => {
     return {
         Average: __limitedParseDouble(output.Average),
         Max: __limitedParseDouble(output.Max),
@@ -2864,38 +2822,38 @@ const deserializeAws_json1_1SummarizedCounter = (output, context) => {
         Unit: __expectString(output.Unit),
     };
 };
-const deserializeAws_json1_1SummarizedCounterList = (output, context) => {
+const de_SummarizedCounterList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_json1_1SummarizedCounter(entry, context);
+        return de_SummarizedCounter(entry, context);
     });
     return retVal;
 };
-const deserializeAws_json1_1Tag = (output, context) => {
+const de_Tag = (output, context) => {
     return {
         Key: __expectString(output.Key),
         Value: __expectString(output.Value),
     };
 };
-const deserializeAws_json1_1TagList = (output, context) => {
+const de_TagList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_json1_1Tag(entry, context);
+        return de_Tag(entry, context);
     });
     return retVal;
 };
-const deserializeAws_json1_1TagResourceResponse = (output, context) => {
+const de_TagResourceResponse = (output, context) => {
     return {};
 };
-const deserializeAws_json1_1TimeRange = (output, context) => {
+const de_TimeRange = (output, context) => {
     return {
         FromInclusive: output.FromInclusive != null
             ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.FromInclusive)))
@@ -2905,46 +2863,46 @@ const deserializeAws_json1_1TimeRange = (output, context) => {
             : undefined,
     };
 };
-const deserializeAws_json1_1TopContributors = (output, context) => {
+const de_TopContributors = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_json1_1Contributor(entry, context);
+        return de_Contributor(entry, context);
     });
     return retVal;
 };
-const deserializeAws_json1_1UntagResourceResponse = (output, context) => {
+const de_UntagResourceResponse = (output, context) => {
     return {};
 };
-const deserializeAws_json1_1UpdateApplicationLayerAutomaticResponseResponse = (output, context) => {
+const de_UpdateApplicationLayerAutomaticResponseResponse = (output, context) => {
     return {};
 };
-const deserializeAws_json1_1UpdateEmergencyContactSettingsResponse = (output, context) => {
+const de_UpdateEmergencyContactSettingsResponse = (output, context) => {
     return {};
 };
-const deserializeAws_json1_1UpdateProtectionGroupResponse = (output, context) => {
+const de_UpdateProtectionGroupResponse = (output, context) => {
     return {};
 };
-const deserializeAws_json1_1UpdateSubscriptionResponse = (output, context) => {
+const de_UpdateSubscriptionResponse = (output, context) => {
     return {};
 };
-const deserializeAws_json1_1ValidationExceptionField = (output, context) => {
+const de_ValidationExceptionField = (output, context) => {
     return {
         message: __expectString(output.message),
         name: __expectString(output.name),
     };
 };
-const deserializeAws_json1_1ValidationExceptionFieldList = (output, context) => {
+const de_ValidationExceptionFieldList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_json1_1ValidationExceptionField(entry, context);
+        return de_ValidationExceptionField(entry, context);
     });
     return retVal;
 };