@aws-sdk/client-cloudwatch-logs 3.306.0 → 3.310.0

package/dist-es/protocols/Aws_json1_1.js

@@ -2,441 +2,441 @@ import { HttpRequest as __HttpRequest } from "@aws-sdk/protocol-http";
 import { decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectInt32 as __expectInt32, expectLong as __expectLong, expectString as __expectString, limitedParseDouble as __limitedParseDouble, serializeFloat as __serializeFloat, throwDefaultError, } from "@aws-sdk/smithy-client";
 import { CloudWatchLogsServiceException as __BaseException } from "../models/CloudWatchLogsServiceException";
 import { DataAlreadyAcceptedException, InvalidOperationException, InvalidParameterException, InvalidSequenceTokenException, LimitExceededException, MalformedQueryException, OperationAbortedException, ResourceAlreadyExistsException, ResourceNotFoundException, ServiceUnavailableException, TooManyTagsException, UnrecognizedClientException, } from "../models/models_0";
-export const serializeAws_json1_1AssociateKmsKeyCommand = async (input, context) => {
+export const se_AssociateKmsKeyCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Logs_20140328.AssociateKmsKey",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1AssociateKmsKeyRequest(input, context));
+    body = JSON.stringify(se_AssociateKmsKeyRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1CancelExportTaskCommand = async (input, context) => {
+export const se_CancelExportTaskCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Logs_20140328.CancelExportTask",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1CancelExportTaskRequest(input, context));
+    body = JSON.stringify(se_CancelExportTaskRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1CreateExportTaskCommand = async (input, context) => {
+export const se_CreateExportTaskCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Logs_20140328.CreateExportTask",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1CreateExportTaskRequest(input, context));
+    body = JSON.stringify(se_CreateExportTaskRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1CreateLogGroupCommand = async (input, context) => {
+export const se_CreateLogGroupCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Logs_20140328.CreateLogGroup",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1CreateLogGroupRequest(input, context));
+    body = JSON.stringify(se_CreateLogGroupRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1CreateLogStreamCommand = async (input, context) => {
+export const se_CreateLogStreamCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Logs_20140328.CreateLogStream",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1CreateLogStreamRequest(input, context));
+    body = JSON.stringify(se_CreateLogStreamRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1DeleteDataProtectionPolicyCommand = async (input, context) => {
+export const se_DeleteDataProtectionPolicyCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Logs_20140328.DeleteDataProtectionPolicy",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1DeleteDataProtectionPolicyRequest(input, context));
+    body = JSON.stringify(se_DeleteDataProtectionPolicyRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1DeleteDestinationCommand = async (input, context) => {
+export const se_DeleteDestinationCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Logs_20140328.DeleteDestination",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1DeleteDestinationRequest(input, context));
+    body = JSON.stringify(se_DeleteDestinationRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1DeleteLogGroupCommand = async (input, context) => {
+export const se_DeleteLogGroupCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Logs_20140328.DeleteLogGroup",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1DeleteLogGroupRequest(input, context));
+    body = JSON.stringify(se_DeleteLogGroupRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1DeleteLogStreamCommand = async (input, context) => {
+export const se_DeleteLogStreamCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Logs_20140328.DeleteLogStream",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1DeleteLogStreamRequest(input, context));
+    body = JSON.stringify(se_DeleteLogStreamRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1DeleteMetricFilterCommand = async (input, context) => {
+export const se_DeleteMetricFilterCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Logs_20140328.DeleteMetricFilter",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1DeleteMetricFilterRequest(input, context));
+    body = JSON.stringify(se_DeleteMetricFilterRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1DeleteQueryDefinitionCommand = async (input, context) => {
+export const se_DeleteQueryDefinitionCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Logs_20140328.DeleteQueryDefinition",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1DeleteQueryDefinitionRequest(input, context));
+    body = JSON.stringify(se_DeleteQueryDefinitionRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1DeleteResourcePolicyCommand = async (input, context) => {
+export const se_DeleteResourcePolicyCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Logs_20140328.DeleteResourcePolicy",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1DeleteResourcePolicyRequest(input, context));
+    body = JSON.stringify(se_DeleteResourcePolicyRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1DeleteRetentionPolicyCommand = async (input, context) => {
+export const se_DeleteRetentionPolicyCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Logs_20140328.DeleteRetentionPolicy",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1DeleteRetentionPolicyRequest(input, context));
+    body = JSON.stringify(se_DeleteRetentionPolicyRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1DeleteSubscriptionFilterCommand = async (input, context) => {
+export const se_DeleteSubscriptionFilterCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Logs_20140328.DeleteSubscriptionFilter",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1DeleteSubscriptionFilterRequest(input, context));
+    body = JSON.stringify(se_DeleteSubscriptionFilterRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1DescribeDestinationsCommand = async (input, context) => {
+export const se_DescribeDestinationsCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Logs_20140328.DescribeDestinations",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1DescribeDestinationsRequest(input, context));
+    body = JSON.stringify(se_DescribeDestinationsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1DescribeExportTasksCommand = async (input, context) => {
+export const se_DescribeExportTasksCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Logs_20140328.DescribeExportTasks",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1DescribeExportTasksRequest(input, context));
+    body = JSON.stringify(se_DescribeExportTasksRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1DescribeLogGroupsCommand = async (input, context) => {
+export const se_DescribeLogGroupsCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Logs_20140328.DescribeLogGroups",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1DescribeLogGroupsRequest(input, context));
+    body = JSON.stringify(se_DescribeLogGroupsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1DescribeLogStreamsCommand = async (input, context) => {
+export const se_DescribeLogStreamsCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Logs_20140328.DescribeLogStreams",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1DescribeLogStreamsRequest(input, context));
+    body = JSON.stringify(se_DescribeLogStreamsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1DescribeMetricFiltersCommand = async (input, context) => {
+export const se_DescribeMetricFiltersCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Logs_20140328.DescribeMetricFilters",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1DescribeMetricFiltersRequest(input, context));
+    body = JSON.stringify(se_DescribeMetricFiltersRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1DescribeQueriesCommand = async (input, context) => {
+export const se_DescribeQueriesCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Logs_20140328.DescribeQueries",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1DescribeQueriesRequest(input, context));
+    body = JSON.stringify(se_DescribeQueriesRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1DescribeQueryDefinitionsCommand = async (input, context) => {
+export const se_DescribeQueryDefinitionsCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Logs_20140328.DescribeQueryDefinitions",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1DescribeQueryDefinitionsRequest(input, context));
+    body = JSON.stringify(se_DescribeQueryDefinitionsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1DescribeResourcePoliciesCommand = async (input, context) => {
+export const se_DescribeResourcePoliciesCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Logs_20140328.DescribeResourcePolicies",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1DescribeResourcePoliciesRequest(input, context));
+    body = JSON.stringify(se_DescribeResourcePoliciesRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1DescribeSubscriptionFiltersCommand = async (input, context) => {
+export const se_DescribeSubscriptionFiltersCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Logs_20140328.DescribeSubscriptionFilters",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1DescribeSubscriptionFiltersRequest(input, context));
+    body = JSON.stringify(se_DescribeSubscriptionFiltersRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1DisassociateKmsKeyCommand = async (input, context) => {
+export const se_DisassociateKmsKeyCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Logs_20140328.DisassociateKmsKey",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1DisassociateKmsKeyRequest(input, context));
+    body = JSON.stringify(se_DisassociateKmsKeyRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1FilterLogEventsCommand = async (input, context) => {
+export const se_FilterLogEventsCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Logs_20140328.FilterLogEvents",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1FilterLogEventsRequest(input, context));
+    body = JSON.stringify(se_FilterLogEventsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1GetDataProtectionPolicyCommand = async (input, context) => {
+export const se_GetDataProtectionPolicyCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Logs_20140328.GetDataProtectionPolicy",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1GetDataProtectionPolicyRequest(input, context));
+    body = JSON.stringify(se_GetDataProtectionPolicyRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1GetLogEventsCommand = async (input, context) => {
+export const se_GetLogEventsCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Logs_20140328.GetLogEvents",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1GetLogEventsRequest(input, context));
+    body = JSON.stringify(se_GetLogEventsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1GetLogGroupFieldsCommand = async (input, context) => {
+export const se_GetLogGroupFieldsCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Logs_20140328.GetLogGroupFields",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1GetLogGroupFieldsRequest(input, context));
+    body = JSON.stringify(se_GetLogGroupFieldsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1GetLogRecordCommand = async (input, context) => {
+export const se_GetLogRecordCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Logs_20140328.GetLogRecord",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1GetLogRecordRequest(input, context));
+    body = JSON.stringify(se_GetLogRecordRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1GetQueryResultsCommand = async (input, context) => {
+export const se_GetQueryResultsCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Logs_20140328.GetQueryResults",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1GetQueryResultsRequest(input, context));
+    body = JSON.stringify(se_GetQueryResultsRequest(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": "Logs_20140328.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_1ListTagsLogGroupCommand = async (input, context) => {
+export const se_ListTagsLogGroupCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Logs_20140328.ListTagsLogGroup",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1ListTagsLogGroupRequest(input, context));
+    body = JSON.stringify(se_ListTagsLogGroupRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1PutDataProtectionPolicyCommand = async (input, context) => {
+export const se_PutDataProtectionPolicyCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Logs_20140328.PutDataProtectionPolicy",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1PutDataProtectionPolicyRequest(input, context));
+    body = JSON.stringify(se_PutDataProtectionPolicyRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1PutDestinationCommand = async (input, context) => {
+export const se_PutDestinationCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Logs_20140328.PutDestination",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1PutDestinationRequest(input, context));
+    body = JSON.stringify(se_PutDestinationRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1PutDestinationPolicyCommand = async (input, context) => {
+export const se_PutDestinationPolicyCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Logs_20140328.PutDestinationPolicy",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1PutDestinationPolicyRequest(input, context));
+    body = JSON.stringify(se_PutDestinationPolicyRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1PutLogEventsCommand = async (input, context) => {
+export const se_PutLogEventsCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Logs_20140328.PutLogEvents",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1PutLogEventsRequest(input, context));
+    body = JSON.stringify(se_PutLogEventsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1PutMetricFilterCommand = async (input, context) => {
+export const se_PutMetricFilterCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Logs_20140328.PutMetricFilter",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1PutMetricFilterRequest(input, context));
+    body = JSON.stringify(se_PutMetricFilterRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1PutQueryDefinitionCommand = async (input, context) => {
+export const se_PutQueryDefinitionCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Logs_20140328.PutQueryDefinition",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1PutQueryDefinitionRequest(input, context));
+    body = JSON.stringify(se_PutQueryDefinitionRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1PutResourcePolicyCommand = async (input, context) => {
+export const se_PutResourcePolicyCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Logs_20140328.PutResourcePolicy",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1PutResourcePolicyRequest(input, context));
+    body = JSON.stringify(se_PutResourcePolicyRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1PutRetentionPolicyCommand = async (input, context) => {
+export const se_PutRetentionPolicyCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Logs_20140328.PutRetentionPolicy",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1PutRetentionPolicyRequest(input, context));
+    body = JSON.stringify(se_PutRetentionPolicyRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1PutSubscriptionFilterCommand = async (input, context) => {
+export const se_PutSubscriptionFilterCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Logs_20140328.PutSubscriptionFilter",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1PutSubscriptionFilterRequest(input, context));
+    body = JSON.stringify(se_PutSubscriptionFilterRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1StartQueryCommand = async (input, context) => {
+export const se_StartQueryCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Logs_20140328.StartQuery",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1StartQueryRequest(input, context));
+    body = JSON.stringify(se_StartQueryRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1StopQueryCommand = async (input, context) => {
+export const se_StopQueryCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Logs_20140328.StopQuery",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1StopQueryRequest(input, context));
+    body = JSON.stringify(se_StopQueryRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1TagLogGroupCommand = async (input, context) => {
+export const se_TagLogGroupCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Logs_20140328.TagLogGroup",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1TagLogGroupRequest(input, context));
+    body = JSON.stringify(se_TagLogGroupRequest(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": "Logs_20140328.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_1TestMetricFilterCommand = async (input, context) => {
+export const se_TestMetricFilterCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Logs_20140328.TestMetricFilter",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1TestMetricFilterRequest(input, context));
+    body = JSON.stringify(se_TestMetricFilterRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1UntagLogGroupCommand = async (input, context) => {
+export const se_UntagLogGroupCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Logs_20140328.UntagLogGroup",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1UntagLogGroupRequest(input, context));
+    body = JSON.stringify(se_UntagLogGroupRequest(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": "Logs_20140328.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 deserializeAws_json1_1AssociateKmsKeyCommand = async (output, context) => {
+export const de_AssociateKmsKeyCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1AssociateKmsKeyCommandError(output, context);
+        return de_AssociateKmsKeyCommandError(output, context);
     }
     await collectBody(output.body, context);
     const response = {
@@ -444,7 +444,7 @@ export const deserializeAws_json1_1AssociateKmsKeyCommand = async (output, conte
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1AssociateKmsKeyCommandError = async (output, context) => {
+const de_AssociateKmsKeyCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -453,16 +453,16 @@ const deserializeAws_json1_1AssociateKmsKeyCommandError = async (output, context
     switch (errorCode) {
         case "InvalidParameterException":
         case "com.amazonaws.cloudwatchlogs#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "OperationAbortedException":
         case "com.amazonaws.cloudwatchlogs#OperationAbortedException":
-            throw await deserializeAws_json1_1OperationAbortedExceptionResponse(parsedOutput, context);
+            throw await de_OperationAbortedExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.cloudwatchlogs#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.cloudwatchlogs#ServiceUnavailableException":
-            throw await deserializeAws_json1_1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -473,9 +473,9 @@ const deserializeAws_json1_1AssociateKmsKeyCommandError = async (output, context
             });
     }
 };
-export const deserializeAws_json1_1CancelExportTaskCommand = async (output, context) => {
+export const de_CancelExportTaskCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1CancelExportTaskCommandError(output, context);
+        return de_CancelExportTaskCommandError(output, context);
     }
     await collectBody(output.body, context);
     const response = {
@@ -483,7 +483,7 @@ export const deserializeAws_json1_1CancelExportTaskCommand = async (output, cont
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1CancelExportTaskCommandError = async (output, context) => {
+const de_CancelExportTaskCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -492,16 +492,16 @@ const deserializeAws_json1_1CancelExportTaskCommandError = async (output, contex
     switch (errorCode) {
         case "InvalidOperationException":
         case "com.amazonaws.cloudwatchlogs#InvalidOperationException":
-            throw await deserializeAws_json1_1InvalidOperationExceptionResponse(parsedOutput, context);
+            throw await de_InvalidOperationExceptionRes(parsedOutput, context);
         case "InvalidParameterException":
         case "com.amazonaws.cloudwatchlogs#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.cloudwatchlogs#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.cloudwatchlogs#ServiceUnavailableException":
-            throw await deserializeAws_json1_1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -512,20 +512,20 @@ const deserializeAws_json1_1CancelExportTaskCommandError = async (output, contex
             });
     }
 };
-export const deserializeAws_json1_1CreateExportTaskCommand = async (output, context) => {
+export const de_CreateExportTaskCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1CreateExportTaskCommandError(output, context);
+        return de_CreateExportTaskCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1CreateExportTaskResponse(data, context);
+    contents = de_CreateExportTaskResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1CreateExportTaskCommandError = async (output, context) => {
+const de_CreateExportTaskCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -534,22 +534,22 @@ const deserializeAws_json1_1CreateExportTaskCommandError = async (output, contex
     switch (errorCode) {
         case "InvalidParameterException":
         case "com.amazonaws.cloudwatchlogs#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "LimitExceededException":
         case "com.amazonaws.cloudwatchlogs#LimitExceededException":
-            throw await deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         case "OperationAbortedException":
         case "com.amazonaws.cloudwatchlogs#OperationAbortedException":
-            throw await deserializeAws_json1_1OperationAbortedExceptionResponse(parsedOutput, context);
+            throw await de_OperationAbortedExceptionRes(parsedOutput, context);
         case "ResourceAlreadyExistsException":
         case "com.amazonaws.cloudwatchlogs#ResourceAlreadyExistsException":
-            throw await deserializeAws_json1_1ResourceAlreadyExistsExceptionResponse(parsedOutput, context);
+            throw await de_ResourceAlreadyExistsExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.cloudwatchlogs#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.cloudwatchlogs#ServiceUnavailableException":
-            throw await deserializeAws_json1_1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -560,9 +560,9 @@ const deserializeAws_json1_1CreateExportTaskCommandError = async (output, contex
             });
     }
 };
-export const deserializeAws_json1_1CreateLogGroupCommand = async (output, context) => {
+export const de_CreateLogGroupCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1CreateLogGroupCommandError(output, context);
+        return de_CreateLogGroupCommandError(output, context);
     }
     await collectBody(output.body, context);
     const response = {
@@ -570,7 +570,7 @@ export const deserializeAws_json1_1CreateLogGroupCommand = async (output, contex
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1CreateLogGroupCommandError = async (output, context) => {
+const de_CreateLogGroupCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -579,19 +579,19 @@ const deserializeAws_json1_1CreateLogGroupCommandError = async (output, context)
     switch (errorCode) {
         case "InvalidParameterException":
         case "com.amazonaws.cloudwatchlogs#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "LimitExceededException":
         case "com.amazonaws.cloudwatchlogs#LimitExceededException":
-            throw await deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         case "OperationAbortedException":
         case "com.amazonaws.cloudwatchlogs#OperationAbortedException":
-            throw await deserializeAws_json1_1OperationAbortedExceptionResponse(parsedOutput, context);
+            throw await de_OperationAbortedExceptionRes(parsedOutput, context);
         case "ResourceAlreadyExistsException":
         case "com.amazonaws.cloudwatchlogs#ResourceAlreadyExistsException":
-            throw await deserializeAws_json1_1ResourceAlreadyExistsExceptionResponse(parsedOutput, context);
+            throw await de_ResourceAlreadyExistsExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.cloudwatchlogs#ServiceUnavailableException":
-            throw await deserializeAws_json1_1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -602,9 +602,9 @@ const deserializeAws_json1_1CreateLogGroupCommandError = async (output, context)
             });
     }
 };
-export const deserializeAws_json1_1CreateLogStreamCommand = async (output, context) => {
+export const de_CreateLogStreamCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1CreateLogStreamCommandError(output, context);
+        return de_CreateLogStreamCommandError(output, context);
     }
     await collectBody(output.body, context);
     const response = {
@@ -612,7 +612,7 @@ export const deserializeAws_json1_1CreateLogStreamCommand = async (output, conte
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1CreateLogStreamCommandError = async (output, context) => {
+const de_CreateLogStreamCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -621,16 +621,16 @@ const deserializeAws_json1_1CreateLogStreamCommandError = async (output, context
     switch (errorCode) {
         case "InvalidParameterException":
         case "com.amazonaws.cloudwatchlogs#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "ResourceAlreadyExistsException":
         case "com.amazonaws.cloudwatchlogs#ResourceAlreadyExistsException":
-            throw await deserializeAws_json1_1ResourceAlreadyExistsExceptionResponse(parsedOutput, context);
+            throw await de_ResourceAlreadyExistsExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.cloudwatchlogs#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.cloudwatchlogs#ServiceUnavailableException":
-            throw await deserializeAws_json1_1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -641,9 +641,9 @@ const deserializeAws_json1_1CreateLogStreamCommandError = async (output, context
             });
     }
 };
-export const deserializeAws_json1_1DeleteDataProtectionPolicyCommand = async (output, context) => {
+export const de_DeleteDataProtectionPolicyCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1DeleteDataProtectionPolicyCommandError(output, context);
+        return de_DeleteDataProtectionPolicyCommandError(output, context);
     }
     await collectBody(output.body, context);
     const response = {
@@ -651,7 +651,7 @@ export const deserializeAws_json1_1DeleteDataProtectionPolicyCommand = async (ou
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1DeleteDataProtectionPolicyCommandError = async (output, context) => {
+const de_DeleteDataProtectionPolicyCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -660,16 +660,16 @@ const deserializeAws_json1_1DeleteDataProtectionPolicyCommandError = async (outp
     switch (errorCode) {
         case "InvalidParameterException":
         case "com.amazonaws.cloudwatchlogs#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "OperationAbortedException":
         case "com.amazonaws.cloudwatchlogs#OperationAbortedException":
-            throw await deserializeAws_json1_1OperationAbortedExceptionResponse(parsedOutput, context);
+            throw await de_OperationAbortedExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.cloudwatchlogs#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.cloudwatchlogs#ServiceUnavailableException":
-            throw await deserializeAws_json1_1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -680,9 +680,9 @@ const deserializeAws_json1_1DeleteDataProtectionPolicyCommandError = async (outp
             });
     }
 };
-export const deserializeAws_json1_1DeleteDestinationCommand = async (output, context) => {
+export const de_DeleteDestinationCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1DeleteDestinationCommandError(output, context);
+        return de_DeleteDestinationCommandError(output, context);
     }
     await collectBody(output.body, context);
     const response = {
@@ -690,7 +690,7 @@ export const deserializeAws_json1_1DeleteDestinationCommand = async (output, con
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1DeleteDestinationCommandError = async (output, context) => {
+const de_DeleteDestinationCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -699,16 +699,16 @@ const deserializeAws_json1_1DeleteDestinationCommandError = async (output, conte
     switch (errorCode) {
         case "InvalidParameterException":
         case "com.amazonaws.cloudwatchlogs#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "OperationAbortedException":
         case "com.amazonaws.cloudwatchlogs#OperationAbortedException":
-            throw await deserializeAws_json1_1OperationAbortedExceptionResponse(parsedOutput, context);
+            throw await de_OperationAbortedExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.cloudwatchlogs#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.cloudwatchlogs#ServiceUnavailableException":
-            throw await deserializeAws_json1_1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -719,9 +719,9 @@ const deserializeAws_json1_1DeleteDestinationCommandError = async (output, conte
             });
     }
 };
-export const deserializeAws_json1_1DeleteLogGroupCommand = async (output, context) => {
+export const de_DeleteLogGroupCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1DeleteLogGroupCommandError(output, context);
+        return de_DeleteLogGroupCommandError(output, context);
     }
     await collectBody(output.body, context);
     const response = {
@@ -729,7 +729,7 @@ export const deserializeAws_json1_1DeleteLogGroupCommand = async (output, contex
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1DeleteLogGroupCommandError = async (output, context) => {
+const de_DeleteLogGroupCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -738,16 +738,16 @@ const deserializeAws_json1_1DeleteLogGroupCommandError = async (output, context)
     switch (errorCode) {
         case "InvalidParameterException":
         case "com.amazonaws.cloudwatchlogs#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "OperationAbortedException":
         case "com.amazonaws.cloudwatchlogs#OperationAbortedException":
-            throw await deserializeAws_json1_1OperationAbortedExceptionResponse(parsedOutput, context);
+            throw await de_OperationAbortedExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.cloudwatchlogs#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.cloudwatchlogs#ServiceUnavailableException":
-            throw await deserializeAws_json1_1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -758,9 +758,9 @@ const deserializeAws_json1_1DeleteLogGroupCommandError = async (output, context)
             });
     }
 };
-export const deserializeAws_json1_1DeleteLogStreamCommand = async (output, context) => {
+export const de_DeleteLogStreamCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1DeleteLogStreamCommandError(output, context);
+        return de_DeleteLogStreamCommandError(output, context);
     }
     await collectBody(output.body, context);
     const response = {
@@ -768,7 +768,7 @@ export const deserializeAws_json1_1DeleteLogStreamCommand = async (output, conte
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1DeleteLogStreamCommandError = async (output, context) => {
+const de_DeleteLogStreamCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -777,16 +777,16 @@ const deserializeAws_json1_1DeleteLogStreamCommandError = async (output, context
     switch (errorCode) {
         case "InvalidParameterException":
         case "com.amazonaws.cloudwatchlogs#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "OperationAbortedException":
         case "com.amazonaws.cloudwatchlogs#OperationAbortedException":
-            throw await deserializeAws_json1_1OperationAbortedExceptionResponse(parsedOutput, context);
+            throw await de_OperationAbortedExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.cloudwatchlogs#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.cloudwatchlogs#ServiceUnavailableException":
-            throw await deserializeAws_json1_1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -797,9 +797,9 @@ const deserializeAws_json1_1DeleteLogStreamCommandError = async (output, context
             });
     }
 };
-export const deserializeAws_json1_1DeleteMetricFilterCommand = async (output, context) => {
+export const de_DeleteMetricFilterCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1DeleteMetricFilterCommandError(output, context);
+        return de_DeleteMetricFilterCommandError(output, context);
     }
     await collectBody(output.body, context);
     const response = {
@@ -807,7 +807,7 @@ export const deserializeAws_json1_1DeleteMetricFilterCommand = async (output, co
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1DeleteMetricFilterCommandError = async (output, context) => {
+const de_DeleteMetricFilterCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -816,16 +816,16 @@ const deserializeAws_json1_1DeleteMetricFilterCommandError = async (output, cont
     switch (errorCode) {
         case "InvalidParameterException":
         case "com.amazonaws.cloudwatchlogs#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "OperationAbortedException":
         case "com.amazonaws.cloudwatchlogs#OperationAbortedException":
-            throw await deserializeAws_json1_1OperationAbortedExceptionResponse(parsedOutput, context);
+            throw await de_OperationAbortedExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.cloudwatchlogs#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.cloudwatchlogs#ServiceUnavailableException":
-            throw await deserializeAws_json1_1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -836,20 +836,20 @@ const deserializeAws_json1_1DeleteMetricFilterCommandError = async (output, cont
             });
     }
 };
-export const deserializeAws_json1_1DeleteQueryDefinitionCommand = async (output, context) => {
+export const de_DeleteQueryDefinitionCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1DeleteQueryDefinitionCommandError(output, context);
+        return de_DeleteQueryDefinitionCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1DeleteQueryDefinitionResponse(data, context);
+    contents = de_DeleteQueryDefinitionResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1DeleteQueryDefinitionCommandError = async (output, context) => {
+const de_DeleteQueryDefinitionCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -858,13 +858,13 @@ const deserializeAws_json1_1DeleteQueryDefinitionCommandError = async (output, c
     switch (errorCode) {
         case "InvalidParameterException":
         case "com.amazonaws.cloudwatchlogs#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.cloudwatchlogs#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.cloudwatchlogs#ServiceUnavailableException":
-            throw await deserializeAws_json1_1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -875,9 +875,9 @@ const deserializeAws_json1_1DeleteQueryDefinitionCommandError = async (output, c
             });
     }
 };
-export const deserializeAws_json1_1DeleteResourcePolicyCommand = async (output, context) => {
+export const de_DeleteResourcePolicyCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1DeleteResourcePolicyCommandError(output, context);
+        return de_DeleteResourcePolicyCommandError(output, context);
     }
     await collectBody(output.body, context);
     const response = {
@@ -885,7 +885,7 @@ export const deserializeAws_json1_1DeleteResourcePolicyCommand = async (output,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1DeleteResourcePolicyCommandError = async (output, context) => {
+const de_DeleteResourcePolicyCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -894,13 +894,13 @@ const deserializeAws_json1_1DeleteResourcePolicyCommandError = async (output, co
     switch (errorCode) {
         case "InvalidParameterException":
         case "com.amazonaws.cloudwatchlogs#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.cloudwatchlogs#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.cloudwatchlogs#ServiceUnavailableException":
-            throw await deserializeAws_json1_1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -911,9 +911,9 @@ const deserializeAws_json1_1DeleteResourcePolicyCommandError = async (output, co
             });
     }
 };
-export const deserializeAws_json1_1DeleteRetentionPolicyCommand = async (output, context) => {
+export const de_DeleteRetentionPolicyCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1DeleteRetentionPolicyCommandError(output, context);
+        return de_DeleteRetentionPolicyCommandError(output, context);
     }
     await collectBody(output.body, context);
     const response = {
@@ -921,7 +921,7 @@ export const deserializeAws_json1_1DeleteRetentionPolicyCommand = async (output,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1DeleteRetentionPolicyCommandError = async (output, context) => {
+const de_DeleteRetentionPolicyCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -930,16 +930,16 @@ const deserializeAws_json1_1DeleteRetentionPolicyCommandError = async (output, c
     switch (errorCode) {
         case "InvalidParameterException":
         case "com.amazonaws.cloudwatchlogs#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "OperationAbortedException":
         case "com.amazonaws.cloudwatchlogs#OperationAbortedException":
-            throw await deserializeAws_json1_1OperationAbortedExceptionResponse(parsedOutput, context);
+            throw await de_OperationAbortedExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.cloudwatchlogs#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.cloudwatchlogs#ServiceUnavailableException":
-            throw await deserializeAws_json1_1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -950,9 +950,9 @@ const deserializeAws_json1_1DeleteRetentionPolicyCommandError = async (output, c
             });
     }
 };
-export const deserializeAws_json1_1DeleteSubscriptionFilterCommand = async (output, context) => {
+export const de_DeleteSubscriptionFilterCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1DeleteSubscriptionFilterCommandError(output, context);
+        return de_DeleteSubscriptionFilterCommandError(output, context);
     }
     await collectBody(output.body, context);
     const response = {
@@ -960,7 +960,7 @@ export const deserializeAws_json1_1DeleteSubscriptionFilterCommand = async (outp
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1DeleteSubscriptionFilterCommandError = async (output, context) => {
+const de_DeleteSubscriptionFilterCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -969,16 +969,16 @@ const deserializeAws_json1_1DeleteSubscriptionFilterCommandError = async (output
     switch (errorCode) {
         case "InvalidParameterException":
         case "com.amazonaws.cloudwatchlogs#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "OperationAbortedException":
         case "com.amazonaws.cloudwatchlogs#OperationAbortedException":
-            throw await deserializeAws_json1_1OperationAbortedExceptionResponse(parsedOutput, context);
+            throw await de_OperationAbortedExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.cloudwatchlogs#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.cloudwatchlogs#ServiceUnavailableException":
-            throw await deserializeAws_json1_1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -989,20 +989,20 @@ const deserializeAws_json1_1DeleteSubscriptionFilterCommandError = async (output
             });
     }
 };
-export const deserializeAws_json1_1DescribeDestinationsCommand = async (output, context) => {
+export const de_DescribeDestinationsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1DescribeDestinationsCommandError(output, context);
+        return de_DescribeDestinationsCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1DescribeDestinationsResponse(data, context);
+    contents = de_DescribeDestinationsResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1DescribeDestinationsCommandError = async (output, context) => {
+const de_DescribeDestinationsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1011,10 +1011,10 @@ const deserializeAws_json1_1DescribeDestinationsCommandError = async (output, co
     switch (errorCode) {
         case "InvalidParameterException":
         case "com.amazonaws.cloudwatchlogs#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.cloudwatchlogs#ServiceUnavailableException":
-            throw await deserializeAws_json1_1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1025,20 +1025,20 @@ const deserializeAws_json1_1DescribeDestinationsCommandError = async (output, co
             });
     }
 };
-export const deserializeAws_json1_1DescribeExportTasksCommand = async (output, context) => {
+export const de_DescribeExportTasksCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1DescribeExportTasksCommandError(output, context);
+        return de_DescribeExportTasksCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1DescribeExportTasksResponse(data, context);
+    contents = de_DescribeExportTasksResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1DescribeExportTasksCommandError = async (output, context) => {
+const de_DescribeExportTasksCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1047,10 +1047,10 @@ const deserializeAws_json1_1DescribeExportTasksCommandError = async (output, con
     switch (errorCode) {
         case "InvalidParameterException":
         case "com.amazonaws.cloudwatchlogs#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.cloudwatchlogs#ServiceUnavailableException":
-            throw await deserializeAws_json1_1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1061,20 +1061,20 @@ const deserializeAws_json1_1DescribeExportTasksCommandError = async (output, con
             });
     }
 };
-export const deserializeAws_json1_1DescribeLogGroupsCommand = async (output, context) => {
+export const de_DescribeLogGroupsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1DescribeLogGroupsCommandError(output, context);
+        return de_DescribeLogGroupsCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1DescribeLogGroupsResponse(data, context);
+    contents = de_DescribeLogGroupsResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1DescribeLogGroupsCommandError = async (output, context) => {
+const de_DescribeLogGroupsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1083,10 +1083,10 @@ const deserializeAws_json1_1DescribeLogGroupsCommandError = async (output, conte
     switch (errorCode) {
         case "InvalidParameterException":
         case "com.amazonaws.cloudwatchlogs#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.cloudwatchlogs#ServiceUnavailableException":
-            throw await deserializeAws_json1_1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1097,20 +1097,20 @@ const deserializeAws_json1_1DescribeLogGroupsCommandError = async (output, conte
             });
     }
 };
-export const deserializeAws_json1_1DescribeLogStreamsCommand = async (output, context) => {
+export const de_DescribeLogStreamsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1DescribeLogStreamsCommandError(output, context);
+        return de_DescribeLogStreamsCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1DescribeLogStreamsResponse(data, context);
+    contents = de_DescribeLogStreamsResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1DescribeLogStreamsCommandError = async (output, context) => {
+const de_DescribeLogStreamsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1119,13 +1119,13 @@ const deserializeAws_json1_1DescribeLogStreamsCommandError = async (output, cont
     switch (errorCode) {
         case "InvalidParameterException":
         case "com.amazonaws.cloudwatchlogs#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.cloudwatchlogs#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.cloudwatchlogs#ServiceUnavailableException":
-            throw await deserializeAws_json1_1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1136,20 +1136,20 @@ const deserializeAws_json1_1DescribeLogStreamsCommandError = async (output, cont
             });
     }
 };
-export const deserializeAws_json1_1DescribeMetricFiltersCommand = async (output, context) => {
+export const de_DescribeMetricFiltersCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1DescribeMetricFiltersCommandError(output, context);
+        return de_DescribeMetricFiltersCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1DescribeMetricFiltersResponse(data, context);
+    contents = de_DescribeMetricFiltersResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1DescribeMetricFiltersCommandError = async (output, context) => {
+const de_DescribeMetricFiltersCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1158,13 +1158,13 @@ const deserializeAws_json1_1DescribeMetricFiltersCommandError = async (output, c
     switch (errorCode) {
         case "InvalidParameterException":
         case "com.amazonaws.cloudwatchlogs#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.cloudwatchlogs#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.cloudwatchlogs#ServiceUnavailableException":
-            throw await deserializeAws_json1_1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1175,20 +1175,20 @@ const deserializeAws_json1_1DescribeMetricFiltersCommandError = async (output, c
             });
     }
 };
-export const deserializeAws_json1_1DescribeQueriesCommand = async (output, context) => {
+export const de_DescribeQueriesCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1DescribeQueriesCommandError(output, context);
+        return de_DescribeQueriesCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1DescribeQueriesResponse(data, context);
+    contents = de_DescribeQueriesResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1DescribeQueriesCommandError = async (output, context) => {
+const de_DescribeQueriesCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1197,13 +1197,13 @@ const deserializeAws_json1_1DescribeQueriesCommandError = async (output, context
     switch (errorCode) {
         case "InvalidParameterException":
         case "com.amazonaws.cloudwatchlogs#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.cloudwatchlogs#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.cloudwatchlogs#ServiceUnavailableException":
-            throw await deserializeAws_json1_1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1214,20 +1214,20 @@ const deserializeAws_json1_1DescribeQueriesCommandError = async (output, context
             });
     }
 };
-export const deserializeAws_json1_1DescribeQueryDefinitionsCommand = async (output, context) => {
+export const de_DescribeQueryDefinitionsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1DescribeQueryDefinitionsCommandError(output, context);
+        return de_DescribeQueryDefinitionsCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1DescribeQueryDefinitionsResponse(data, context);
+    contents = de_DescribeQueryDefinitionsResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1DescribeQueryDefinitionsCommandError = async (output, context) => {
+const de_DescribeQueryDefinitionsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1236,10 +1236,10 @@ const deserializeAws_json1_1DescribeQueryDefinitionsCommandError = async (output
     switch (errorCode) {
         case "InvalidParameterException":
         case "com.amazonaws.cloudwatchlogs#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.cloudwatchlogs#ServiceUnavailableException":
-            throw await deserializeAws_json1_1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1250,20 +1250,20 @@ const deserializeAws_json1_1DescribeQueryDefinitionsCommandError = async (output
             });
     }
 };
-export const deserializeAws_json1_1DescribeResourcePoliciesCommand = async (output, context) => {
+export const de_DescribeResourcePoliciesCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1DescribeResourcePoliciesCommandError(output, context);
+        return de_DescribeResourcePoliciesCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1DescribeResourcePoliciesResponse(data, context);
+    contents = de_DescribeResourcePoliciesResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1DescribeResourcePoliciesCommandError = async (output, context) => {
+const de_DescribeResourcePoliciesCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1272,10 +1272,10 @@ const deserializeAws_json1_1DescribeResourcePoliciesCommandError = async (output
     switch (errorCode) {
         case "InvalidParameterException":
         case "com.amazonaws.cloudwatchlogs#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.cloudwatchlogs#ServiceUnavailableException":
-            throw await deserializeAws_json1_1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1286,20 +1286,20 @@ const deserializeAws_json1_1DescribeResourcePoliciesCommandError = async (output
             });
     }
 };
-export const deserializeAws_json1_1DescribeSubscriptionFiltersCommand = async (output, context) => {
+export const de_DescribeSubscriptionFiltersCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1DescribeSubscriptionFiltersCommandError(output, context);
+        return de_DescribeSubscriptionFiltersCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1DescribeSubscriptionFiltersResponse(data, context);
+    contents = de_DescribeSubscriptionFiltersResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1DescribeSubscriptionFiltersCommandError = async (output, context) => {
+const de_DescribeSubscriptionFiltersCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1308,13 +1308,13 @@ const deserializeAws_json1_1DescribeSubscriptionFiltersCommandError = async (out
     switch (errorCode) {
         case "InvalidParameterException":
         case "com.amazonaws.cloudwatchlogs#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.cloudwatchlogs#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.cloudwatchlogs#ServiceUnavailableException":
-            throw await deserializeAws_json1_1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1325,9 +1325,9 @@ const deserializeAws_json1_1DescribeSubscriptionFiltersCommandError = async (out
             });
     }
 };
-export const deserializeAws_json1_1DisassociateKmsKeyCommand = async (output, context) => {
+export const de_DisassociateKmsKeyCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1DisassociateKmsKeyCommandError(output, context);
+        return de_DisassociateKmsKeyCommandError(output, context);
     }
     await collectBody(output.body, context);
     const response = {
@@ -1335,7 +1335,7 @@ export const deserializeAws_json1_1DisassociateKmsKeyCommand = async (output, co
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1DisassociateKmsKeyCommandError = async (output, context) => {
+const de_DisassociateKmsKeyCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1344,16 +1344,16 @@ const deserializeAws_json1_1DisassociateKmsKeyCommandError = async (output, cont
     switch (errorCode) {
         case "InvalidParameterException":
         case "com.amazonaws.cloudwatchlogs#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "OperationAbortedException":
         case "com.amazonaws.cloudwatchlogs#OperationAbortedException":
-            throw await deserializeAws_json1_1OperationAbortedExceptionResponse(parsedOutput, context);
+            throw await de_OperationAbortedExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.cloudwatchlogs#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.cloudwatchlogs#ServiceUnavailableException":
-            throw await deserializeAws_json1_1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1364,20 +1364,20 @@ const deserializeAws_json1_1DisassociateKmsKeyCommandError = async (output, cont
             });
     }
 };
-export const deserializeAws_json1_1FilterLogEventsCommand = async (output, context) => {
+export const de_FilterLogEventsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1FilterLogEventsCommandError(output, context);
+        return de_FilterLogEventsCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1FilterLogEventsResponse(data, context);
+    contents = de_FilterLogEventsResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1FilterLogEventsCommandError = async (output, context) => {
+const de_FilterLogEventsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1386,13 +1386,13 @@ const deserializeAws_json1_1FilterLogEventsCommandError = async (output, context
     switch (errorCode) {
         case "InvalidParameterException":
         case "com.amazonaws.cloudwatchlogs#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.cloudwatchlogs#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.cloudwatchlogs#ServiceUnavailableException":
-            throw await deserializeAws_json1_1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1403,20 +1403,20 @@ const deserializeAws_json1_1FilterLogEventsCommandError = async (output, context
             });
     }
 };
-export const deserializeAws_json1_1GetDataProtectionPolicyCommand = async (output, context) => {
+export const de_GetDataProtectionPolicyCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1GetDataProtectionPolicyCommandError(output, context);
+        return de_GetDataProtectionPolicyCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1GetDataProtectionPolicyResponse(data, context);
+    contents = de_GetDataProtectionPolicyResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1GetDataProtectionPolicyCommandError = async (output, context) => {
+const de_GetDataProtectionPolicyCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1425,16 +1425,16 @@ const deserializeAws_json1_1GetDataProtectionPolicyCommandError = async (output,
     switch (errorCode) {
         case "InvalidParameterException":
         case "com.amazonaws.cloudwatchlogs#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "OperationAbortedException":
         case "com.amazonaws.cloudwatchlogs#OperationAbortedException":
-            throw await deserializeAws_json1_1OperationAbortedExceptionResponse(parsedOutput, context);
+            throw await de_OperationAbortedExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.cloudwatchlogs#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.cloudwatchlogs#ServiceUnavailableException":
-            throw await deserializeAws_json1_1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1445,20 +1445,20 @@ const deserializeAws_json1_1GetDataProtectionPolicyCommandError = async (output,
             });
     }
 };
-export const deserializeAws_json1_1GetLogEventsCommand = async (output, context) => {
+export const de_GetLogEventsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1GetLogEventsCommandError(output, context);
+        return de_GetLogEventsCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1GetLogEventsResponse(data, context);
+    contents = de_GetLogEventsResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1GetLogEventsCommandError = async (output, context) => {
+const de_GetLogEventsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1467,13 +1467,13 @@ const deserializeAws_json1_1GetLogEventsCommandError = async (output, context) =
     switch (errorCode) {
         case "InvalidParameterException":
         case "com.amazonaws.cloudwatchlogs#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.cloudwatchlogs#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.cloudwatchlogs#ServiceUnavailableException":
-            throw await deserializeAws_json1_1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1484,20 +1484,20 @@ const deserializeAws_json1_1GetLogEventsCommandError = async (output, context) =
             });
     }
 };
-export const deserializeAws_json1_1GetLogGroupFieldsCommand = async (output, context) => {
+export const de_GetLogGroupFieldsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1GetLogGroupFieldsCommandError(output, context);
+        return de_GetLogGroupFieldsCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1GetLogGroupFieldsResponse(data, context);
+    contents = de_GetLogGroupFieldsResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1GetLogGroupFieldsCommandError = async (output, context) => {
+const de_GetLogGroupFieldsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1506,16 +1506,16 @@ const deserializeAws_json1_1GetLogGroupFieldsCommandError = async (output, conte
     switch (errorCode) {
         case "InvalidParameterException":
         case "com.amazonaws.cloudwatchlogs#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "LimitExceededException":
         case "com.amazonaws.cloudwatchlogs#LimitExceededException":
-            throw await deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.cloudwatchlogs#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.cloudwatchlogs#ServiceUnavailableException":
-            throw await deserializeAws_json1_1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1526,20 +1526,20 @@ const deserializeAws_json1_1GetLogGroupFieldsCommandError = async (output, conte
             });
     }
 };
-export const deserializeAws_json1_1GetLogRecordCommand = async (output, context) => {
+export const de_GetLogRecordCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1GetLogRecordCommandError(output, context);
+        return de_GetLogRecordCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1GetLogRecordResponse(data, context);
+    contents = de_GetLogRecordResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1GetLogRecordCommandError = async (output, context) => {
+const de_GetLogRecordCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1548,16 +1548,16 @@ const deserializeAws_json1_1GetLogRecordCommandError = async (output, context) =
     switch (errorCode) {
         case "InvalidParameterException":
         case "com.amazonaws.cloudwatchlogs#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "LimitExceededException":
         case "com.amazonaws.cloudwatchlogs#LimitExceededException":
-            throw await deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.cloudwatchlogs#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.cloudwatchlogs#ServiceUnavailableException":
-            throw await deserializeAws_json1_1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1568,20 +1568,20 @@ const deserializeAws_json1_1GetLogRecordCommandError = async (output, context) =
             });
     }
 };
-export const deserializeAws_json1_1GetQueryResultsCommand = async (output, context) => {
+export const de_GetQueryResultsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1GetQueryResultsCommandError(output, context);
+        return de_GetQueryResultsCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1GetQueryResultsResponse(data, context);
+    contents = de_GetQueryResultsResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1GetQueryResultsCommandError = async (output, context) => {
+const de_GetQueryResultsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1590,13 +1590,13 @@ const deserializeAws_json1_1GetQueryResultsCommandError = async (output, context
     switch (errorCode) {
         case "InvalidParameterException":
         case "com.amazonaws.cloudwatchlogs#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.cloudwatchlogs#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.cloudwatchlogs#ServiceUnavailableException":
-            throw await deserializeAws_json1_1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1607,20 +1607,20 @@ const deserializeAws_json1_1GetQueryResultsCommandError = async (output, context
             });
     }
 };
-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),
@@ -1629,13 +1629,13 @@ const deserializeAws_json1_1ListTagsForResourceCommandError = async (output, con
     switch (errorCode) {
         case "InvalidParameterException":
         case "com.amazonaws.cloudwatchlogs#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.cloudwatchlogs#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.cloudwatchlogs#ServiceUnavailableException":
-            throw await deserializeAws_json1_1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1646,20 +1646,20 @@ const deserializeAws_json1_1ListTagsForResourceCommandError = async (output, con
             });
     }
 };
-export const deserializeAws_json1_1ListTagsLogGroupCommand = async (output, context) => {
+export const de_ListTagsLogGroupCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1ListTagsLogGroupCommandError(output, context);
+        return de_ListTagsLogGroupCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1ListTagsLogGroupResponse(data, context);
+    contents = de_ListTagsLogGroupResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1ListTagsLogGroupCommandError = async (output, context) => {
+const de_ListTagsLogGroupCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1668,10 +1668,10 @@ const deserializeAws_json1_1ListTagsLogGroupCommandError = async (output, contex
     switch (errorCode) {
         case "ResourceNotFoundException":
         case "com.amazonaws.cloudwatchlogs#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.cloudwatchlogs#ServiceUnavailableException":
-            throw await deserializeAws_json1_1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1682,20 +1682,20 @@ const deserializeAws_json1_1ListTagsLogGroupCommandError = async (output, contex
             });
     }
 };
-export const deserializeAws_json1_1PutDataProtectionPolicyCommand = async (output, context) => {
+export const de_PutDataProtectionPolicyCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1PutDataProtectionPolicyCommandError(output, context);
+        return de_PutDataProtectionPolicyCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1PutDataProtectionPolicyResponse(data, context);
+    contents = de_PutDataProtectionPolicyResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1PutDataProtectionPolicyCommandError = async (output, context) => {
+const de_PutDataProtectionPolicyCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1704,19 +1704,19 @@ const deserializeAws_json1_1PutDataProtectionPolicyCommandError = async (output,
     switch (errorCode) {
         case "InvalidParameterException":
         case "com.amazonaws.cloudwatchlogs#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "LimitExceededException":
         case "com.amazonaws.cloudwatchlogs#LimitExceededException":
-            throw await deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         case "OperationAbortedException":
         case "com.amazonaws.cloudwatchlogs#OperationAbortedException":
-            throw await deserializeAws_json1_1OperationAbortedExceptionResponse(parsedOutput, context);
+            throw await de_OperationAbortedExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.cloudwatchlogs#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.cloudwatchlogs#ServiceUnavailableException":
-            throw await deserializeAws_json1_1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1727,20 +1727,20 @@ const deserializeAws_json1_1PutDataProtectionPolicyCommandError = async (output,
             });
     }
 };
-export const deserializeAws_json1_1PutDestinationCommand = async (output, context) => {
+export const de_PutDestinationCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1PutDestinationCommandError(output, context);
+        return de_PutDestinationCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1PutDestinationResponse(data, context);
+    contents = de_PutDestinationResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1PutDestinationCommandError = async (output, context) => {
+const de_PutDestinationCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1749,13 +1749,13 @@ const deserializeAws_json1_1PutDestinationCommandError = async (output, context)
     switch (errorCode) {
         case "InvalidParameterException":
         case "com.amazonaws.cloudwatchlogs#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "OperationAbortedException":
         case "com.amazonaws.cloudwatchlogs#OperationAbortedException":
-            throw await deserializeAws_json1_1OperationAbortedExceptionResponse(parsedOutput, context);
+            throw await de_OperationAbortedExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.cloudwatchlogs#ServiceUnavailableException":
-            throw await deserializeAws_json1_1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1766,9 +1766,9 @@ const deserializeAws_json1_1PutDestinationCommandError = async (output, context)
             });
     }
 };
-export const deserializeAws_json1_1PutDestinationPolicyCommand = async (output, context) => {
+export const de_PutDestinationPolicyCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1PutDestinationPolicyCommandError(output, context);
+        return de_PutDestinationPolicyCommandError(output, context);
     }
     await collectBody(output.body, context);
     const response = {
@@ -1776,7 +1776,7 @@ export const deserializeAws_json1_1PutDestinationPolicyCommand = async (output,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1PutDestinationPolicyCommandError = async (output, context) => {
+const de_PutDestinationPolicyCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1785,13 +1785,13 @@ const deserializeAws_json1_1PutDestinationPolicyCommandError = async (output, co
     switch (errorCode) {
         case "InvalidParameterException":
         case "com.amazonaws.cloudwatchlogs#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "OperationAbortedException":
         case "com.amazonaws.cloudwatchlogs#OperationAbortedException":
-            throw await deserializeAws_json1_1OperationAbortedExceptionResponse(parsedOutput, context);
+            throw await de_OperationAbortedExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.cloudwatchlogs#ServiceUnavailableException":
-            throw await deserializeAws_json1_1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1802,20 +1802,20 @@ const deserializeAws_json1_1PutDestinationPolicyCommandError = async (output, co
             });
     }
 };
-export const deserializeAws_json1_1PutLogEventsCommand = async (output, context) => {
+export const de_PutLogEventsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1PutLogEventsCommandError(output, context);
+        return de_PutLogEventsCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1PutLogEventsResponse(data, context);
+    contents = de_PutLogEventsResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1PutLogEventsCommandError = async (output, context) => {
+const de_PutLogEventsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1824,22 +1824,22 @@ const deserializeAws_json1_1PutLogEventsCommandError = async (output, context) =
     switch (errorCode) {
         case "DataAlreadyAcceptedException":
         case "com.amazonaws.cloudwatchlogs#DataAlreadyAcceptedException":
-            throw await deserializeAws_json1_1DataAlreadyAcceptedExceptionResponse(parsedOutput, context);
+            throw await de_DataAlreadyAcceptedExceptionRes(parsedOutput, context);
         case "InvalidParameterException":
         case "com.amazonaws.cloudwatchlogs#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "InvalidSequenceTokenException":
         case "com.amazonaws.cloudwatchlogs#InvalidSequenceTokenException":
-            throw await deserializeAws_json1_1InvalidSequenceTokenExceptionResponse(parsedOutput, context);
+            throw await de_InvalidSequenceTokenExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.cloudwatchlogs#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.cloudwatchlogs#ServiceUnavailableException":
-            throw await deserializeAws_json1_1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         case "UnrecognizedClientException":
         case "com.amazonaws.cloudwatchlogs#UnrecognizedClientException":
-            throw await deserializeAws_json1_1UnrecognizedClientExceptionResponse(parsedOutput, context);
+            throw await de_UnrecognizedClientExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1850,9 +1850,9 @@ const deserializeAws_json1_1PutLogEventsCommandError = async (output, context) =
             });
     }
 };
-export const deserializeAws_json1_1PutMetricFilterCommand = async (output, context) => {
+export const de_PutMetricFilterCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1PutMetricFilterCommandError(output, context);
+        return de_PutMetricFilterCommandError(output, context);
     }
     await collectBody(output.body, context);
     const response = {
@@ -1860,7 +1860,7 @@ export const deserializeAws_json1_1PutMetricFilterCommand = async (output, conte
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1PutMetricFilterCommandError = async (output, context) => {
+const de_PutMetricFilterCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1869,19 +1869,19 @@ const deserializeAws_json1_1PutMetricFilterCommandError = async (output, context
     switch (errorCode) {
         case "InvalidParameterException":
         case "com.amazonaws.cloudwatchlogs#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "LimitExceededException":
         case "com.amazonaws.cloudwatchlogs#LimitExceededException":
-            throw await deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         case "OperationAbortedException":
         case "com.amazonaws.cloudwatchlogs#OperationAbortedException":
-            throw await deserializeAws_json1_1OperationAbortedExceptionResponse(parsedOutput, context);
+            throw await de_OperationAbortedExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.cloudwatchlogs#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.cloudwatchlogs#ServiceUnavailableException":
-            throw await deserializeAws_json1_1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1892,20 +1892,20 @@ const deserializeAws_json1_1PutMetricFilterCommandError = async (output, context
             });
     }
 };
-export const deserializeAws_json1_1PutQueryDefinitionCommand = async (output, context) => {
+export const de_PutQueryDefinitionCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1PutQueryDefinitionCommandError(output, context);
+        return de_PutQueryDefinitionCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1PutQueryDefinitionResponse(data, context);
+    contents = de_PutQueryDefinitionResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1PutQueryDefinitionCommandError = async (output, context) => {
+const de_PutQueryDefinitionCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1914,16 +1914,16 @@ const deserializeAws_json1_1PutQueryDefinitionCommandError = async (output, cont
     switch (errorCode) {
         case "InvalidParameterException":
         case "com.amazonaws.cloudwatchlogs#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "LimitExceededException":
         case "com.amazonaws.cloudwatchlogs#LimitExceededException":
-            throw await deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.cloudwatchlogs#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.cloudwatchlogs#ServiceUnavailableException":
-            throw await deserializeAws_json1_1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1934,20 +1934,20 @@ const deserializeAws_json1_1PutQueryDefinitionCommandError = async (output, cont
             });
     }
 };
-export const deserializeAws_json1_1PutResourcePolicyCommand = async (output, context) => {
+export const de_PutResourcePolicyCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1PutResourcePolicyCommandError(output, context);
+        return de_PutResourcePolicyCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1PutResourcePolicyResponse(data, context);
+    contents = de_PutResourcePolicyResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1PutResourcePolicyCommandError = async (output, context) => {
+const de_PutResourcePolicyCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1956,13 +1956,13 @@ const deserializeAws_json1_1PutResourcePolicyCommandError = async (output, conte
     switch (errorCode) {
         case "InvalidParameterException":
         case "com.amazonaws.cloudwatchlogs#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "LimitExceededException":
         case "com.amazonaws.cloudwatchlogs#LimitExceededException":
-            throw await deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.cloudwatchlogs#ServiceUnavailableException":
-            throw await deserializeAws_json1_1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1973,9 +1973,9 @@ const deserializeAws_json1_1PutResourcePolicyCommandError = async (output, conte
             });
     }
 };
-export const deserializeAws_json1_1PutRetentionPolicyCommand = async (output, context) => {
+export const de_PutRetentionPolicyCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1PutRetentionPolicyCommandError(output, context);
+        return de_PutRetentionPolicyCommandError(output, context);
     }
     await collectBody(output.body, context);
     const response = {
@@ -1983,7 +1983,7 @@ export const deserializeAws_json1_1PutRetentionPolicyCommand = async (output, co
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1PutRetentionPolicyCommandError = async (output, context) => {
+const de_PutRetentionPolicyCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1992,16 +1992,16 @@ const deserializeAws_json1_1PutRetentionPolicyCommandError = async (output, cont
     switch (errorCode) {
         case "InvalidParameterException":
         case "com.amazonaws.cloudwatchlogs#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "OperationAbortedException":
         case "com.amazonaws.cloudwatchlogs#OperationAbortedException":
-            throw await deserializeAws_json1_1OperationAbortedExceptionResponse(parsedOutput, context);
+            throw await de_OperationAbortedExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.cloudwatchlogs#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.cloudwatchlogs#ServiceUnavailableException":
-            throw await deserializeAws_json1_1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2012,9 +2012,9 @@ const deserializeAws_json1_1PutRetentionPolicyCommandError = async (output, cont
             });
     }
 };
-export const deserializeAws_json1_1PutSubscriptionFilterCommand = async (output, context) => {
+export const de_PutSubscriptionFilterCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1PutSubscriptionFilterCommandError(output, context);
+        return de_PutSubscriptionFilterCommandError(output, context);
     }
     await collectBody(output.body, context);
     const response = {
@@ -2022,7 +2022,7 @@ export const deserializeAws_json1_1PutSubscriptionFilterCommand = async (output,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1PutSubscriptionFilterCommandError = async (output, context) => {
+const de_PutSubscriptionFilterCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2031,19 +2031,19 @@ const deserializeAws_json1_1PutSubscriptionFilterCommandError = async (output, c
     switch (errorCode) {
         case "InvalidParameterException":
         case "com.amazonaws.cloudwatchlogs#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "LimitExceededException":
         case "com.amazonaws.cloudwatchlogs#LimitExceededException":
-            throw await deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         case "OperationAbortedException":
         case "com.amazonaws.cloudwatchlogs#OperationAbortedException":
-            throw await deserializeAws_json1_1OperationAbortedExceptionResponse(parsedOutput, context);
+            throw await de_OperationAbortedExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.cloudwatchlogs#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.cloudwatchlogs#ServiceUnavailableException":
-            throw await deserializeAws_json1_1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2054,20 +2054,20 @@ const deserializeAws_json1_1PutSubscriptionFilterCommandError = async (output, c
             });
     }
 };
-export const deserializeAws_json1_1StartQueryCommand = async (output, context) => {
+export const de_StartQueryCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1StartQueryCommandError(output, context);
+        return de_StartQueryCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1StartQueryResponse(data, context);
+    contents = de_StartQueryResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1StartQueryCommandError = async (output, context) => {
+const de_StartQueryCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2076,19 +2076,19 @@ const deserializeAws_json1_1StartQueryCommandError = async (output, context) =>
     switch (errorCode) {
         case "InvalidParameterException":
         case "com.amazonaws.cloudwatchlogs#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "LimitExceededException":
         case "com.amazonaws.cloudwatchlogs#LimitExceededException":
-            throw await deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         case "MalformedQueryException":
         case "com.amazonaws.cloudwatchlogs#MalformedQueryException":
-            throw await deserializeAws_json1_1MalformedQueryExceptionResponse(parsedOutput, context);
+            throw await de_MalformedQueryExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.cloudwatchlogs#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.cloudwatchlogs#ServiceUnavailableException":
-            throw await deserializeAws_json1_1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2099,20 +2099,20 @@ const deserializeAws_json1_1StartQueryCommandError = async (output, context) =>
             });
     }
 };
-export const deserializeAws_json1_1StopQueryCommand = async (output, context) => {
+export const de_StopQueryCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1StopQueryCommandError(output, context);
+        return de_StopQueryCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1StopQueryResponse(data, context);
+    contents = de_StopQueryResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1StopQueryCommandError = async (output, context) => {
+const de_StopQueryCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2121,13 +2121,13 @@ const deserializeAws_json1_1StopQueryCommandError = async (output, context) => {
     switch (errorCode) {
         case "InvalidParameterException":
         case "com.amazonaws.cloudwatchlogs#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.cloudwatchlogs#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.cloudwatchlogs#ServiceUnavailableException":
-            throw await deserializeAws_json1_1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2138,9 +2138,9 @@ const deserializeAws_json1_1StopQueryCommandError = async (output, context) => {
             });
     }
 };
-export const deserializeAws_json1_1TagLogGroupCommand = async (output, context) => {
+export const de_TagLogGroupCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1TagLogGroupCommandError(output, context);
+        return de_TagLogGroupCommandError(output, context);
     }
     await collectBody(output.body, context);
     const response = {
@@ -2148,7 +2148,7 @@ export const deserializeAws_json1_1TagLogGroupCommand = async (output, context)
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1TagLogGroupCommandError = async (output, context) => {
+const de_TagLogGroupCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2157,10 +2157,10 @@ const deserializeAws_json1_1TagLogGroupCommandError = async (output, context) =>
     switch (errorCode) {
         case "InvalidParameterException":
         case "com.amazonaws.cloudwatchlogs#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.cloudwatchlogs#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2171,9 +2171,9 @@ const deserializeAws_json1_1TagLogGroupCommandError = async (output, context) =>
             });
     }
 };
-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);
     }
     await collectBody(output.body, context);
     const response = {
@@ -2181,7 +2181,7 @@ export const deserializeAws_json1_1TagResourceCommand = async (output, context)
     };
     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),
@@ -2190,16 +2190,16 @@ const deserializeAws_json1_1TagResourceCommandError = async (output, context) =>
     switch (errorCode) {
         case "InvalidParameterException":
         case "com.amazonaws.cloudwatchlogs#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.cloudwatchlogs#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.cloudwatchlogs#ServiceUnavailableException":
-            throw await deserializeAws_json1_1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         case "TooManyTagsException":
         case "com.amazonaws.cloudwatchlogs#TooManyTagsException":
-            throw await deserializeAws_json1_1TooManyTagsExceptionResponse(parsedOutput, context);
+            throw await de_TooManyTagsExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2210,20 +2210,20 @@ const deserializeAws_json1_1TagResourceCommandError = async (output, context) =>
             });
     }
 };
-export const deserializeAws_json1_1TestMetricFilterCommand = async (output, context) => {
+export const de_TestMetricFilterCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1TestMetricFilterCommandError(output, context);
+        return de_TestMetricFilterCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1TestMetricFilterResponse(data, context);
+    contents = de_TestMetricFilterResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1TestMetricFilterCommandError = async (output, context) => {
+const de_TestMetricFilterCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2232,10 +2232,10 @@ const deserializeAws_json1_1TestMetricFilterCommandError = async (output, contex
     switch (errorCode) {
         case "InvalidParameterException":
         case "com.amazonaws.cloudwatchlogs#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.cloudwatchlogs#ServiceUnavailableException":
-            throw await deserializeAws_json1_1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2246,9 +2246,9 @@ const deserializeAws_json1_1TestMetricFilterCommandError = async (output, contex
             });
     }
 };
-export const deserializeAws_json1_1UntagLogGroupCommand = async (output, context) => {
+export const de_UntagLogGroupCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1UntagLogGroupCommandError(output, context);
+        return de_UntagLogGroupCommandError(output, context);
     }
     await collectBody(output.body, context);
     const response = {
@@ -2256,7 +2256,7 @@ export const deserializeAws_json1_1UntagLogGroupCommand = async (output, context
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1UntagLogGroupCommandError = async (output, context) => {
+const de_UntagLogGroupCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2265,7 +2265,7 @@ const deserializeAws_json1_1UntagLogGroupCommandError = async (output, context)
     switch (errorCode) {
         case "ResourceNotFoundException":
         case "com.amazonaws.cloudwatchlogs#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2276,9 +2276,9 @@ const deserializeAws_json1_1UntagLogGroupCommandError = 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);
     }
     await collectBody(output.body, context);
     const response = {
@@ -2286,7 +2286,7 @@ export const deserializeAws_json1_1UntagResourceCommand = async (output, context
     };
     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),
@@ -2295,13 +2295,13 @@ const deserializeAws_json1_1UntagResourceCommandError = async (output, context)
     switch (errorCode) {
         case "InvalidParameterException":
         case "com.amazonaws.cloudwatchlogs#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.cloudwatchlogs#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.cloudwatchlogs#ServiceUnavailableException":
-            throw await deserializeAws_json1_1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2312,133 +2312,133 @@ const deserializeAws_json1_1UntagResourceCommandError = async (output, context)
             });
     }
 };
-const deserializeAws_json1_1DataAlreadyAcceptedExceptionResponse = async (parsedOutput, context) => {
+const de_DataAlreadyAcceptedExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_1DataAlreadyAcceptedException(body, context);
+    const deserialized = de_DataAlreadyAcceptedException(body, context);
     const exception = new DataAlreadyAcceptedException({
         $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_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_1InvalidSequenceTokenExceptionResponse = async (parsedOutput, context) => {
+const de_InvalidSequenceTokenExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_1InvalidSequenceTokenException(body, context);
+    const deserialized = de_InvalidSequenceTokenException(body, context);
     const exception = new InvalidSequenceTokenException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_json1_1LimitExceededExceptionResponse = async (parsedOutput, context) => {
+const de_LimitExceededExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_1LimitExceededException(body, context);
+    const deserialized = de_LimitExceededException(body, context);
     const exception = new LimitExceededException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_json1_1MalformedQueryExceptionResponse = async (parsedOutput, context) => {
+const de_MalformedQueryExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_1MalformedQueryException(body, context);
+    const deserialized = de_MalformedQueryException(body, context);
     const exception = new MalformedQueryException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_json1_1OperationAbortedExceptionResponse = async (parsedOutput, context) => {
+const de_OperationAbortedExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_1OperationAbortedException(body, context);
+    const deserialized = de_OperationAbortedException(body, context);
     const exception = new OperationAbortedException({
         $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 deserializeAws_json1_1ServiceUnavailableExceptionResponse = async (parsedOutput, context) => {
+const de_ServiceUnavailableExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_1ServiceUnavailableException(body, context);
+    const deserialized = de_ServiceUnavailableException(body, context);
     const exception = new ServiceUnavailableException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_json1_1TooManyTagsExceptionResponse = async (parsedOutput, context) => {
+const de_TooManyTagsExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_1TooManyTagsException(body, context);
+    const deserialized = de_TooManyTagsException(body, context);
     const exception = new TooManyTagsException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_json1_1UnrecognizedClientExceptionResponse = async (parsedOutput, context) => {
+const de_UnrecognizedClientExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_1UnrecognizedClientException(body, context);
+    const deserialized = de_UnrecognizedClientException(body, context);
     const exception = new UnrecognizedClientException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const serializeAws_json1_1AccountIds = (input, context) => {
+const se_AccountIds = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
         return entry;
     });
 };
-const serializeAws_json1_1AssociateKmsKeyRequest = (input, context) => {
+const se_AssociateKmsKeyRequest = (input, context) => {
     return {
         ...(input.kmsKeyId != null && { kmsKeyId: input.kmsKeyId }),
         ...(input.logGroupName != null && { logGroupName: input.logGroupName }),
     };
 };
-const serializeAws_json1_1CancelExportTaskRequest = (input, context) => {
+const se_CancelExportTaskRequest = (input, context) => {
     return {
         ...(input.taskId != null && { taskId: input.taskId }),
     };
 };
-const serializeAws_json1_1CreateExportTaskRequest = (input, context) => {
+const se_CreateExportTaskRequest = (input, context) => {
     return {
         ...(input.destination != null && { destination: input.destination }),
         ...(input.destinationPrefix != null && { destinationPrefix: input.destinationPrefix }),
@@ -2449,75 +2449,75 @@ const serializeAws_json1_1CreateExportTaskRequest = (input, context) => {
         ...(input.to != null && { to: input.to }),
     };
 };
-const serializeAws_json1_1CreateLogGroupRequest = (input, context) => {
+const se_CreateLogGroupRequest = (input, context) => {
     return {
         ...(input.kmsKeyId != null && { kmsKeyId: input.kmsKeyId }),
         ...(input.logGroupName != null && { logGroupName: input.logGroupName }),
-        ...(input.tags != null && { tags: serializeAws_json1_1Tags(input.tags, context) }),
+        ...(input.tags != null && { tags: se_Tags(input.tags, context) }),
     };
 };
-const serializeAws_json1_1CreateLogStreamRequest = (input, context) => {
+const se_CreateLogStreamRequest = (input, context) => {
     return {
         ...(input.logGroupName != null && { logGroupName: input.logGroupName }),
         ...(input.logStreamName != null && { logStreamName: input.logStreamName }),
     };
 };
-const serializeAws_json1_1DeleteDataProtectionPolicyRequest = (input, context) => {
+const se_DeleteDataProtectionPolicyRequest = (input, context) => {
     return {
         ...(input.logGroupIdentifier != null && { logGroupIdentifier: input.logGroupIdentifier }),
     };
 };
-const serializeAws_json1_1DeleteDestinationRequest = (input, context) => {
+const se_DeleteDestinationRequest = (input, context) => {
     return {
         ...(input.destinationName != null && { destinationName: input.destinationName }),
     };
 };
-const serializeAws_json1_1DeleteLogGroupRequest = (input, context) => {
+const se_DeleteLogGroupRequest = (input, context) => {
     return {
         ...(input.logGroupName != null && { logGroupName: input.logGroupName }),
     };
 };
-const serializeAws_json1_1DeleteLogStreamRequest = (input, context) => {
+const se_DeleteLogStreamRequest = (input, context) => {
     return {
         ...(input.logGroupName != null && { logGroupName: input.logGroupName }),
         ...(input.logStreamName != null && { logStreamName: input.logStreamName }),
     };
 };
-const serializeAws_json1_1DeleteMetricFilterRequest = (input, context) => {
+const se_DeleteMetricFilterRequest = (input, context) => {
     return {
         ...(input.filterName != null && { filterName: input.filterName }),
         ...(input.logGroupName != null && { logGroupName: input.logGroupName }),
     };
 };
-const serializeAws_json1_1DeleteQueryDefinitionRequest = (input, context) => {
+const se_DeleteQueryDefinitionRequest = (input, context) => {
     return {
         ...(input.queryDefinitionId != null && { queryDefinitionId: input.queryDefinitionId }),
     };
 };
-const serializeAws_json1_1DeleteResourcePolicyRequest = (input, context) => {
+const se_DeleteResourcePolicyRequest = (input, context) => {
     return {
         ...(input.policyName != null && { policyName: input.policyName }),
     };
 };
-const serializeAws_json1_1DeleteRetentionPolicyRequest = (input, context) => {
+const se_DeleteRetentionPolicyRequest = (input, context) => {
     return {
         ...(input.logGroupName != null && { logGroupName: input.logGroupName }),
     };
 };
-const serializeAws_json1_1DeleteSubscriptionFilterRequest = (input, context) => {
+const se_DeleteSubscriptionFilterRequest = (input, context) => {
     return {
         ...(input.filterName != null && { filterName: input.filterName }),
         ...(input.logGroupName != null && { logGroupName: input.logGroupName }),
     };
 };
-const serializeAws_json1_1DescribeDestinationsRequest = (input, context) => {
+const se_DescribeDestinationsRequest = (input, context) => {
     return {
         ...(input.DestinationNamePrefix != null && { DestinationNamePrefix: input.DestinationNamePrefix }),
         ...(input.limit != null && { limit: input.limit }),
         ...(input.nextToken != null && { nextToken: input.nextToken }),
     };
 };
-const serializeAws_json1_1DescribeExportTasksRequest = (input, context) => {
+const se_DescribeExportTasksRequest = (input, context) => {
     return {
         ...(input.limit != null && { limit: input.limit }),
         ...(input.nextToken != null && { nextToken: input.nextToken }),
@@ -2525,11 +2525,9 @@ const serializeAws_json1_1DescribeExportTasksRequest = (input, context) => {
         ...(input.taskId != null && { taskId: input.taskId }),
     };
 };
-const serializeAws_json1_1DescribeLogGroupsRequest = (input, context) => {
+const se_DescribeLogGroupsRequest = (input, context) => {
     return {
-        ...(input.accountIdentifiers != null && {
-            accountIdentifiers: serializeAws_json1_1AccountIds(input.accountIdentifiers, context),
-        }),
+        ...(input.accountIdentifiers != null && { accountIdentifiers: se_AccountIds(input.accountIdentifiers, context) }),
         ...(input.includeLinkedAccounts != null && { includeLinkedAccounts: input.includeLinkedAccounts }),
         ...(input.limit != null && { limit: input.limit }),
         ...(input.logGroupNamePattern != null && { logGroupNamePattern: input.logGroupNamePattern }),
@@ -2537,7 +2535,7 @@ const serializeAws_json1_1DescribeLogGroupsRequest = (input, context) => {
         ...(input.nextToken != null && { nextToken: input.nextToken }),
     };
 };
-const serializeAws_json1_1DescribeLogStreamsRequest = (input, context) => {
+const se_DescribeLogStreamsRequest = (input, context) => {
     return {
         ...(input.descending != null && { descending: input.descending }),
         ...(input.limit != null && { limit: input.limit }),
@@ -2548,7 +2546,7 @@ const serializeAws_json1_1DescribeLogStreamsRequest = (input, context) => {
         ...(input.orderBy != null && { orderBy: input.orderBy }),
     };
 };
-const serializeAws_json1_1DescribeMetricFiltersRequest = (input, context) => {
+const se_DescribeMetricFiltersRequest = (input, context) => {
     return {
         ...(input.filterNamePrefix != null && { filterNamePrefix: input.filterNamePrefix }),
         ...(input.limit != null && { limit: input.limit }),
@@ -2558,7 +2556,7 @@ const serializeAws_json1_1DescribeMetricFiltersRequest = (input, context) => {
         ...(input.nextToken != null && { nextToken: input.nextToken }),
     };
 };
-const serializeAws_json1_1DescribeQueriesRequest = (input, context) => {
+const se_DescribeQueriesRequest = (input, context) => {
     return {
         ...(input.logGroupName != null && { logGroupName: input.logGroupName }),
         ...(input.maxResults != null && { maxResults: input.maxResults }),
@@ -2566,20 +2564,20 @@ const serializeAws_json1_1DescribeQueriesRequest = (input, context) => {
         ...(input.status != null && { status: input.status }),
     };
 };
-const serializeAws_json1_1DescribeQueryDefinitionsRequest = (input, context) => {
+const se_DescribeQueryDefinitionsRequest = (input, context) => {
     return {
         ...(input.maxResults != null && { maxResults: input.maxResults }),
         ...(input.nextToken != null && { nextToken: input.nextToken }),
         ...(input.queryDefinitionNamePrefix != null && { queryDefinitionNamePrefix: input.queryDefinitionNamePrefix }),
     };
 };
-const serializeAws_json1_1DescribeResourcePoliciesRequest = (input, context) => {
+const se_DescribeResourcePoliciesRequest = (input, context) => {
     return {
         ...(input.limit != null && { limit: input.limit }),
         ...(input.nextToken != null && { nextToken: input.nextToken }),
     };
 };
-const serializeAws_json1_1DescribeSubscriptionFiltersRequest = (input, context) => {
+const se_DescribeSubscriptionFiltersRequest = (input, context) => {
     return {
         ...(input.filterNamePrefix != null && { filterNamePrefix: input.filterNamePrefix }),
         ...(input.limit != null && { limit: input.limit }),
@@ -2587,7 +2585,7 @@ const serializeAws_json1_1DescribeSubscriptionFiltersRequest = (input, context)
         ...(input.nextToken != null && { nextToken: input.nextToken }),
     };
 };
-const serializeAws_json1_1Dimensions = (input, context) => {
+const se_Dimensions = (input, context) => {
     return Object.entries(input).reduce((acc, [key, value]) => {
         if (value === null) {
             return acc;
@@ -2596,12 +2594,12 @@ const serializeAws_json1_1Dimensions = (input, context) => {
         return acc;
     }, {});
 };
-const serializeAws_json1_1DisassociateKmsKeyRequest = (input, context) => {
+const se_DisassociateKmsKeyRequest = (input, context) => {
     return {
         ...(input.logGroupName != null && { logGroupName: input.logGroupName }),
     };
 };
-const serializeAws_json1_1FilterLogEventsRequest = (input, context) => {
+const se_FilterLogEventsRequest = (input, context) => {
     return {
         ...(input.endTime != null && { endTime: input.endTime }),
         ...(input.filterPattern != null && { filterPattern: input.filterPattern }),
@@ -2610,20 +2608,18 @@ const serializeAws_json1_1FilterLogEventsRequest = (input, context) => {
         ...(input.logGroupIdentifier != null && { logGroupIdentifier: input.logGroupIdentifier }),
         ...(input.logGroupName != null && { logGroupName: input.logGroupName }),
         ...(input.logStreamNamePrefix != null && { logStreamNamePrefix: input.logStreamNamePrefix }),
-        ...(input.logStreamNames != null && {
-            logStreamNames: serializeAws_json1_1InputLogStreamNames(input.logStreamNames, context),
-        }),
+        ...(input.logStreamNames != null && { logStreamNames: se_InputLogStreamNames(input.logStreamNames, context) }),
         ...(input.nextToken != null && { nextToken: input.nextToken }),
         ...(input.startTime != null && { startTime: input.startTime }),
         ...(input.unmask != null && { unmask: input.unmask }),
     };
 };
-const serializeAws_json1_1GetDataProtectionPolicyRequest = (input, context) => {
+const se_GetDataProtectionPolicyRequest = (input, context) => {
     return {
         ...(input.logGroupIdentifier != null && { logGroupIdentifier: input.logGroupIdentifier }),
     };
 };
-const serializeAws_json1_1GetLogEventsRequest = (input, context) => {
+const se_GetLogEventsRequest = (input, context) => {
     return {
         ...(input.endTime != null && { endTime: input.endTime }),
         ...(input.limit != null && { limit: input.limit }),
@@ -2636,147 +2632,145 @@ const serializeAws_json1_1GetLogEventsRequest = (input, context) => {
         ...(input.unmask != null && { unmask: input.unmask }),
     };
 };
-const serializeAws_json1_1GetLogGroupFieldsRequest = (input, context) => {
+const se_GetLogGroupFieldsRequest = (input, context) => {
     return {
         ...(input.logGroupIdentifier != null && { logGroupIdentifier: input.logGroupIdentifier }),
         ...(input.logGroupName != null && { logGroupName: input.logGroupName }),
         ...(input.time != null && { time: input.time }),
     };
 };
-const serializeAws_json1_1GetLogRecordRequest = (input, context) => {
+const se_GetLogRecordRequest = (input, context) => {
     return {
         ...(input.logRecordPointer != null && { logRecordPointer: input.logRecordPointer }),
         ...(input.unmask != null && { unmask: input.unmask }),
     };
 };
-const serializeAws_json1_1GetQueryResultsRequest = (input, context) => {
+const se_GetQueryResultsRequest = (input, context) => {
     return {
         ...(input.queryId != null && { queryId: input.queryId }),
     };
 };
-const serializeAws_json1_1InputLogEvent = (input, context) => {
+const se_InputLogEvent = (input, context) => {
     return {
         ...(input.message != null && { message: input.message }),
         ...(input.timestamp != null && { timestamp: input.timestamp }),
     };
 };
-const serializeAws_json1_1InputLogEvents = (input, context) => {
+const se_InputLogEvents = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
-        return serializeAws_json1_1InputLogEvent(entry, context);
+        return se_InputLogEvent(entry, context);
     });
 };
-const serializeAws_json1_1InputLogStreamNames = (input, context) => {
+const se_InputLogStreamNames = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
         return entry;
     });
 };
-const serializeAws_json1_1ListTagsForResourceRequest = (input, context) => {
+const se_ListTagsForResourceRequest = (input, context) => {
     return {
         ...(input.resourceArn != null && { resourceArn: input.resourceArn }),
     };
 };
-const serializeAws_json1_1ListTagsLogGroupRequest = (input, context) => {
+const se_ListTagsLogGroupRequest = (input, context) => {
     return {
         ...(input.logGroupName != null && { logGroupName: input.logGroupName }),
     };
 };
-const serializeAws_json1_1LogGroupIdentifiers = (input, context) => {
+const se_LogGroupIdentifiers = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
         return entry;
     });
 };
-const serializeAws_json1_1LogGroupNames = (input, context) => {
+const se_LogGroupNames = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
         return entry;
     });
 };
-const serializeAws_json1_1MetricTransformation = (input, context) => {
+const se_MetricTransformation = (input, context) => {
     return {
         ...(input.defaultValue != null && { defaultValue: __serializeFloat(input.defaultValue) }),
-        ...(input.dimensions != null && { dimensions: serializeAws_json1_1Dimensions(input.dimensions, context) }),
+        ...(input.dimensions != null && { dimensions: se_Dimensions(input.dimensions, context) }),
         ...(input.metricName != null && { metricName: input.metricName }),
         ...(input.metricNamespace != null && { metricNamespace: input.metricNamespace }),
         ...(input.metricValue != null && { metricValue: input.metricValue }),
         ...(input.unit != null && { unit: input.unit }),
     };
 };
-const serializeAws_json1_1MetricTransformations = (input, context) => {
+const se_MetricTransformations = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
-        return serializeAws_json1_1MetricTransformation(entry, context);
+        return se_MetricTransformation(entry, context);
     });
 };
-const serializeAws_json1_1PutDataProtectionPolicyRequest = (input, context) => {
+const se_PutDataProtectionPolicyRequest = (input, context) => {
     return {
         ...(input.logGroupIdentifier != null && { logGroupIdentifier: input.logGroupIdentifier }),
         ...(input.policyDocument != null && { policyDocument: input.policyDocument }),
     };
 };
-const serializeAws_json1_1PutDestinationPolicyRequest = (input, context) => {
+const se_PutDestinationPolicyRequest = (input, context) => {
     return {
         ...(input.accessPolicy != null && { accessPolicy: input.accessPolicy }),
         ...(input.destinationName != null && { destinationName: input.destinationName }),
         ...(input.forceUpdate != null && { forceUpdate: input.forceUpdate }),
     };
 };
-const serializeAws_json1_1PutDestinationRequest = (input, context) => {
+const se_PutDestinationRequest = (input, context) => {
     return {
         ...(input.destinationName != null && { destinationName: input.destinationName }),
         ...(input.roleArn != null && { roleArn: input.roleArn }),
-        ...(input.tags != null && { tags: serializeAws_json1_1Tags(input.tags, context) }),
+        ...(input.tags != null && { tags: se_Tags(input.tags, context) }),
         ...(input.targetArn != null && { targetArn: input.targetArn }),
     };
 };
-const serializeAws_json1_1PutLogEventsRequest = (input, context) => {
+const se_PutLogEventsRequest = (input, context) => {
     return {
-        ...(input.logEvents != null && { logEvents: serializeAws_json1_1InputLogEvents(input.logEvents, context) }),
+        ...(input.logEvents != null && { logEvents: se_InputLogEvents(input.logEvents, context) }),
         ...(input.logGroupName != null && { logGroupName: input.logGroupName }),
         ...(input.logStreamName != null && { logStreamName: input.logStreamName }),
         ...(input.sequenceToken != null && { sequenceToken: input.sequenceToken }),
     };
 };
-const serializeAws_json1_1PutMetricFilterRequest = (input, context) => {
+const se_PutMetricFilterRequest = (input, context) => {
     return {
         ...(input.filterName != null && { filterName: input.filterName }),
         ...(input.filterPattern != null && { filterPattern: input.filterPattern }),
         ...(input.logGroupName != null && { logGroupName: input.logGroupName }),
         ...(input.metricTransformations != null && {
-            metricTransformations: serializeAws_json1_1MetricTransformations(input.metricTransformations, context),
+            metricTransformations: se_MetricTransformations(input.metricTransformations, context),
         }),
     };
 };
-const serializeAws_json1_1PutQueryDefinitionRequest = (input, context) => {
+const se_PutQueryDefinitionRequest = (input, context) => {
     return {
-        ...(input.logGroupNames != null && {
-            logGroupNames: serializeAws_json1_1LogGroupNames(input.logGroupNames, context),
-        }),
+        ...(input.logGroupNames != null && { logGroupNames: se_LogGroupNames(input.logGroupNames, context) }),
         ...(input.name != null && { name: input.name }),
         ...(input.queryDefinitionId != null && { queryDefinitionId: input.queryDefinitionId }),
         ...(input.queryString != null && { queryString: input.queryString }),
     };
 };
-const serializeAws_json1_1PutResourcePolicyRequest = (input, context) => {
+const se_PutResourcePolicyRequest = (input, context) => {
     return {
         ...(input.policyDocument != null && { policyDocument: input.policyDocument }),
         ...(input.policyName != null && { policyName: input.policyName }),
     };
 };
-const serializeAws_json1_1PutRetentionPolicyRequest = (input, context) => {
+const se_PutRetentionPolicyRequest = (input, context) => {
     return {
         ...(input.logGroupName != null && { logGroupName: input.logGroupName }),
         ...(input.retentionInDays != null && { retentionInDays: input.retentionInDays }),
     };
 };
-const serializeAws_json1_1PutSubscriptionFilterRequest = (input, context) => {
+const se_PutSubscriptionFilterRequest = (input, context) => {
     return {
         ...(input.destinationArn != null && { destinationArn: input.destinationArn }),
         ...(input.distribution != null && { distribution: input.distribution }),
@@ -2786,53 +2780,51 @@ const serializeAws_json1_1PutSubscriptionFilterRequest = (input, context) => {
         ...(input.roleArn != null && { roleArn: input.roleArn }),
     };
 };
-const serializeAws_json1_1StartQueryRequest = (input, context) => {
+const se_StartQueryRequest = (input, context) => {
     return {
         ...(input.endTime != null && { endTime: input.endTime }),
         ...(input.limit != null && { limit: input.limit }),
         ...(input.logGroupIdentifiers != null && {
-            logGroupIdentifiers: serializeAws_json1_1LogGroupIdentifiers(input.logGroupIdentifiers, context),
+            logGroupIdentifiers: se_LogGroupIdentifiers(input.logGroupIdentifiers, context),
         }),
         ...(input.logGroupName != null && { logGroupName: input.logGroupName }),
-        ...(input.logGroupNames != null && {
-            logGroupNames: serializeAws_json1_1LogGroupNames(input.logGroupNames, context),
-        }),
+        ...(input.logGroupNames != null && { logGroupNames: se_LogGroupNames(input.logGroupNames, context) }),
         ...(input.queryString != null && { queryString: input.queryString }),
         ...(input.startTime != null && { startTime: input.startTime }),
     };
 };
-const serializeAws_json1_1StopQueryRequest = (input, context) => {
+const se_StopQueryRequest = (input, context) => {
     return {
         ...(input.queryId != null && { queryId: input.queryId }),
     };
 };
-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 entry;
     });
 };
-const serializeAws_json1_1TagLogGroupRequest = (input, context) => {
+const se_TagLogGroupRequest = (input, context) => {
     return {
         ...(input.logGroupName != null && { logGroupName: input.logGroupName }),
-        ...(input.tags != null && { tags: serializeAws_json1_1Tags(input.tags, context) }),
+        ...(input.tags != null && { tags: se_Tags(input.tags, 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_1Tags(input.tags, context) }),
+        ...(input.tags != null && { tags: se_Tags(input.tags, context) }),
     };
 };
-const serializeAws_json1_1Tags = (input, context) => {
+const se_Tags = (input, context) => {
     return Object.entries(input).reduce((acc, [key, value]) => {
         if (value === null) {
             return acc;
@@ -2841,110 +2833,102 @@ const serializeAws_json1_1Tags = (input, context) => {
         return acc;
     }, {});
 };
-const serializeAws_json1_1TestEventMessages = (input, context) => {
+const se_TestEventMessages = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
         return entry;
     });
 };
-const serializeAws_json1_1TestMetricFilterRequest = (input, context) => {
+const se_TestMetricFilterRequest = (input, context) => {
     return {
         ...(input.filterPattern != null && { filterPattern: input.filterPattern }),
-        ...(input.logEventMessages != null && {
-            logEventMessages: serializeAws_json1_1TestEventMessages(input.logEventMessages, context),
-        }),
+        ...(input.logEventMessages != null && { logEventMessages: se_TestEventMessages(input.logEventMessages, context) }),
     };
 };
-const serializeAws_json1_1UntagLogGroupRequest = (input, context) => {
+const se_UntagLogGroupRequest = (input, context) => {
     return {
         ...(input.logGroupName != null && { logGroupName: input.logGroupName }),
-        ...(input.tags != null && { tags: serializeAws_json1_1TagList(input.tags, context) }),
+        ...(input.tags != null && { tags: se_TagList(input.tags, context) }),
     };
 };
-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 deserializeAws_json1_1CreateExportTaskResponse = (output, context) => {
+const de_CreateExportTaskResponse = (output, context) => {
     return {
         taskId: __expectString(output.taskId),
     };
 };
-const deserializeAws_json1_1DataAlreadyAcceptedException = (output, context) => {
+const de_DataAlreadyAcceptedException = (output, context) => {
     return {
         expectedSequenceToken: __expectString(output.expectedSequenceToken),
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_1DeleteQueryDefinitionResponse = (output, context) => {
+const de_DeleteQueryDefinitionResponse = (output, context) => {
     return {
         success: __expectBoolean(output.success),
     };
 };
-const deserializeAws_json1_1DescribeDestinationsResponse = (output, context) => {
+const de_DescribeDestinationsResponse = (output, context) => {
     return {
-        destinations: output.destinations != null ? deserializeAws_json1_1Destinations(output.destinations, context) : undefined,
+        destinations: output.destinations != null ? de_Destinations(output.destinations, context) : undefined,
         nextToken: __expectString(output.nextToken),
     };
 };
-const deserializeAws_json1_1DescribeExportTasksResponse = (output, context) => {
+const de_DescribeExportTasksResponse = (output, context) => {
     return {
-        exportTasks: output.exportTasks != null ? deserializeAws_json1_1ExportTasks(output.exportTasks, context) : undefined,
+        exportTasks: output.exportTasks != null ? de_ExportTasks(output.exportTasks, context) : undefined,
         nextToken: __expectString(output.nextToken),
     };
 };
-const deserializeAws_json1_1DescribeLogGroupsResponse = (output, context) => {
+const de_DescribeLogGroupsResponse = (output, context) => {
     return {
-        logGroups: output.logGroups != null ? deserializeAws_json1_1LogGroups(output.logGroups, context) : undefined,
+        logGroups: output.logGroups != null ? de_LogGroups(output.logGroups, context) : undefined,
         nextToken: __expectString(output.nextToken),
     };
 };
-const deserializeAws_json1_1DescribeLogStreamsResponse = (output, context) => {
+const de_DescribeLogStreamsResponse = (output, context) => {
     return {
-        logStreams: output.logStreams != null ? deserializeAws_json1_1LogStreams(output.logStreams, context) : undefined,
+        logStreams: output.logStreams != null ? de_LogStreams(output.logStreams, context) : undefined,
         nextToken: __expectString(output.nextToken),
     };
 };
-const deserializeAws_json1_1DescribeMetricFiltersResponse = (output, context) => {
+const de_DescribeMetricFiltersResponse = (output, context) => {
     return {
-        metricFilters: output.metricFilters != null ? deserializeAws_json1_1MetricFilters(output.metricFilters, context) : undefined,
+        metricFilters: output.metricFilters != null ? de_MetricFilters(output.metricFilters, context) : undefined,
         nextToken: __expectString(output.nextToken),
     };
 };
-const deserializeAws_json1_1DescribeQueriesResponse = (output, context) => {
+const de_DescribeQueriesResponse = (output, context) => {
     return {
         nextToken: __expectString(output.nextToken),
-        queries: output.queries != null ? deserializeAws_json1_1QueryInfoList(output.queries, context) : undefined,
+        queries: output.queries != null ? de_QueryInfoList(output.queries, context) : undefined,
     };
 };
-const deserializeAws_json1_1DescribeQueryDefinitionsResponse = (output, context) => {
+const de_DescribeQueryDefinitionsResponse = (output, context) => {
     return {
         nextToken: __expectString(output.nextToken),
-        queryDefinitions: output.queryDefinitions != null
-            ? deserializeAws_json1_1QueryDefinitionList(output.queryDefinitions, context)
-            : undefined,
+        queryDefinitions: output.queryDefinitions != null ? de_QueryDefinitionList(output.queryDefinitions, context) : undefined,
     };
 };
-const deserializeAws_json1_1DescribeResourcePoliciesResponse = (output, context) => {
+const de_DescribeResourcePoliciesResponse = (output, context) => {
     return {
         nextToken: __expectString(output.nextToken),
-        resourcePolicies: output.resourcePolicies != null
-            ? deserializeAws_json1_1ResourcePolicies(output.resourcePolicies, context)
-            : undefined,
+        resourcePolicies: output.resourcePolicies != null ? de_ResourcePolicies(output.resourcePolicies, context) : undefined,
     };
 };
-const deserializeAws_json1_1DescribeSubscriptionFiltersResponse = (output, context) => {
+const de_DescribeSubscriptionFiltersResponse = (output, context) => {
     return {
         nextToken: __expectString(output.nextToken),
-        subscriptionFilters: output.subscriptionFilters != null
-            ? deserializeAws_json1_1SubscriptionFilters(output.subscriptionFilters, context)
-            : undefined,
+        subscriptionFilters: output.subscriptionFilters != null ? de_SubscriptionFilters(output.subscriptionFilters, context) : undefined,
     };
 };
-const deserializeAws_json1_1Destination = (output, context) => {
+const de_Destination = (output, context) => {
     return {
         accessPolicy: __expectString(output.accessPolicy),
         arn: __expectString(output.arn),
@@ -2954,18 +2938,18 @@ const deserializeAws_json1_1Destination = (output, context) => {
         targetArn: __expectString(output.targetArn),
     };
 };
-const deserializeAws_json1_1Destinations = (output, context) => {
+const de_Destinations = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_json1_1Destination(entry, context);
+        return de_Destination(entry, context);
     });
     return retVal;
 };
-const deserializeAws_json1_1Dimensions = (output, context) => {
+const de_Dimensions = (output, context) => {
     return Object.entries(output).reduce((acc, [key, value]) => {
         if (value === null) {
             return acc;
@@ -2974,45 +2958,43 @@ const deserializeAws_json1_1Dimensions = (output, context) => {
         return acc;
     }, {});
 };
-const deserializeAws_json1_1ExportTask = (output, context) => {
+const de_ExportTask = (output, context) => {
     return {
         destination: __expectString(output.destination),
         destinationPrefix: __expectString(output.destinationPrefix),
-        executionInfo: output.executionInfo != null
-            ? deserializeAws_json1_1ExportTaskExecutionInfo(output.executionInfo, context)
-            : undefined,
+        executionInfo: output.executionInfo != null ? de_ExportTaskExecutionInfo(output.executionInfo, context) : undefined,
         from: __expectLong(output.from),
         logGroupName: __expectString(output.logGroupName),
-        status: output.status != null ? deserializeAws_json1_1ExportTaskStatus(output.status, context) : undefined,
+        status: output.status != null ? de_ExportTaskStatus(output.status, context) : undefined,
         taskId: __expectString(output.taskId),
         taskName: __expectString(output.taskName),
         to: __expectLong(output.to),
     };
 };
-const deserializeAws_json1_1ExportTaskExecutionInfo = (output, context) => {
+const de_ExportTaskExecutionInfo = (output, context) => {
     return {
         completionTime: __expectLong(output.completionTime),
         creationTime: __expectLong(output.creationTime),
     };
 };
-const deserializeAws_json1_1ExportTasks = (output, context) => {
+const de_ExportTasks = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_json1_1ExportTask(entry, context);
+        return de_ExportTask(entry, context);
     });
     return retVal;
 };
-const deserializeAws_json1_1ExportTaskStatus = (output, context) => {
+const de_ExportTaskStatus = (output, context) => {
     return {
         code: __expectString(output.code),
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_1ExtractedValues = (output, context) => {
+const de_ExtractedValues = (output, context) => {
     return Object.entries(output).reduce((acc, [key, value]) => {
         if (value === null) {
             return acc;
@@ -3021,7 +3003,7 @@ const deserializeAws_json1_1ExtractedValues = (output, context) => {
         return acc;
     }, {});
 };
-const deserializeAws_json1_1FilteredLogEvent = (output, context) => {
+const de_FilteredLogEvent = (output, context) => {
     return {
         eventId: __expectString(output.eventId),
         ingestionTime: __expectLong(output.ingestionTime),
@@ -3030,91 +3012,87 @@ const deserializeAws_json1_1FilteredLogEvent = (output, context) => {
         timestamp: __expectLong(output.timestamp),
     };
 };
-const deserializeAws_json1_1FilteredLogEvents = (output, context) => {
+const de_FilteredLogEvents = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_json1_1FilteredLogEvent(entry, context);
+        return de_FilteredLogEvent(entry, context);
     });
     return retVal;
 };
-const deserializeAws_json1_1FilterLogEventsResponse = (output, context) => {
+const de_FilterLogEventsResponse = (output, context) => {
     return {
-        events: output.events != null ? deserializeAws_json1_1FilteredLogEvents(output.events, context) : undefined,
+        events: output.events != null ? de_FilteredLogEvents(output.events, context) : undefined,
         nextToken: __expectString(output.nextToken),
-        searchedLogStreams: output.searchedLogStreams != null
-            ? deserializeAws_json1_1SearchedLogStreams(output.searchedLogStreams, context)
-            : undefined,
+        searchedLogStreams: output.searchedLogStreams != null ? de_SearchedLogStreams(output.searchedLogStreams, context) : undefined,
     };
 };
-const deserializeAws_json1_1GetDataProtectionPolicyResponse = (output, context) => {
+const de_GetDataProtectionPolicyResponse = (output, context) => {
     return {
         lastUpdatedTime: __expectLong(output.lastUpdatedTime),
         logGroupIdentifier: __expectString(output.logGroupIdentifier),
         policyDocument: __expectString(output.policyDocument),
     };
 };
-const deserializeAws_json1_1GetLogEventsResponse = (output, context) => {
+const de_GetLogEventsResponse = (output, context) => {
     return {
-        events: output.events != null ? deserializeAws_json1_1OutputLogEvents(output.events, context) : undefined,
+        events: output.events != null ? de_OutputLogEvents(output.events, context) : undefined,
         nextBackwardToken: __expectString(output.nextBackwardToken),
         nextForwardToken: __expectString(output.nextForwardToken),
     };
 };
-const deserializeAws_json1_1GetLogGroupFieldsResponse = (output, context) => {
+const de_GetLogGroupFieldsResponse = (output, context) => {
     return {
-        logGroupFields: output.logGroupFields != null
-            ? deserializeAws_json1_1LogGroupFieldList(output.logGroupFields, context)
-            : undefined,
+        logGroupFields: output.logGroupFields != null ? de_LogGroupFieldList(output.logGroupFields, context) : undefined,
     };
 };
-const deserializeAws_json1_1GetLogRecordResponse = (output, context) => {
+const de_GetLogRecordResponse = (output, context) => {
     return {
-        logRecord: output.logRecord != null ? deserializeAws_json1_1LogRecord(output.logRecord, context) : undefined,
+        logRecord: output.logRecord != null ? de_LogRecord(output.logRecord, context) : undefined,
     };
 };
-const deserializeAws_json1_1GetQueryResultsResponse = (output, context) => {
+const de_GetQueryResultsResponse = (output, context) => {
     return {
-        results: output.results != null ? deserializeAws_json1_1QueryResults(output.results, context) : undefined,
-        statistics: output.statistics != null ? deserializeAws_json1_1QueryStatistics(output.statistics, context) : undefined,
+        results: output.results != null ? de_QueryResults(output.results, context) : undefined,
+        statistics: output.statistics != null ? de_QueryStatistics(output.statistics, context) : undefined,
         status: __expectString(output.status),
     };
 };
-const deserializeAws_json1_1InvalidOperationException = (output, context) => {
+const de_InvalidOperationException = (output, context) => {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_1InvalidParameterException = (output, context) => {
+const de_InvalidParameterException = (output, context) => {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_1InvalidSequenceTokenException = (output, context) => {
+const de_InvalidSequenceTokenException = (output, context) => {
     return {
         expectedSequenceToken: __expectString(output.expectedSequenceToken),
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_1LimitExceededException = (output, context) => {
+const de_LimitExceededException = (output, context) => {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_1ListTagsForResourceResponse = (output, context) => {
+const de_ListTagsForResourceResponse = (output, context) => {
     return {
-        tags: output.tags != null ? deserializeAws_json1_1Tags(output.tags, context) : undefined,
+        tags: output.tags != null ? de_Tags(output.tags, context) : undefined,
     };
 };
-const deserializeAws_json1_1ListTagsLogGroupResponse = (output, context) => {
+const de_ListTagsLogGroupResponse = (output, context) => {
     return {
-        tags: output.tags != null ? deserializeAws_json1_1Tags(output.tags, context) : undefined,
+        tags: output.tags != null ? de_Tags(output.tags, context) : undefined,
     };
 };
-const deserializeAws_json1_1LogGroup = (output, context) => {
+const de_LogGroup = (output, context) => {
     return {
         arn: __expectString(output.arn),
         creationTime: __expectLong(output.creationTime),
@@ -3126,24 +3104,24 @@ const deserializeAws_json1_1LogGroup = (output, context) => {
         storedBytes: __expectLong(output.storedBytes),
     };
 };
-const deserializeAws_json1_1LogGroupField = (output, context) => {
+const de_LogGroupField = (output, context) => {
     return {
         name: __expectString(output.name),
         percent: __expectInt32(output.percent),
     };
 };
-const deserializeAws_json1_1LogGroupFieldList = (output, context) => {
+const de_LogGroupFieldList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_json1_1LogGroupField(entry, context);
+        return de_LogGroupField(entry, context);
     });
     return retVal;
 };
-const deserializeAws_json1_1LogGroupNames = (output, context) => {
+const de_LogGroupNames = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
@@ -3154,18 +3132,18 @@ const deserializeAws_json1_1LogGroupNames = (output, context) => {
     });
     return retVal;
 };
-const deserializeAws_json1_1LogGroups = (output, context) => {
+const de_LogGroups = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_json1_1LogGroup(entry, context);
+        return de_LogGroup(entry, context);
     });
     return retVal;
 };
-const deserializeAws_json1_1LogRecord = (output, context) => {
+const de_LogRecord = (output, context) => {
     return Object.entries(output).reduce((acc, [key, value]) => {
         if (value === null) {
             return acc;
@@ -3174,7 +3152,7 @@ const deserializeAws_json1_1LogRecord = (output, context) => {
         return acc;
     }, {});
 };
-const deserializeAws_json1_1LogStream = (output, context) => {
+const de_LogStream = (output, context) => {
     return {
         arn: __expectString(output.arn),
         creationTime: __expectLong(output.creationTime),
@@ -3186,174 +3164,170 @@ const deserializeAws_json1_1LogStream = (output, context) => {
         uploadSequenceToken: __expectString(output.uploadSequenceToken),
     };
 };
-const deserializeAws_json1_1LogStreams = (output, context) => {
+const de_LogStreams = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_json1_1LogStream(entry, context);
+        return de_LogStream(entry, context);
     });
     return retVal;
 };
-const deserializeAws_json1_1MalformedQueryException = (output, context) => {
+const de_MalformedQueryException = (output, context) => {
     return {
         message: __expectString(output.message),
-        queryCompileError: output.queryCompileError != null
-            ? deserializeAws_json1_1QueryCompileError(output.queryCompileError, context)
-            : undefined,
+        queryCompileError: output.queryCompileError != null ? de_QueryCompileError(output.queryCompileError, context) : undefined,
     };
 };
-const deserializeAws_json1_1MetricFilter = (output, context) => {
+const de_MetricFilter = (output, context) => {
     return {
         creationTime: __expectLong(output.creationTime),
         filterName: __expectString(output.filterName),
         filterPattern: __expectString(output.filterPattern),
         logGroupName: __expectString(output.logGroupName),
         metricTransformations: output.metricTransformations != null
-            ? deserializeAws_json1_1MetricTransformations(output.metricTransformations, context)
+            ? de_MetricTransformations(output.metricTransformations, context)
             : undefined,
     };
 };
-const deserializeAws_json1_1MetricFilterMatches = (output, context) => {
+const de_MetricFilterMatches = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_json1_1MetricFilterMatchRecord(entry, context);
+        return de_MetricFilterMatchRecord(entry, context);
     });
     return retVal;
 };
-const deserializeAws_json1_1MetricFilterMatchRecord = (output, context) => {
+const de_MetricFilterMatchRecord = (output, context) => {
     return {
         eventMessage: __expectString(output.eventMessage),
         eventNumber: __expectLong(output.eventNumber),
-        extractedValues: output.extractedValues != null
-            ? deserializeAws_json1_1ExtractedValues(output.extractedValues, context)
-            : undefined,
+        extractedValues: output.extractedValues != null ? de_ExtractedValues(output.extractedValues, context) : undefined,
     };
 };
-const deserializeAws_json1_1MetricFilters = (output, context) => {
+const de_MetricFilters = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_json1_1MetricFilter(entry, context);
+        return de_MetricFilter(entry, context);
     });
     return retVal;
 };
-const deserializeAws_json1_1MetricTransformation = (output, context) => {
+const de_MetricTransformation = (output, context) => {
     return {
         defaultValue: __limitedParseDouble(output.defaultValue),
-        dimensions: output.dimensions != null ? deserializeAws_json1_1Dimensions(output.dimensions, context) : undefined,
+        dimensions: output.dimensions != null ? de_Dimensions(output.dimensions, context) : undefined,
         metricName: __expectString(output.metricName),
         metricNamespace: __expectString(output.metricNamespace),
         metricValue: __expectString(output.metricValue),
         unit: __expectString(output.unit),
     };
 };
-const deserializeAws_json1_1MetricTransformations = (output, context) => {
+const de_MetricTransformations = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_json1_1MetricTransformation(entry, context);
+        return de_MetricTransformation(entry, context);
     });
     return retVal;
 };
-const deserializeAws_json1_1OperationAbortedException = (output, context) => {
+const de_OperationAbortedException = (output, context) => {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_1OutputLogEvent = (output, context) => {
+const de_OutputLogEvent = (output, context) => {
     return {
         ingestionTime: __expectLong(output.ingestionTime),
         message: __expectString(output.message),
         timestamp: __expectLong(output.timestamp),
     };
 };
-const deserializeAws_json1_1OutputLogEvents = (output, context) => {
+const de_OutputLogEvents = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_json1_1OutputLogEvent(entry, context);
+        return de_OutputLogEvent(entry, context);
     });
     return retVal;
 };
-const deserializeAws_json1_1PutDataProtectionPolicyResponse = (output, context) => {
+const de_PutDataProtectionPolicyResponse = (output, context) => {
     return {
         lastUpdatedTime: __expectLong(output.lastUpdatedTime),
         logGroupIdentifier: __expectString(output.logGroupIdentifier),
         policyDocument: __expectString(output.policyDocument),
     };
 };
-const deserializeAws_json1_1PutDestinationResponse = (output, context) => {
+const de_PutDestinationResponse = (output, context) => {
     return {
-        destination: output.destination != null ? deserializeAws_json1_1Destination(output.destination, context) : undefined,
+        destination: output.destination != null ? de_Destination(output.destination, context) : undefined,
     };
 };
-const deserializeAws_json1_1PutLogEventsResponse = (output, context) => {
+const de_PutLogEventsResponse = (output, context) => {
     return {
         nextSequenceToken: __expectString(output.nextSequenceToken),
         rejectedLogEventsInfo: output.rejectedLogEventsInfo != null
-            ? deserializeAws_json1_1RejectedLogEventsInfo(output.rejectedLogEventsInfo, context)
+            ? de_RejectedLogEventsInfo(output.rejectedLogEventsInfo, context)
             : undefined,
     };
 };
-const deserializeAws_json1_1PutQueryDefinitionResponse = (output, context) => {
+const de_PutQueryDefinitionResponse = (output, context) => {
     return {
         queryDefinitionId: __expectString(output.queryDefinitionId),
     };
 };
-const deserializeAws_json1_1PutResourcePolicyResponse = (output, context) => {
+const de_PutResourcePolicyResponse = (output, context) => {
     return {
-        resourcePolicy: output.resourcePolicy != null ? deserializeAws_json1_1ResourcePolicy(output.resourcePolicy, context) : undefined,
+        resourcePolicy: output.resourcePolicy != null ? de_ResourcePolicy(output.resourcePolicy, context) : undefined,
     };
 };
-const deserializeAws_json1_1QueryCompileError = (output, context) => {
+const de_QueryCompileError = (output, context) => {
     return {
-        location: output.location != null ? deserializeAws_json1_1QueryCompileErrorLocation(output.location, context) : undefined,
+        location: output.location != null ? de_QueryCompileErrorLocation(output.location, context) : undefined,
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_1QueryCompileErrorLocation = (output, context) => {
+const de_QueryCompileErrorLocation = (output, context) => {
     return {
         endCharOffset: __expectInt32(output.endCharOffset),
         startCharOffset: __expectInt32(output.startCharOffset),
     };
 };
-const deserializeAws_json1_1QueryDefinition = (output, context) => {
+const de_QueryDefinition = (output, context) => {
     return {
         lastModified: __expectLong(output.lastModified),
-        logGroupNames: output.logGroupNames != null ? deserializeAws_json1_1LogGroupNames(output.logGroupNames, context) : undefined,
+        logGroupNames: output.logGroupNames != null ? de_LogGroupNames(output.logGroupNames, context) : undefined,
         name: __expectString(output.name),
         queryDefinitionId: __expectString(output.queryDefinitionId),
         queryString: __expectString(output.queryString),
     };
 };
-const deserializeAws_json1_1QueryDefinitionList = (output, context) => {
+const de_QueryDefinitionList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_json1_1QueryDefinition(entry, context);
+        return de_QueryDefinition(entry, context);
     });
     return retVal;
 };
-const deserializeAws_json1_1QueryInfo = (output, context) => {
+const de_QueryInfo = (output, context) => {
     return {
         createTime: __expectLong(output.createTime),
         logGroupName: __expectString(output.logGroupName),
@@ -3362,120 +3336,120 @@ const deserializeAws_json1_1QueryInfo = (output, context) => {
         status: __expectString(output.status),
     };
 };
-const deserializeAws_json1_1QueryInfoList = (output, context) => {
+const de_QueryInfoList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_json1_1QueryInfo(entry, context);
+        return de_QueryInfo(entry, context);
     });
     return retVal;
 };
-const deserializeAws_json1_1QueryResults = (output, context) => {
+const de_QueryResults = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_json1_1ResultRows(entry, context);
+        return de_ResultRows(entry, context);
     });
     return retVal;
 };
-const deserializeAws_json1_1QueryStatistics = (output, context) => {
+const de_QueryStatistics = (output, context) => {
     return {
         bytesScanned: __limitedParseDouble(output.bytesScanned),
         recordsMatched: __limitedParseDouble(output.recordsMatched),
         recordsScanned: __limitedParseDouble(output.recordsScanned),
     };
 };
-const deserializeAws_json1_1RejectedLogEventsInfo = (output, context) => {
+const de_RejectedLogEventsInfo = (output, context) => {
     return {
         expiredLogEventEndIndex: __expectInt32(output.expiredLogEventEndIndex),
         tooNewLogEventStartIndex: __expectInt32(output.tooNewLogEventStartIndex),
         tooOldLogEventEndIndex: __expectInt32(output.tooOldLogEventEndIndex),
     };
 };
-const deserializeAws_json1_1ResourceAlreadyExistsException = (output, context) => {
+const de_ResourceAlreadyExistsException = (output, context) => {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_1ResourceNotFoundException = (output, context) => {
+const de_ResourceNotFoundException = (output, context) => {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_1ResourcePolicies = (output, context) => {
+const de_ResourcePolicies = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_json1_1ResourcePolicy(entry, context);
+        return de_ResourcePolicy(entry, context);
     });
     return retVal;
 };
-const deserializeAws_json1_1ResourcePolicy = (output, context) => {
+const de_ResourcePolicy = (output, context) => {
     return {
         lastUpdatedTime: __expectLong(output.lastUpdatedTime),
         policyDocument: __expectString(output.policyDocument),
         policyName: __expectString(output.policyName),
     };
 };
-const deserializeAws_json1_1ResultField = (output, context) => {
+const de_ResultField = (output, context) => {
     return {
         field: __expectString(output.field),
         value: __expectString(output.value),
     };
 };
-const deserializeAws_json1_1ResultRows = (output, context) => {
+const de_ResultRows = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_json1_1ResultField(entry, context);
+        return de_ResultField(entry, context);
     });
     return retVal;
 };
-const deserializeAws_json1_1SearchedLogStream = (output, context) => {
+const de_SearchedLogStream = (output, context) => {
     return {
         logStreamName: __expectString(output.logStreamName),
         searchedCompletely: __expectBoolean(output.searchedCompletely),
     };
 };
-const deserializeAws_json1_1SearchedLogStreams = (output, context) => {
+const de_SearchedLogStreams = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_json1_1SearchedLogStream(entry, context);
+        return de_SearchedLogStream(entry, context);
     });
     return retVal;
 };
-const deserializeAws_json1_1ServiceUnavailableException = (output, context) => {
+const de_ServiceUnavailableException = (output, context) => {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_1StartQueryResponse = (output, context) => {
+const de_StartQueryResponse = (output, context) => {
     return {
         queryId: __expectString(output.queryId),
     };
 };
-const deserializeAws_json1_1StopQueryResponse = (output, context) => {
+const de_StopQueryResponse = (output, context) => {
     return {
         success: __expectBoolean(output.success),
     };
 };
-const deserializeAws_json1_1SubscriptionFilter = (output, context) => {
+const de_SubscriptionFilter = (output, context) => {
     return {
         creationTime: __expectLong(output.creationTime),
         destinationArn: __expectString(output.destinationArn),
@@ -3486,18 +3460,18 @@ const deserializeAws_json1_1SubscriptionFilter = (output, context) => {
         roleArn: __expectString(output.roleArn),
     };
 };
-const deserializeAws_json1_1SubscriptionFilters = (output, context) => {
+const de_SubscriptionFilters = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_json1_1SubscriptionFilter(entry, context);
+        return de_SubscriptionFilter(entry, context);
     });
     return retVal;
 };
-const deserializeAws_json1_1Tags = (output, context) => {
+const de_Tags = (output, context) => {
     return Object.entries(output).reduce((acc, [key, value]) => {
         if (value === null) {
             return acc;
@@ -3506,18 +3480,18 @@ const deserializeAws_json1_1Tags = (output, context) => {
         return acc;
     }, {});
 };
-const deserializeAws_json1_1TestMetricFilterResponse = (output, context) => {
+const de_TestMetricFilterResponse = (output, context) => {
     return {
-        matches: output.matches != null ? deserializeAws_json1_1MetricFilterMatches(output.matches, context) : undefined,
+        matches: output.matches != null ? de_MetricFilterMatches(output.matches, context) : undefined,
     };
 };
-const deserializeAws_json1_1TooManyTagsException = (output, context) => {
+const de_TooManyTagsException = (output, context) => {
     return {
         message: __expectString(output.message),
         resourceName: __expectString(output.resourceName),
     };
 };
-const deserializeAws_json1_1UnrecognizedClientException = (output, context) => {
+const de_UnrecognizedClientException = (output, context) => {
     return {
         message: __expectString(output.message),
     };