@aws-sdk/client-cloudwatch 3.303.0 → 3.309.0

package/dist-es/protocols/Aws_query.js

@@ -3,465 +3,465 @@ import { decorateServiceException as __decorateServiceException, expectNonNull a
 import { XMLParser } from "fast-xml-parser";
 import { CloudWatchServiceException as __BaseException } from "../models/CloudWatchServiceException";
 import { ConcurrentModificationException, DashboardInvalidInputError, DashboardNotFoundError, InternalServiceFault, InvalidFormatFault, InvalidNextToken, InvalidParameterCombinationException, InvalidParameterValueException, LimitExceededException, LimitExceededFault, MissingRequiredParameterException, ResourceNotFound, ResourceNotFoundException, } from "../models/models_0";
-export const serializeAws_queryDeleteAlarmsCommand = async (input, context) => {
+export const se_DeleteAlarmsCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryDeleteAlarmsInput(input, context),
+        ...se_DeleteAlarmsInput(input, context),
         Action: "DeleteAlarms",
         Version: "2010-08-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryDeleteAnomalyDetectorCommand = async (input, context) => {
+export const se_DeleteAnomalyDetectorCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryDeleteAnomalyDetectorInput(input, context),
+        ...se_DeleteAnomalyDetectorInput(input, context),
         Action: "DeleteAnomalyDetector",
         Version: "2010-08-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryDeleteDashboardsCommand = async (input, context) => {
+export const se_DeleteDashboardsCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryDeleteDashboardsInput(input, context),
+        ...se_DeleteDashboardsInput(input, context),
         Action: "DeleteDashboards",
         Version: "2010-08-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryDeleteInsightRulesCommand = async (input, context) => {
+export const se_DeleteInsightRulesCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryDeleteInsightRulesInput(input, context),
+        ...se_DeleteInsightRulesInput(input, context),
         Action: "DeleteInsightRules",
         Version: "2010-08-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryDeleteMetricStreamCommand = async (input, context) => {
+export const se_DeleteMetricStreamCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryDeleteMetricStreamInput(input, context),
+        ...se_DeleteMetricStreamInput(input, context),
         Action: "DeleteMetricStream",
         Version: "2010-08-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryDescribeAlarmHistoryCommand = async (input, context) => {
+export const se_DescribeAlarmHistoryCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryDescribeAlarmHistoryInput(input, context),
+        ...se_DescribeAlarmHistoryInput(input, context),
         Action: "DescribeAlarmHistory",
         Version: "2010-08-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryDescribeAlarmsCommand = async (input, context) => {
+export const se_DescribeAlarmsCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryDescribeAlarmsInput(input, context),
+        ...se_DescribeAlarmsInput(input, context),
         Action: "DescribeAlarms",
         Version: "2010-08-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryDescribeAlarmsForMetricCommand = async (input, context) => {
+export const se_DescribeAlarmsForMetricCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryDescribeAlarmsForMetricInput(input, context),
+        ...se_DescribeAlarmsForMetricInput(input, context),
         Action: "DescribeAlarmsForMetric",
         Version: "2010-08-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryDescribeAnomalyDetectorsCommand = async (input, context) => {
+export const se_DescribeAnomalyDetectorsCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryDescribeAnomalyDetectorsInput(input, context),
+        ...se_DescribeAnomalyDetectorsInput(input, context),
         Action: "DescribeAnomalyDetectors",
         Version: "2010-08-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryDescribeInsightRulesCommand = async (input, context) => {
+export const se_DescribeInsightRulesCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryDescribeInsightRulesInput(input, context),
+        ...se_DescribeInsightRulesInput(input, context),
         Action: "DescribeInsightRules",
         Version: "2010-08-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryDisableAlarmActionsCommand = async (input, context) => {
+export const se_DisableAlarmActionsCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryDisableAlarmActionsInput(input, context),
+        ...se_DisableAlarmActionsInput(input, context),
         Action: "DisableAlarmActions",
         Version: "2010-08-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryDisableInsightRulesCommand = async (input, context) => {
+export const se_DisableInsightRulesCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryDisableInsightRulesInput(input, context),
+        ...se_DisableInsightRulesInput(input, context),
         Action: "DisableInsightRules",
         Version: "2010-08-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryEnableAlarmActionsCommand = async (input, context) => {
+export const se_EnableAlarmActionsCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryEnableAlarmActionsInput(input, context),
+        ...se_EnableAlarmActionsInput(input, context),
         Action: "EnableAlarmActions",
         Version: "2010-08-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryEnableInsightRulesCommand = async (input, context) => {
+export const se_EnableInsightRulesCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryEnableInsightRulesInput(input, context),
+        ...se_EnableInsightRulesInput(input, context),
         Action: "EnableInsightRules",
         Version: "2010-08-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryGetDashboardCommand = async (input, context) => {
+export const se_GetDashboardCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryGetDashboardInput(input, context),
+        ...se_GetDashboardInput(input, context),
         Action: "GetDashboard",
         Version: "2010-08-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryGetInsightRuleReportCommand = async (input, context) => {
+export const se_GetInsightRuleReportCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryGetInsightRuleReportInput(input, context),
+        ...se_GetInsightRuleReportInput(input, context),
         Action: "GetInsightRuleReport",
         Version: "2010-08-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryGetMetricDataCommand = async (input, context) => {
+export const se_GetMetricDataCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryGetMetricDataInput(input, context),
+        ...se_GetMetricDataInput(input, context),
         Action: "GetMetricData",
         Version: "2010-08-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryGetMetricStatisticsCommand = async (input, context) => {
+export const se_GetMetricStatisticsCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryGetMetricStatisticsInput(input, context),
+        ...se_GetMetricStatisticsInput(input, context),
         Action: "GetMetricStatistics",
         Version: "2010-08-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryGetMetricStreamCommand = async (input, context) => {
+export const se_GetMetricStreamCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryGetMetricStreamInput(input, context),
+        ...se_GetMetricStreamInput(input, context),
         Action: "GetMetricStream",
         Version: "2010-08-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryGetMetricWidgetImageCommand = async (input, context) => {
+export const se_GetMetricWidgetImageCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryGetMetricWidgetImageInput(input, context),
+        ...se_GetMetricWidgetImageInput(input, context),
         Action: "GetMetricWidgetImage",
         Version: "2010-08-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryListDashboardsCommand = async (input, context) => {
+export const se_ListDashboardsCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryListDashboardsInput(input, context),
+        ...se_ListDashboardsInput(input, context),
         Action: "ListDashboards",
         Version: "2010-08-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryListManagedInsightRulesCommand = async (input, context) => {
+export const se_ListManagedInsightRulesCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryListManagedInsightRulesInput(input, context),
+        ...se_ListManagedInsightRulesInput(input, context),
         Action: "ListManagedInsightRules",
         Version: "2010-08-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryListMetricsCommand = async (input, context) => {
+export const se_ListMetricsCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryListMetricsInput(input, context),
+        ...se_ListMetricsInput(input, context),
         Action: "ListMetrics",
         Version: "2010-08-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryListMetricStreamsCommand = async (input, context) => {
+export const se_ListMetricStreamsCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryListMetricStreamsInput(input, context),
+        ...se_ListMetricStreamsInput(input, context),
         Action: "ListMetricStreams",
         Version: "2010-08-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryListTagsForResourceCommand = async (input, context) => {
+export const se_ListTagsForResourceCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryListTagsForResourceInput(input, context),
+        ...se_ListTagsForResourceInput(input, context),
         Action: "ListTagsForResource",
         Version: "2010-08-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryPutAnomalyDetectorCommand = async (input, context) => {
+export const se_PutAnomalyDetectorCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryPutAnomalyDetectorInput(input, context),
+        ...se_PutAnomalyDetectorInput(input, context),
         Action: "PutAnomalyDetector",
         Version: "2010-08-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryPutCompositeAlarmCommand = async (input, context) => {
+export const se_PutCompositeAlarmCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryPutCompositeAlarmInput(input, context),
+        ...se_PutCompositeAlarmInput(input, context),
         Action: "PutCompositeAlarm",
         Version: "2010-08-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryPutDashboardCommand = async (input, context) => {
+export const se_PutDashboardCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryPutDashboardInput(input, context),
+        ...se_PutDashboardInput(input, context),
         Action: "PutDashboard",
         Version: "2010-08-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryPutInsightRuleCommand = async (input, context) => {
+export const se_PutInsightRuleCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryPutInsightRuleInput(input, context),
+        ...se_PutInsightRuleInput(input, context),
         Action: "PutInsightRule",
         Version: "2010-08-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryPutManagedInsightRulesCommand = async (input, context) => {
+export const se_PutManagedInsightRulesCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryPutManagedInsightRulesInput(input, context),
+        ...se_PutManagedInsightRulesInput(input, context),
         Action: "PutManagedInsightRules",
         Version: "2010-08-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryPutMetricAlarmCommand = async (input, context) => {
+export const se_PutMetricAlarmCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryPutMetricAlarmInput(input, context),
+        ...se_PutMetricAlarmInput(input, context),
         Action: "PutMetricAlarm",
         Version: "2010-08-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryPutMetricDataCommand = async (input, context) => {
+export const se_PutMetricDataCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryPutMetricDataInput(input, context),
+        ...se_PutMetricDataInput(input, context),
         Action: "PutMetricData",
         Version: "2010-08-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryPutMetricStreamCommand = async (input, context) => {
+export const se_PutMetricStreamCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryPutMetricStreamInput(input, context),
+        ...se_PutMetricStreamInput(input, context),
         Action: "PutMetricStream",
         Version: "2010-08-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_querySetAlarmStateCommand = async (input, context) => {
+export const se_SetAlarmStateCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_querySetAlarmStateInput(input, context),
+        ...se_SetAlarmStateInput(input, context),
         Action: "SetAlarmState",
         Version: "2010-08-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryStartMetricStreamsCommand = async (input, context) => {
+export const se_StartMetricStreamsCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryStartMetricStreamsInput(input, context),
+        ...se_StartMetricStreamsInput(input, context),
         Action: "StartMetricStreams",
         Version: "2010-08-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryStopMetricStreamsCommand = async (input, context) => {
+export const se_StopMetricStreamsCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryStopMetricStreamsInput(input, context),
+        ...se_StopMetricStreamsInput(input, context),
         Action: "StopMetricStreams",
         Version: "2010-08-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryTagResourceCommand = async (input, context) => {
+export const se_TagResourceCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryTagResourceInput(input, context),
+        ...se_TagResourceInput(input, context),
         Action: "TagResource",
         Version: "2010-08-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryUntagResourceCommand = async (input, context) => {
+export const se_UntagResourceCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryUntagResourceInput(input, context),
+        ...se_UntagResourceInput(input, context),
         Action: "UntagResource",
         Version: "2010-08-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const deserializeAws_queryDeleteAlarmsCommand = async (output, context) => {
+export const de_DeleteAlarmsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryDeleteAlarmsCommandError(output, context);
+        return de_DeleteAlarmsCommandError(output, context);
     }
     await collectBody(output.body, context);
     const response = {
@@ -469,7 +469,7 @@ export const deserializeAws_queryDeleteAlarmsCommand = async (output, context) =
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryDeleteAlarmsCommandError = async (output, context) => {
+const de_DeleteAlarmsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -478,7 +478,7 @@ const deserializeAws_queryDeleteAlarmsCommandError = async (output, context) =>
     switch (errorCode) {
         case "ResourceNotFound":
         case "com.amazonaws.cloudwatch#ResourceNotFound":
-            throw await deserializeAws_queryResourceNotFoundResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -489,20 +489,20 @@ const deserializeAws_queryDeleteAlarmsCommandError = async (output, context) =>
             });
     }
 };
-export const deserializeAws_queryDeleteAnomalyDetectorCommand = async (output, context) => {
+export const de_DeleteAnomalyDetectorCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryDeleteAnomalyDetectorCommandError(output, context);
+        return de_DeleteAnomalyDetectorCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryDeleteAnomalyDetectorOutput(data.DeleteAnomalyDetectorResult, context);
+    contents = de_DeleteAnomalyDetectorOutput(data.DeleteAnomalyDetectorResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryDeleteAnomalyDetectorCommandError = async (output, context) => {
+const de_DeleteAnomalyDetectorCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -511,19 +511,19 @@ const deserializeAws_queryDeleteAnomalyDetectorCommandError = async (output, con
     switch (errorCode) {
         case "InternalServiceError":
         case "com.amazonaws.cloudwatch#InternalServiceFault":
-            throw await deserializeAws_queryInternalServiceFaultResponse(parsedOutput, context);
+            throw await de_InternalServiceFaultRes(parsedOutput, context);
         case "InvalidParameterCombination":
         case "com.amazonaws.cloudwatch#InvalidParameterCombinationException":
-            throw await deserializeAws_queryInvalidParameterCombinationExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
         case "InvalidParameterValue":
         case "com.amazonaws.cloudwatch#InvalidParameterValueException":
-            throw await deserializeAws_queryInvalidParameterValueExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
         case "MissingParameter":
         case "com.amazonaws.cloudwatch#MissingRequiredParameterException":
-            throw await deserializeAws_queryMissingRequiredParameterExceptionResponse(parsedOutput, context);
+            throw await de_MissingRequiredParameterExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.cloudwatch#ResourceNotFoundException":
-            throw await deserializeAws_queryResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -534,20 +534,20 @@ const deserializeAws_queryDeleteAnomalyDetectorCommandError = async (output, con
             });
     }
 };
-export const deserializeAws_queryDeleteDashboardsCommand = async (output, context) => {
+export const de_DeleteDashboardsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryDeleteDashboardsCommandError(output, context);
+        return de_DeleteDashboardsCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryDeleteDashboardsOutput(data.DeleteDashboardsResult, context);
+    contents = de_DeleteDashboardsOutput(data.DeleteDashboardsResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryDeleteDashboardsCommandError = async (output, context) => {
+const de_DeleteDashboardsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -556,13 +556,13 @@ const deserializeAws_queryDeleteDashboardsCommandError = async (output, context)
     switch (errorCode) {
         case "InternalServiceError":
         case "com.amazonaws.cloudwatch#InternalServiceFault":
-            throw await deserializeAws_queryInternalServiceFaultResponse(parsedOutput, context);
+            throw await de_InternalServiceFaultRes(parsedOutput, context);
         case "InvalidParameterValue":
         case "com.amazonaws.cloudwatch#InvalidParameterValueException":
-            throw await deserializeAws_queryInvalidParameterValueExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
         case "ResourceNotFound":
         case "com.amazonaws.cloudwatch#DashboardNotFoundError":
-            throw await deserializeAws_queryDashboardNotFoundErrorResponse(parsedOutput, context);
+            throw await de_DashboardNotFoundErrorRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -573,20 +573,20 @@ const deserializeAws_queryDeleteDashboardsCommandError = async (output, context)
             });
     }
 };
-export const deserializeAws_queryDeleteInsightRulesCommand = async (output, context) => {
+export const de_DeleteInsightRulesCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryDeleteInsightRulesCommandError(output, context);
+        return de_DeleteInsightRulesCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryDeleteInsightRulesOutput(data.DeleteInsightRulesResult, context);
+    contents = de_DeleteInsightRulesOutput(data.DeleteInsightRulesResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryDeleteInsightRulesCommandError = async (output, context) => {
+const de_DeleteInsightRulesCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -595,10 +595,10 @@ const deserializeAws_queryDeleteInsightRulesCommandError = async (output, contex
     switch (errorCode) {
         case "InvalidParameterValue":
         case "com.amazonaws.cloudwatch#InvalidParameterValueException":
-            throw await deserializeAws_queryInvalidParameterValueExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
         case "MissingParameter":
         case "com.amazonaws.cloudwatch#MissingRequiredParameterException":
-            throw await deserializeAws_queryMissingRequiredParameterExceptionResponse(parsedOutput, context);
+            throw await de_MissingRequiredParameterExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -609,20 +609,20 @@ const deserializeAws_queryDeleteInsightRulesCommandError = async (output, contex
             });
     }
 };
-export const deserializeAws_queryDeleteMetricStreamCommand = async (output, context) => {
+export const de_DeleteMetricStreamCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryDeleteMetricStreamCommandError(output, context);
+        return de_DeleteMetricStreamCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryDeleteMetricStreamOutput(data.DeleteMetricStreamResult, context);
+    contents = de_DeleteMetricStreamOutput(data.DeleteMetricStreamResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryDeleteMetricStreamCommandError = async (output, context) => {
+const de_DeleteMetricStreamCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -631,13 +631,13 @@ const deserializeAws_queryDeleteMetricStreamCommandError = async (output, contex
     switch (errorCode) {
         case "InternalServiceError":
         case "com.amazonaws.cloudwatch#InternalServiceFault":
-            throw await deserializeAws_queryInternalServiceFaultResponse(parsedOutput, context);
+            throw await de_InternalServiceFaultRes(parsedOutput, context);
         case "InvalidParameterValue":
         case "com.amazonaws.cloudwatch#InvalidParameterValueException":
-            throw await deserializeAws_queryInvalidParameterValueExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
         case "MissingParameter":
         case "com.amazonaws.cloudwatch#MissingRequiredParameterException":
-            throw await deserializeAws_queryMissingRequiredParameterExceptionResponse(parsedOutput, context);
+            throw await de_MissingRequiredParameterExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -648,20 +648,20 @@ const deserializeAws_queryDeleteMetricStreamCommandError = async (output, contex
             });
     }
 };
-export const deserializeAws_queryDescribeAlarmHistoryCommand = async (output, context) => {
+export const de_DescribeAlarmHistoryCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryDescribeAlarmHistoryCommandError(output, context);
+        return de_DescribeAlarmHistoryCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryDescribeAlarmHistoryOutput(data.DescribeAlarmHistoryResult, context);
+    contents = de_DescribeAlarmHistoryOutput(data.DescribeAlarmHistoryResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryDescribeAlarmHistoryCommandError = async (output, context) => {
+const de_DescribeAlarmHistoryCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -670,7 +670,7 @@ const deserializeAws_queryDescribeAlarmHistoryCommandError = async (output, cont
     switch (errorCode) {
         case "InvalidNextToken":
         case "com.amazonaws.cloudwatch#InvalidNextToken":
-            throw await deserializeAws_queryInvalidNextTokenResponse(parsedOutput, context);
+            throw await de_InvalidNextTokenRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -681,20 +681,20 @@ const deserializeAws_queryDescribeAlarmHistoryCommandError = async (output, cont
             });
     }
 };
-export const deserializeAws_queryDescribeAlarmsCommand = async (output, context) => {
+export const de_DescribeAlarmsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryDescribeAlarmsCommandError(output, context);
+        return de_DescribeAlarmsCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryDescribeAlarmsOutput(data.DescribeAlarmsResult, context);
+    contents = de_DescribeAlarmsOutput(data.DescribeAlarmsResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryDescribeAlarmsCommandError = async (output, context) => {
+const de_DescribeAlarmsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -703,7 +703,7 @@ const deserializeAws_queryDescribeAlarmsCommandError = async (output, context) =
     switch (errorCode) {
         case "InvalidNextToken":
         case "com.amazonaws.cloudwatch#InvalidNextToken":
-            throw await deserializeAws_queryInvalidNextTokenResponse(parsedOutput, context);
+            throw await de_InvalidNextTokenRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -714,20 +714,20 @@ const deserializeAws_queryDescribeAlarmsCommandError = async (output, context) =
             });
     }
 };
-export const deserializeAws_queryDescribeAlarmsForMetricCommand = async (output, context) => {
+export const de_DescribeAlarmsForMetricCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryDescribeAlarmsForMetricCommandError(output, context);
+        return de_DescribeAlarmsForMetricCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryDescribeAlarmsForMetricOutput(data.DescribeAlarmsForMetricResult, context);
+    contents = de_DescribeAlarmsForMetricOutput(data.DescribeAlarmsForMetricResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryDescribeAlarmsForMetricCommandError = async (output, context) => {
+const de_DescribeAlarmsForMetricCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -741,20 +741,20 @@ const deserializeAws_queryDescribeAlarmsForMetricCommandError = async (output, c
         errorCode,
     });
 };
-export const deserializeAws_queryDescribeAnomalyDetectorsCommand = async (output, context) => {
+export const de_DescribeAnomalyDetectorsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryDescribeAnomalyDetectorsCommandError(output, context);
+        return de_DescribeAnomalyDetectorsCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryDescribeAnomalyDetectorsOutput(data.DescribeAnomalyDetectorsResult, context);
+    contents = de_DescribeAnomalyDetectorsOutput(data.DescribeAnomalyDetectorsResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryDescribeAnomalyDetectorsCommandError = async (output, context) => {
+const de_DescribeAnomalyDetectorsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -763,16 +763,16 @@ const deserializeAws_queryDescribeAnomalyDetectorsCommandError = async (output,
     switch (errorCode) {
         case "InternalServiceError":
         case "com.amazonaws.cloudwatch#InternalServiceFault":
-            throw await deserializeAws_queryInternalServiceFaultResponse(parsedOutput, context);
+            throw await de_InternalServiceFaultRes(parsedOutput, context);
         case "InvalidNextToken":
         case "com.amazonaws.cloudwatch#InvalidNextToken":
-            throw await deserializeAws_queryInvalidNextTokenResponse(parsedOutput, context);
+            throw await de_InvalidNextTokenRes(parsedOutput, context);
         case "InvalidParameterCombination":
         case "com.amazonaws.cloudwatch#InvalidParameterCombinationException":
-            throw await deserializeAws_queryInvalidParameterCombinationExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
         case "InvalidParameterValue":
         case "com.amazonaws.cloudwatch#InvalidParameterValueException":
-            throw await deserializeAws_queryInvalidParameterValueExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -783,20 +783,20 @@ const deserializeAws_queryDescribeAnomalyDetectorsCommandError = async (output,
             });
     }
 };
-export const deserializeAws_queryDescribeInsightRulesCommand = async (output, context) => {
+export const de_DescribeInsightRulesCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryDescribeInsightRulesCommandError(output, context);
+        return de_DescribeInsightRulesCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryDescribeInsightRulesOutput(data.DescribeInsightRulesResult, context);
+    contents = de_DescribeInsightRulesOutput(data.DescribeInsightRulesResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryDescribeInsightRulesCommandError = async (output, context) => {
+const de_DescribeInsightRulesCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -805,7 +805,7 @@ const deserializeAws_queryDescribeInsightRulesCommandError = async (output, cont
     switch (errorCode) {
         case "InvalidNextToken":
         case "com.amazonaws.cloudwatch#InvalidNextToken":
-            throw await deserializeAws_queryInvalidNextTokenResponse(parsedOutput, context);
+            throw await de_InvalidNextTokenRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -816,9 +816,9 @@ const deserializeAws_queryDescribeInsightRulesCommandError = async (output, cont
             });
     }
 };
-export const deserializeAws_queryDisableAlarmActionsCommand = async (output, context) => {
+export const de_DisableAlarmActionsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryDisableAlarmActionsCommandError(output, context);
+        return de_DisableAlarmActionsCommandError(output, context);
     }
     await collectBody(output.body, context);
     const response = {
@@ -826,7 +826,7 @@ export const deserializeAws_queryDisableAlarmActionsCommand = async (output, con
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryDisableAlarmActionsCommandError = async (output, context) => {
+const de_DisableAlarmActionsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -840,20 +840,20 @@ const deserializeAws_queryDisableAlarmActionsCommandError = async (output, conte
         errorCode,
     });
 };
-export const deserializeAws_queryDisableInsightRulesCommand = async (output, context) => {
+export const de_DisableInsightRulesCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryDisableInsightRulesCommandError(output, context);
+        return de_DisableInsightRulesCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryDisableInsightRulesOutput(data.DisableInsightRulesResult, context);
+    contents = de_DisableInsightRulesOutput(data.DisableInsightRulesResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryDisableInsightRulesCommandError = async (output, context) => {
+const de_DisableInsightRulesCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -862,10 +862,10 @@ const deserializeAws_queryDisableInsightRulesCommandError = async (output, conte
     switch (errorCode) {
         case "InvalidParameterValue":
         case "com.amazonaws.cloudwatch#InvalidParameterValueException":
-            throw await deserializeAws_queryInvalidParameterValueExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
         case "MissingParameter":
         case "com.amazonaws.cloudwatch#MissingRequiredParameterException":
-            throw await deserializeAws_queryMissingRequiredParameterExceptionResponse(parsedOutput, context);
+            throw await de_MissingRequiredParameterExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -876,9 +876,9 @@ const deserializeAws_queryDisableInsightRulesCommandError = async (output, conte
             });
     }
 };
-export const deserializeAws_queryEnableAlarmActionsCommand = async (output, context) => {
+export const de_EnableAlarmActionsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryEnableAlarmActionsCommandError(output, context);
+        return de_EnableAlarmActionsCommandError(output, context);
     }
     await collectBody(output.body, context);
     const response = {
@@ -886,7 +886,7 @@ export const deserializeAws_queryEnableAlarmActionsCommand = async (output, cont
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryEnableAlarmActionsCommandError = async (output, context) => {
+const de_EnableAlarmActionsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -900,20 +900,20 @@ const deserializeAws_queryEnableAlarmActionsCommandError = async (output, contex
         errorCode,
     });
 };
-export const deserializeAws_queryEnableInsightRulesCommand = async (output, context) => {
+export const de_EnableInsightRulesCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryEnableInsightRulesCommandError(output, context);
+        return de_EnableInsightRulesCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryEnableInsightRulesOutput(data.EnableInsightRulesResult, context);
+    contents = de_EnableInsightRulesOutput(data.EnableInsightRulesResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryEnableInsightRulesCommandError = async (output, context) => {
+const de_EnableInsightRulesCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -922,13 +922,13 @@ const deserializeAws_queryEnableInsightRulesCommandError = async (output, contex
     switch (errorCode) {
         case "InvalidParameterValue":
         case "com.amazonaws.cloudwatch#InvalidParameterValueException":
-            throw await deserializeAws_queryInvalidParameterValueExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
         case "LimitExceededException":
         case "com.amazonaws.cloudwatch#LimitExceededException":
-            throw await deserializeAws_queryLimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         case "MissingParameter":
         case "com.amazonaws.cloudwatch#MissingRequiredParameterException":
-            throw await deserializeAws_queryMissingRequiredParameterExceptionResponse(parsedOutput, context);
+            throw await de_MissingRequiredParameterExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -939,20 +939,20 @@ const deserializeAws_queryEnableInsightRulesCommandError = async (output, contex
             });
     }
 };
-export const deserializeAws_queryGetDashboardCommand = async (output, context) => {
+export const de_GetDashboardCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryGetDashboardCommandError(output, context);
+        return de_GetDashboardCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryGetDashboardOutput(data.GetDashboardResult, context);
+    contents = de_GetDashboardOutput(data.GetDashboardResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryGetDashboardCommandError = async (output, context) => {
+const de_GetDashboardCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -961,13 +961,13 @@ const deserializeAws_queryGetDashboardCommandError = async (output, context) =>
     switch (errorCode) {
         case "InternalServiceError":
         case "com.amazonaws.cloudwatch#InternalServiceFault":
-            throw await deserializeAws_queryInternalServiceFaultResponse(parsedOutput, context);
+            throw await de_InternalServiceFaultRes(parsedOutput, context);
         case "InvalidParameterValue":
         case "com.amazonaws.cloudwatch#InvalidParameterValueException":
-            throw await deserializeAws_queryInvalidParameterValueExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
         case "ResourceNotFound":
         case "com.amazonaws.cloudwatch#DashboardNotFoundError":
-            throw await deserializeAws_queryDashboardNotFoundErrorResponse(parsedOutput, context);
+            throw await de_DashboardNotFoundErrorRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -978,20 +978,20 @@ const deserializeAws_queryGetDashboardCommandError = async (output, context) =>
             });
     }
 };
-export const deserializeAws_queryGetInsightRuleReportCommand = async (output, context) => {
+export const de_GetInsightRuleReportCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryGetInsightRuleReportCommandError(output, context);
+        return de_GetInsightRuleReportCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryGetInsightRuleReportOutput(data.GetInsightRuleReportResult, context);
+    contents = de_GetInsightRuleReportOutput(data.GetInsightRuleReportResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryGetInsightRuleReportCommandError = async (output, context) => {
+const de_GetInsightRuleReportCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1000,13 +1000,13 @@ const deserializeAws_queryGetInsightRuleReportCommandError = async (output, cont
     switch (errorCode) {
         case "InvalidParameterValue":
         case "com.amazonaws.cloudwatch#InvalidParameterValueException":
-            throw await deserializeAws_queryInvalidParameterValueExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
         case "MissingParameter":
         case "com.amazonaws.cloudwatch#MissingRequiredParameterException":
-            throw await deserializeAws_queryMissingRequiredParameterExceptionResponse(parsedOutput, context);
+            throw await de_MissingRequiredParameterExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.cloudwatch#ResourceNotFoundException":
-            throw await deserializeAws_queryResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1017,20 +1017,20 @@ const deserializeAws_queryGetInsightRuleReportCommandError = async (output, cont
             });
     }
 };
-export const deserializeAws_queryGetMetricDataCommand = async (output, context) => {
+export const de_GetMetricDataCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryGetMetricDataCommandError(output, context);
+        return de_GetMetricDataCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryGetMetricDataOutput(data.GetMetricDataResult, context);
+    contents = de_GetMetricDataOutput(data.GetMetricDataResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryGetMetricDataCommandError = async (output, context) => {
+const de_GetMetricDataCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1039,7 +1039,7 @@ const deserializeAws_queryGetMetricDataCommandError = async (output, context) =>
     switch (errorCode) {
         case "InvalidNextToken":
         case "com.amazonaws.cloudwatch#InvalidNextToken":
-            throw await deserializeAws_queryInvalidNextTokenResponse(parsedOutput, context);
+            throw await de_InvalidNextTokenRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1050,20 +1050,20 @@ const deserializeAws_queryGetMetricDataCommandError = async (output, context) =>
             });
     }
 };
-export const deserializeAws_queryGetMetricStatisticsCommand = async (output, context) => {
+export const de_GetMetricStatisticsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryGetMetricStatisticsCommandError(output, context);
+        return de_GetMetricStatisticsCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryGetMetricStatisticsOutput(data.GetMetricStatisticsResult, context);
+    contents = de_GetMetricStatisticsOutput(data.GetMetricStatisticsResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryGetMetricStatisticsCommandError = async (output, context) => {
+const de_GetMetricStatisticsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1072,16 +1072,16 @@ const deserializeAws_queryGetMetricStatisticsCommandError = async (output, conte
     switch (errorCode) {
         case "InternalServiceError":
         case "com.amazonaws.cloudwatch#InternalServiceFault":
-            throw await deserializeAws_queryInternalServiceFaultResponse(parsedOutput, context);
+            throw await de_InternalServiceFaultRes(parsedOutput, context);
         case "InvalidParameterCombination":
         case "com.amazonaws.cloudwatch#InvalidParameterCombinationException":
-            throw await deserializeAws_queryInvalidParameterCombinationExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
         case "InvalidParameterValue":
         case "com.amazonaws.cloudwatch#InvalidParameterValueException":
-            throw await deserializeAws_queryInvalidParameterValueExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
         case "MissingParameter":
         case "com.amazonaws.cloudwatch#MissingRequiredParameterException":
-            throw await deserializeAws_queryMissingRequiredParameterExceptionResponse(parsedOutput, context);
+            throw await de_MissingRequiredParameterExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1092,20 +1092,20 @@ const deserializeAws_queryGetMetricStatisticsCommandError = async (output, conte
             });
     }
 };
-export const deserializeAws_queryGetMetricStreamCommand = async (output, context) => {
+export const de_GetMetricStreamCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryGetMetricStreamCommandError(output, context);
+        return de_GetMetricStreamCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryGetMetricStreamOutput(data.GetMetricStreamResult, context);
+    contents = de_GetMetricStreamOutput(data.GetMetricStreamResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryGetMetricStreamCommandError = async (output, context) => {
+const de_GetMetricStreamCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1114,19 +1114,19 @@ const deserializeAws_queryGetMetricStreamCommandError = async (output, context)
     switch (errorCode) {
         case "InternalServiceError":
         case "com.amazonaws.cloudwatch#InternalServiceFault":
-            throw await deserializeAws_queryInternalServiceFaultResponse(parsedOutput, context);
+            throw await de_InternalServiceFaultRes(parsedOutput, context);
         case "InvalidParameterCombination":
         case "com.amazonaws.cloudwatch#InvalidParameterCombinationException":
-            throw await deserializeAws_queryInvalidParameterCombinationExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
         case "InvalidParameterValue":
         case "com.amazonaws.cloudwatch#InvalidParameterValueException":
-            throw await deserializeAws_queryInvalidParameterValueExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
         case "MissingParameter":
         case "com.amazonaws.cloudwatch#MissingRequiredParameterException":
-            throw await deserializeAws_queryMissingRequiredParameterExceptionResponse(parsedOutput, context);
+            throw await de_MissingRequiredParameterExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.cloudwatch#ResourceNotFoundException":
-            throw await deserializeAws_queryResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1137,20 +1137,20 @@ const deserializeAws_queryGetMetricStreamCommandError = async (output, context)
             });
     }
 };
-export const deserializeAws_queryGetMetricWidgetImageCommand = async (output, context) => {
+export const de_GetMetricWidgetImageCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryGetMetricWidgetImageCommandError(output, context);
+        return de_GetMetricWidgetImageCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryGetMetricWidgetImageOutput(data.GetMetricWidgetImageResult, context);
+    contents = de_GetMetricWidgetImageOutput(data.GetMetricWidgetImageResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryGetMetricWidgetImageCommandError = async (output, context) => {
+const de_GetMetricWidgetImageCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1164,20 +1164,20 @@ const deserializeAws_queryGetMetricWidgetImageCommandError = async (output, cont
         errorCode,
     });
 };
-export const deserializeAws_queryListDashboardsCommand = async (output, context) => {
+export const de_ListDashboardsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryListDashboardsCommandError(output, context);
+        return de_ListDashboardsCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryListDashboardsOutput(data.ListDashboardsResult, context);
+    contents = de_ListDashboardsOutput(data.ListDashboardsResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryListDashboardsCommandError = async (output, context) => {
+const de_ListDashboardsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1186,10 +1186,10 @@ const deserializeAws_queryListDashboardsCommandError = async (output, context) =
     switch (errorCode) {
         case "InternalServiceError":
         case "com.amazonaws.cloudwatch#InternalServiceFault":
-            throw await deserializeAws_queryInternalServiceFaultResponse(parsedOutput, context);
+            throw await de_InternalServiceFaultRes(parsedOutput, context);
         case "InvalidParameterValue":
         case "com.amazonaws.cloudwatch#InvalidParameterValueException":
-            throw await deserializeAws_queryInvalidParameterValueExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1200,20 +1200,20 @@ const deserializeAws_queryListDashboardsCommandError = async (output, context) =
             });
     }
 };
-export const deserializeAws_queryListManagedInsightRulesCommand = async (output, context) => {
+export const de_ListManagedInsightRulesCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryListManagedInsightRulesCommandError(output, context);
+        return de_ListManagedInsightRulesCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryListManagedInsightRulesOutput(data.ListManagedInsightRulesResult, context);
+    contents = de_ListManagedInsightRulesOutput(data.ListManagedInsightRulesResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryListManagedInsightRulesCommandError = async (output, context) => {
+const de_ListManagedInsightRulesCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1222,13 +1222,13 @@ const deserializeAws_queryListManagedInsightRulesCommandError = async (output, c
     switch (errorCode) {
         case "InvalidNextToken":
         case "com.amazonaws.cloudwatch#InvalidNextToken":
-            throw await deserializeAws_queryInvalidNextTokenResponse(parsedOutput, context);
+            throw await de_InvalidNextTokenRes(parsedOutput, context);
         case "InvalidParameterValue":
         case "com.amazonaws.cloudwatch#InvalidParameterValueException":
-            throw await deserializeAws_queryInvalidParameterValueExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
         case "MissingParameter":
         case "com.amazonaws.cloudwatch#MissingRequiredParameterException":
-            throw await deserializeAws_queryMissingRequiredParameterExceptionResponse(parsedOutput, context);
+            throw await de_MissingRequiredParameterExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1239,20 +1239,20 @@ const deserializeAws_queryListManagedInsightRulesCommandError = async (output, c
             });
     }
 };
-export const deserializeAws_queryListMetricsCommand = async (output, context) => {
+export const de_ListMetricsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryListMetricsCommandError(output, context);
+        return de_ListMetricsCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryListMetricsOutput(data.ListMetricsResult, context);
+    contents = de_ListMetricsOutput(data.ListMetricsResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryListMetricsCommandError = async (output, context) => {
+const de_ListMetricsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1261,10 +1261,10 @@ const deserializeAws_queryListMetricsCommandError = async (output, context) => {
     switch (errorCode) {
         case "InternalServiceError":
         case "com.amazonaws.cloudwatch#InternalServiceFault":
-            throw await deserializeAws_queryInternalServiceFaultResponse(parsedOutput, context);
+            throw await de_InternalServiceFaultRes(parsedOutput, context);
         case "InvalidParameterValue":
         case "com.amazonaws.cloudwatch#InvalidParameterValueException":
-            throw await deserializeAws_queryInvalidParameterValueExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1275,20 +1275,20 @@ const deserializeAws_queryListMetricsCommandError = async (output, context) => {
             });
     }
 };
-export const deserializeAws_queryListMetricStreamsCommand = async (output, context) => {
+export const de_ListMetricStreamsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryListMetricStreamsCommandError(output, context);
+        return de_ListMetricStreamsCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryListMetricStreamsOutput(data.ListMetricStreamsResult, context);
+    contents = de_ListMetricStreamsOutput(data.ListMetricStreamsResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryListMetricStreamsCommandError = async (output, context) => {
+const de_ListMetricStreamsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1297,16 +1297,16 @@ const deserializeAws_queryListMetricStreamsCommandError = async (output, context
     switch (errorCode) {
         case "InternalServiceError":
         case "com.amazonaws.cloudwatch#InternalServiceFault":
-            throw await deserializeAws_queryInternalServiceFaultResponse(parsedOutput, context);
+            throw await de_InternalServiceFaultRes(parsedOutput, context);
         case "InvalidNextToken":
         case "com.amazonaws.cloudwatch#InvalidNextToken":
-            throw await deserializeAws_queryInvalidNextTokenResponse(parsedOutput, context);
+            throw await de_InvalidNextTokenRes(parsedOutput, context);
         case "InvalidParameterValue":
         case "com.amazonaws.cloudwatch#InvalidParameterValueException":
-            throw await deserializeAws_queryInvalidParameterValueExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
         case "MissingParameter":
         case "com.amazonaws.cloudwatch#MissingRequiredParameterException":
-            throw await deserializeAws_queryMissingRequiredParameterExceptionResponse(parsedOutput, context);
+            throw await de_MissingRequiredParameterExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1317,20 +1317,20 @@ const deserializeAws_queryListMetricStreamsCommandError = async (output, context
             });
     }
 };
-export const deserializeAws_queryListTagsForResourceCommand = async (output, context) => {
+export const de_ListTagsForResourceCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryListTagsForResourceCommandError(output, context);
+        return de_ListTagsForResourceCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryListTagsForResourceOutput(data.ListTagsForResourceResult, context);
+    contents = de_ListTagsForResourceOutput(data.ListTagsForResourceResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryListTagsForResourceCommandError = async (output, context) => {
+const de_ListTagsForResourceCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1339,13 +1339,13 @@ const deserializeAws_queryListTagsForResourceCommandError = async (output, conte
     switch (errorCode) {
         case "InternalServiceError":
         case "com.amazonaws.cloudwatch#InternalServiceFault":
-            throw await deserializeAws_queryInternalServiceFaultResponse(parsedOutput, context);
+            throw await de_InternalServiceFaultRes(parsedOutput, context);
         case "InvalidParameterValue":
         case "com.amazonaws.cloudwatch#InvalidParameterValueException":
-            throw await deserializeAws_queryInvalidParameterValueExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.cloudwatch#ResourceNotFoundException":
-            throw await deserializeAws_queryResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1356,20 +1356,20 @@ const deserializeAws_queryListTagsForResourceCommandError = async (output, conte
             });
     }
 };
-export const deserializeAws_queryPutAnomalyDetectorCommand = async (output, context) => {
+export const de_PutAnomalyDetectorCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryPutAnomalyDetectorCommandError(output, context);
+        return de_PutAnomalyDetectorCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryPutAnomalyDetectorOutput(data.PutAnomalyDetectorResult, context);
+    contents = de_PutAnomalyDetectorOutput(data.PutAnomalyDetectorResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryPutAnomalyDetectorCommandError = async (output, context) => {
+const de_PutAnomalyDetectorCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1378,19 +1378,19 @@ const deserializeAws_queryPutAnomalyDetectorCommandError = async (output, contex
     switch (errorCode) {
         case "InternalServiceError":
         case "com.amazonaws.cloudwatch#InternalServiceFault":
-            throw await deserializeAws_queryInternalServiceFaultResponse(parsedOutput, context);
+            throw await de_InternalServiceFaultRes(parsedOutput, context);
         case "InvalidParameterCombination":
         case "com.amazonaws.cloudwatch#InvalidParameterCombinationException":
-            throw await deserializeAws_queryInvalidParameterCombinationExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
         case "InvalidParameterValue":
         case "com.amazonaws.cloudwatch#InvalidParameterValueException":
-            throw await deserializeAws_queryInvalidParameterValueExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
         case "LimitExceededException":
         case "com.amazonaws.cloudwatch#LimitExceededException":
-            throw await deserializeAws_queryLimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         case "MissingParameter":
         case "com.amazonaws.cloudwatch#MissingRequiredParameterException":
-            throw await deserializeAws_queryMissingRequiredParameterExceptionResponse(parsedOutput, context);
+            throw await de_MissingRequiredParameterExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1401,9 +1401,9 @@ const deserializeAws_queryPutAnomalyDetectorCommandError = async (output, contex
             });
     }
 };
-export const deserializeAws_queryPutCompositeAlarmCommand = async (output, context) => {
+export const de_PutCompositeAlarmCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryPutCompositeAlarmCommandError(output, context);
+        return de_PutCompositeAlarmCommandError(output, context);
     }
     await collectBody(output.body, context);
     const response = {
@@ -1411,7 +1411,7 @@ export const deserializeAws_queryPutCompositeAlarmCommand = async (output, conte
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryPutCompositeAlarmCommandError = async (output, context) => {
+const de_PutCompositeAlarmCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1420,7 +1420,7 @@ const deserializeAws_queryPutCompositeAlarmCommandError = async (output, context
     switch (errorCode) {
         case "LimitExceeded":
         case "com.amazonaws.cloudwatch#LimitExceededFault":
-            throw await deserializeAws_queryLimitExceededFaultResponse(parsedOutput, context);
+            throw await de_LimitExceededFaultRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1431,20 +1431,20 @@ const deserializeAws_queryPutCompositeAlarmCommandError = async (output, context
             });
     }
 };
-export const deserializeAws_queryPutDashboardCommand = async (output, context) => {
+export const de_PutDashboardCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryPutDashboardCommandError(output, context);
+        return de_PutDashboardCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryPutDashboardOutput(data.PutDashboardResult, context);
+    contents = de_PutDashboardOutput(data.PutDashboardResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryPutDashboardCommandError = async (output, context) => {
+const de_PutDashboardCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1453,10 +1453,10 @@ const deserializeAws_queryPutDashboardCommandError = async (output, context) =>
     switch (errorCode) {
         case "InternalServiceError":
         case "com.amazonaws.cloudwatch#InternalServiceFault":
-            throw await deserializeAws_queryInternalServiceFaultResponse(parsedOutput, context);
+            throw await de_InternalServiceFaultRes(parsedOutput, context);
         case "InvalidParameterInput":
         case "com.amazonaws.cloudwatch#DashboardInvalidInputError":
-            throw await deserializeAws_queryDashboardInvalidInputErrorResponse(parsedOutput, context);
+            throw await de_DashboardInvalidInputErrorRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1467,20 +1467,20 @@ const deserializeAws_queryPutDashboardCommandError = async (output, context) =>
             });
     }
 };
-export const deserializeAws_queryPutInsightRuleCommand = async (output, context) => {
+export const de_PutInsightRuleCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryPutInsightRuleCommandError(output, context);
+        return de_PutInsightRuleCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryPutInsightRuleOutput(data.PutInsightRuleResult, context);
+    contents = de_PutInsightRuleOutput(data.PutInsightRuleResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryPutInsightRuleCommandError = async (output, context) => {
+const de_PutInsightRuleCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1489,13 +1489,13 @@ const deserializeAws_queryPutInsightRuleCommandError = async (output, context) =
     switch (errorCode) {
         case "InvalidParameterValue":
         case "com.amazonaws.cloudwatch#InvalidParameterValueException":
-            throw await deserializeAws_queryInvalidParameterValueExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
         case "LimitExceededException":
         case "com.amazonaws.cloudwatch#LimitExceededException":
-            throw await deserializeAws_queryLimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         case "MissingParameter":
         case "com.amazonaws.cloudwatch#MissingRequiredParameterException":
-            throw await deserializeAws_queryMissingRequiredParameterExceptionResponse(parsedOutput, context);
+            throw await de_MissingRequiredParameterExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1506,20 +1506,20 @@ const deserializeAws_queryPutInsightRuleCommandError = async (output, context) =
             });
     }
 };
-export const deserializeAws_queryPutManagedInsightRulesCommand = async (output, context) => {
+export const de_PutManagedInsightRulesCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryPutManagedInsightRulesCommandError(output, context);
+        return de_PutManagedInsightRulesCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryPutManagedInsightRulesOutput(data.PutManagedInsightRulesResult, context);
+    contents = de_PutManagedInsightRulesOutput(data.PutManagedInsightRulesResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryPutManagedInsightRulesCommandError = async (output, context) => {
+const de_PutManagedInsightRulesCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1528,10 +1528,10 @@ const deserializeAws_queryPutManagedInsightRulesCommandError = async (output, co
     switch (errorCode) {
         case "InvalidParameterValue":
         case "com.amazonaws.cloudwatch#InvalidParameterValueException":
-            throw await deserializeAws_queryInvalidParameterValueExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
         case "MissingParameter":
         case "com.amazonaws.cloudwatch#MissingRequiredParameterException":
-            throw await deserializeAws_queryMissingRequiredParameterExceptionResponse(parsedOutput, context);
+            throw await de_MissingRequiredParameterExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1542,9 +1542,9 @@ const deserializeAws_queryPutManagedInsightRulesCommandError = async (output, co
             });
     }
 };
-export const deserializeAws_queryPutMetricAlarmCommand = async (output, context) => {
+export const de_PutMetricAlarmCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryPutMetricAlarmCommandError(output, context);
+        return de_PutMetricAlarmCommandError(output, context);
     }
     await collectBody(output.body, context);
     const response = {
@@ -1552,7 +1552,7 @@ export const deserializeAws_queryPutMetricAlarmCommand = async (output, context)
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryPutMetricAlarmCommandError = async (output, context) => {
+const de_PutMetricAlarmCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1561,7 +1561,7 @@ const deserializeAws_queryPutMetricAlarmCommandError = async (output, context) =
     switch (errorCode) {
         case "LimitExceeded":
         case "com.amazonaws.cloudwatch#LimitExceededFault":
-            throw await deserializeAws_queryLimitExceededFaultResponse(parsedOutput, context);
+            throw await de_LimitExceededFaultRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1572,9 +1572,9 @@ const deserializeAws_queryPutMetricAlarmCommandError = async (output, context) =
             });
     }
 };
-export const deserializeAws_queryPutMetricDataCommand = async (output, context) => {
+export const de_PutMetricDataCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryPutMetricDataCommandError(output, context);
+        return de_PutMetricDataCommandError(output, context);
     }
     await collectBody(output.body, context);
     const response = {
@@ -1582,7 +1582,7 @@ export const deserializeAws_queryPutMetricDataCommand = async (output, context)
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryPutMetricDataCommandError = async (output, context) => {
+const de_PutMetricDataCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1591,16 +1591,16 @@ const deserializeAws_queryPutMetricDataCommandError = async (output, context) =>
     switch (errorCode) {
         case "InternalServiceError":
         case "com.amazonaws.cloudwatch#InternalServiceFault":
-            throw await deserializeAws_queryInternalServiceFaultResponse(parsedOutput, context);
+            throw await de_InternalServiceFaultRes(parsedOutput, context);
         case "InvalidParameterCombination":
         case "com.amazonaws.cloudwatch#InvalidParameterCombinationException":
-            throw await deserializeAws_queryInvalidParameterCombinationExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
         case "InvalidParameterValue":
         case "com.amazonaws.cloudwatch#InvalidParameterValueException":
-            throw await deserializeAws_queryInvalidParameterValueExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
         case "MissingParameter":
         case "com.amazonaws.cloudwatch#MissingRequiredParameterException":
-            throw await deserializeAws_queryMissingRequiredParameterExceptionResponse(parsedOutput, context);
+            throw await de_MissingRequiredParameterExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1611,20 +1611,20 @@ const deserializeAws_queryPutMetricDataCommandError = async (output, context) =>
             });
     }
 };
-export const deserializeAws_queryPutMetricStreamCommand = async (output, context) => {
+export const de_PutMetricStreamCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryPutMetricStreamCommandError(output, context);
+        return de_PutMetricStreamCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryPutMetricStreamOutput(data.PutMetricStreamResult, context);
+    contents = de_PutMetricStreamOutput(data.PutMetricStreamResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryPutMetricStreamCommandError = async (output, context) => {
+const de_PutMetricStreamCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1633,19 +1633,19 @@ const deserializeAws_queryPutMetricStreamCommandError = async (output, context)
     switch (errorCode) {
         case "ConcurrentModificationException":
         case "com.amazonaws.cloudwatch#ConcurrentModificationException":
-            throw await deserializeAws_queryConcurrentModificationExceptionResponse(parsedOutput, context);
+            throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
         case "InternalServiceError":
         case "com.amazonaws.cloudwatch#InternalServiceFault":
-            throw await deserializeAws_queryInternalServiceFaultResponse(parsedOutput, context);
+            throw await de_InternalServiceFaultRes(parsedOutput, context);
         case "InvalidParameterCombination":
         case "com.amazonaws.cloudwatch#InvalidParameterCombinationException":
-            throw await deserializeAws_queryInvalidParameterCombinationExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
         case "InvalidParameterValue":
         case "com.amazonaws.cloudwatch#InvalidParameterValueException":
-            throw await deserializeAws_queryInvalidParameterValueExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
         case "MissingParameter":
         case "com.amazonaws.cloudwatch#MissingRequiredParameterException":
-            throw await deserializeAws_queryMissingRequiredParameterExceptionResponse(parsedOutput, context);
+            throw await de_MissingRequiredParameterExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1656,9 +1656,9 @@ const deserializeAws_queryPutMetricStreamCommandError = async (output, context)
             });
     }
 };
-export const deserializeAws_querySetAlarmStateCommand = async (output, context) => {
+export const de_SetAlarmStateCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_querySetAlarmStateCommandError(output, context);
+        return de_SetAlarmStateCommandError(output, context);
     }
     await collectBody(output.body, context);
     const response = {
@@ -1666,7 +1666,7 @@ export const deserializeAws_querySetAlarmStateCommand = async (output, context)
     };
     return Promise.resolve(response);
 };
-const deserializeAws_querySetAlarmStateCommandError = async (output, context) => {
+const de_SetAlarmStateCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1675,10 +1675,10 @@ const deserializeAws_querySetAlarmStateCommandError = async (output, context) =>
     switch (errorCode) {
         case "InvalidFormat":
         case "com.amazonaws.cloudwatch#InvalidFormatFault":
-            throw await deserializeAws_queryInvalidFormatFaultResponse(parsedOutput, context);
+            throw await de_InvalidFormatFaultRes(parsedOutput, context);
         case "ResourceNotFound":
         case "com.amazonaws.cloudwatch#ResourceNotFound":
-            throw await deserializeAws_queryResourceNotFoundResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1689,20 +1689,20 @@ const deserializeAws_querySetAlarmStateCommandError = async (output, context) =>
             });
     }
 };
-export const deserializeAws_queryStartMetricStreamsCommand = async (output, context) => {
+export const de_StartMetricStreamsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryStartMetricStreamsCommandError(output, context);
+        return de_StartMetricStreamsCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryStartMetricStreamsOutput(data.StartMetricStreamsResult, context);
+    contents = de_StartMetricStreamsOutput(data.StartMetricStreamsResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryStartMetricStreamsCommandError = async (output, context) => {
+const de_StartMetricStreamsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1711,13 +1711,13 @@ const deserializeAws_queryStartMetricStreamsCommandError = async (output, contex
     switch (errorCode) {
         case "InternalServiceError":
         case "com.amazonaws.cloudwatch#InternalServiceFault":
-            throw await deserializeAws_queryInternalServiceFaultResponse(parsedOutput, context);
+            throw await de_InternalServiceFaultRes(parsedOutput, context);
         case "InvalidParameterValue":
         case "com.amazonaws.cloudwatch#InvalidParameterValueException":
-            throw await deserializeAws_queryInvalidParameterValueExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
         case "MissingParameter":
         case "com.amazonaws.cloudwatch#MissingRequiredParameterException":
-            throw await deserializeAws_queryMissingRequiredParameterExceptionResponse(parsedOutput, context);
+            throw await de_MissingRequiredParameterExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1728,20 +1728,20 @@ const deserializeAws_queryStartMetricStreamsCommandError = async (output, contex
             });
     }
 };
-export const deserializeAws_queryStopMetricStreamsCommand = async (output, context) => {
+export const de_StopMetricStreamsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryStopMetricStreamsCommandError(output, context);
+        return de_StopMetricStreamsCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryStopMetricStreamsOutput(data.StopMetricStreamsResult, context);
+    contents = de_StopMetricStreamsOutput(data.StopMetricStreamsResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryStopMetricStreamsCommandError = async (output, context) => {
+const de_StopMetricStreamsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1750,13 +1750,13 @@ const deserializeAws_queryStopMetricStreamsCommandError = async (output, context
     switch (errorCode) {
         case "InternalServiceError":
         case "com.amazonaws.cloudwatch#InternalServiceFault":
-            throw await deserializeAws_queryInternalServiceFaultResponse(parsedOutput, context);
+            throw await de_InternalServiceFaultRes(parsedOutput, context);
         case "InvalidParameterValue":
         case "com.amazonaws.cloudwatch#InvalidParameterValueException":
-            throw await deserializeAws_queryInvalidParameterValueExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
         case "MissingParameter":
         case "com.amazonaws.cloudwatch#MissingRequiredParameterException":
-            throw await deserializeAws_queryMissingRequiredParameterExceptionResponse(parsedOutput, context);
+            throw await de_MissingRequiredParameterExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1767,20 +1767,20 @@ const deserializeAws_queryStopMetricStreamsCommandError = async (output, context
             });
     }
 };
-export const deserializeAws_queryTagResourceCommand = async (output, context) => {
+export const de_TagResourceCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryTagResourceCommandError(output, context);
+        return de_TagResourceCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryTagResourceOutput(data.TagResourceResult, context);
+    contents = de_TagResourceOutput(data.TagResourceResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryTagResourceCommandError = async (output, context) => {
+const de_TagResourceCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1789,16 +1789,16 @@ const deserializeAws_queryTagResourceCommandError = async (output, context) => {
     switch (errorCode) {
         case "ConcurrentModificationException":
         case "com.amazonaws.cloudwatch#ConcurrentModificationException":
-            throw await deserializeAws_queryConcurrentModificationExceptionResponse(parsedOutput, context);
+            throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
         case "InternalServiceError":
         case "com.amazonaws.cloudwatch#InternalServiceFault":
-            throw await deserializeAws_queryInternalServiceFaultResponse(parsedOutput, context);
+            throw await de_InternalServiceFaultRes(parsedOutput, context);
         case "InvalidParameterValue":
         case "com.amazonaws.cloudwatch#InvalidParameterValueException":
-            throw await deserializeAws_queryInvalidParameterValueExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.cloudwatch#ResourceNotFoundException":
-            throw await deserializeAws_queryResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1809,20 +1809,20 @@ const deserializeAws_queryTagResourceCommandError = async (output, context) => {
             });
     }
 };
-export const deserializeAws_queryUntagResourceCommand = async (output, context) => {
+export const de_UntagResourceCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryUntagResourceCommandError(output, context);
+        return de_UntagResourceCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryUntagResourceOutput(data.UntagResourceResult, context);
+    contents = de_UntagResourceOutput(data.UntagResourceResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryUntagResourceCommandError = async (output, context) => {
+const de_UntagResourceCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1831,16 +1831,16 @@ const deserializeAws_queryUntagResourceCommandError = async (output, context) =>
     switch (errorCode) {
         case "ConcurrentModificationException":
         case "com.amazonaws.cloudwatch#ConcurrentModificationException":
-            throw await deserializeAws_queryConcurrentModificationExceptionResponse(parsedOutput, context);
+            throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
         case "InternalServiceError":
         case "com.amazonaws.cloudwatch#InternalServiceFault":
-            throw await deserializeAws_queryInternalServiceFaultResponse(parsedOutput, context);
+            throw await de_InternalServiceFaultRes(parsedOutput, context);
         case "InvalidParameterValue":
         case "com.amazonaws.cloudwatch#InvalidParameterValueException":
-            throw await deserializeAws_queryInvalidParameterValueExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.cloudwatch#ResourceNotFoundException":
-            throw await deserializeAws_queryResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1851,124 +1851,124 @@ const deserializeAws_queryUntagResourceCommandError = async (output, context) =>
             });
     }
 };
-const deserializeAws_queryConcurrentModificationExceptionResponse = async (parsedOutput, context) => {
+const de_ConcurrentModificationExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_queryConcurrentModificationException(body.Error, context);
+    const deserialized = de_ConcurrentModificationException(body.Error, context);
     const exception = new ConcurrentModificationException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_queryDashboardInvalidInputErrorResponse = async (parsedOutput, context) => {
+const de_DashboardInvalidInputErrorRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_queryDashboardInvalidInputError(body.Error, context);
+    const deserialized = de_DashboardInvalidInputError(body.Error, context);
     const exception = new DashboardInvalidInputError({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_queryDashboardNotFoundErrorResponse = async (parsedOutput, context) => {
+const de_DashboardNotFoundErrorRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_queryDashboardNotFoundError(body.Error, context);
+    const deserialized = de_DashboardNotFoundError(body.Error, context);
     const exception = new DashboardNotFoundError({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_queryInternalServiceFaultResponse = async (parsedOutput, context) => {
+const de_InternalServiceFaultRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_queryInternalServiceFault(body.Error, context);
+    const deserialized = de_InternalServiceFault(body.Error, context);
     const exception = new InternalServiceFault({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_queryInvalidFormatFaultResponse = async (parsedOutput, context) => {
+const de_InvalidFormatFaultRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_queryInvalidFormatFault(body.Error, context);
+    const deserialized = de_InvalidFormatFault(body.Error, context);
     const exception = new InvalidFormatFault({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_queryInvalidNextTokenResponse = async (parsedOutput, context) => {
+const de_InvalidNextTokenRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_queryInvalidNextToken(body.Error, context);
+    const deserialized = de_InvalidNextToken(body.Error, context);
     const exception = new InvalidNextToken({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_queryInvalidParameterCombinationExceptionResponse = async (parsedOutput, context) => {
+const de_InvalidParameterCombinationExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_queryInvalidParameterCombinationException(body.Error, context);
+    const deserialized = de_InvalidParameterCombinationException(body.Error, context);
     const exception = new InvalidParameterCombinationException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_queryInvalidParameterValueExceptionResponse = async (parsedOutput, context) => {
+const de_InvalidParameterValueExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_queryInvalidParameterValueException(body.Error, context);
+    const deserialized = de_InvalidParameterValueException(body.Error, context);
     const exception = new InvalidParameterValueException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_queryLimitExceededExceptionResponse = async (parsedOutput, context) => {
+const de_LimitExceededExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_queryLimitExceededException(body.Error, context);
+    const deserialized = de_LimitExceededException(body.Error, context);
     const exception = new LimitExceededException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_queryLimitExceededFaultResponse = async (parsedOutput, context) => {
+const de_LimitExceededFaultRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_queryLimitExceededFault(body.Error, context);
+    const deserialized = de_LimitExceededFault(body.Error, context);
     const exception = new LimitExceededFault({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_queryMissingRequiredParameterExceptionResponse = async (parsedOutput, context) => {
+const de_MissingRequiredParameterExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_queryMissingRequiredParameterException(body.Error, context);
+    const deserialized = de_MissingRequiredParameterException(body.Error, context);
     const exception = new MissingRequiredParameterException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_queryResourceNotFoundResponse = async (parsedOutput, context) => {
+const de_ResourceNotFoundRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_queryResourceNotFound(body.Error, context);
+    const deserialized = de_ResourceNotFound(body.Error, context);
     const exception = new ResourceNotFound({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_queryResourceNotFoundExceptionResponse = async (parsedOutput, context) => {
+const de_ResourceNotFoundExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_queryResourceNotFoundException(body.Error, context);
+    const deserialized = de_ResourceNotFoundException(body.Error, context);
     const exception = new ResourceNotFoundException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const serializeAws_queryAlarmNames = (input, context) => {
+const se_AlarmNames = (input, context) => {
     const entries = {};
     let counter = 1;
     for (const entry of input) {
@@ -1980,7 +1980,7 @@ const serializeAws_queryAlarmNames = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryAlarmTypes = (input, context) => {
+const se_AlarmTypes = (input, context) => {
     const entries = {};
     let counter = 1;
     for (const entry of input) {
@@ -1992,10 +1992,10 @@ const serializeAws_queryAlarmTypes = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryAnomalyDetectorConfiguration = (input, context) => {
+const se_AnomalyDetectorConfiguration = (input, context) => {
     const entries = {};
     if (input.ExcludedTimeRanges != null) {
-        const memberEntries = serializeAws_queryAnomalyDetectorExcludedTimeRanges(input.ExcludedTimeRanges, context);
+        const memberEntries = se_AnomalyDetectorExcludedTimeRanges(input.ExcludedTimeRanges, context);
         if (input.ExcludedTimeRanges?.length === 0) {
             entries.ExcludedTimeRanges = [];
         }
@@ -2009,14 +2009,14 @@ const serializeAws_queryAnomalyDetectorConfiguration = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryAnomalyDetectorExcludedTimeRanges = (input, context) => {
+const se_AnomalyDetectorExcludedTimeRanges = (input, context) => {
     const entries = {};
     let counter = 1;
     for (const entry of input) {
         if (entry === null) {
             continue;
         }
-        const memberEntries = serializeAws_queryRange(entry, context);
+        const memberEntries = se_Range(entry, context);
         Object.entries(memberEntries).forEach(([key, value]) => {
             entries[`member.${counter}.${key}`] = value;
         });
@@ -2024,7 +2024,7 @@ const serializeAws_queryAnomalyDetectorExcludedTimeRanges = (input, context) =>
     }
     return entries;
 };
-const serializeAws_queryAnomalyDetectorTypes = (input, context) => {
+const se_AnomalyDetectorTypes = (input, context) => {
     const entries = {};
     let counter = 1;
     for (const entry of input) {
@@ -2036,7 +2036,7 @@ const serializeAws_queryAnomalyDetectorTypes = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryCounts = (input, context) => {
+const se_Counts = (input, context) => {
     const entries = {};
     let counter = 1;
     for (const entry of input) {
@@ -2048,7 +2048,7 @@ const serializeAws_queryCounts = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryDashboardNames = (input, context) => {
+const se_DashboardNames = (input, context) => {
     const entries = {};
     let counter = 1;
     for (const entry of input) {
@@ -2060,10 +2060,10 @@ const serializeAws_queryDashboardNames = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryDeleteAlarmsInput = (input, context) => {
+const se_DeleteAlarmsInput = (input, context) => {
     const entries = {};
     if (input.AlarmNames != null) {
-        const memberEntries = serializeAws_queryAlarmNames(input.AlarmNames, context);
+        const memberEntries = se_AlarmNames(input.AlarmNames, context);
         if (input.AlarmNames?.length === 0) {
             entries.AlarmNames = [];
         }
@@ -2074,7 +2074,7 @@ const serializeAws_queryDeleteAlarmsInput = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryDeleteAnomalyDetectorInput = (input, context) => {
+const se_DeleteAnomalyDetectorInput = (input, context) => {
     const entries = {};
     if (input.Namespace != null) {
         entries["Namespace"] = input.Namespace;
@@ -2083,7 +2083,7 @@ const serializeAws_queryDeleteAnomalyDetectorInput = (input, context) => {
         entries["MetricName"] = input.MetricName;
     }
     if (input.Dimensions != null) {
-        const memberEntries = serializeAws_queryDimensions(input.Dimensions, context);
+        const memberEntries = se_Dimensions(input.Dimensions, context);
         if (input.Dimensions?.length === 0) {
             entries.Dimensions = [];
         }
@@ -2096,14 +2096,14 @@ const serializeAws_queryDeleteAnomalyDetectorInput = (input, context) => {
         entries["Stat"] = input.Stat;
     }
     if (input.SingleMetricAnomalyDetector != null) {
-        const memberEntries = serializeAws_querySingleMetricAnomalyDetector(input.SingleMetricAnomalyDetector, context);
+        const memberEntries = se_SingleMetricAnomalyDetector(input.SingleMetricAnomalyDetector, context);
         Object.entries(memberEntries).forEach(([key, value]) => {
             const loc = `SingleMetricAnomalyDetector.${key}`;
             entries[loc] = value;
         });
     }
     if (input.MetricMathAnomalyDetector != null) {
-        const memberEntries = serializeAws_queryMetricMathAnomalyDetector(input.MetricMathAnomalyDetector, context);
+        const memberEntries = se_MetricMathAnomalyDetector(input.MetricMathAnomalyDetector, context);
         Object.entries(memberEntries).forEach(([key, value]) => {
             const loc = `MetricMathAnomalyDetector.${key}`;
             entries[loc] = value;
@@ -2111,10 +2111,10 @@ const serializeAws_queryDeleteAnomalyDetectorInput = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryDeleteDashboardsInput = (input, context) => {
+const se_DeleteDashboardsInput = (input, context) => {
     const entries = {};
     if (input.DashboardNames != null) {
-        const memberEntries = serializeAws_queryDashboardNames(input.DashboardNames, context);
+        const memberEntries = se_DashboardNames(input.DashboardNames, context);
         if (input.DashboardNames?.length === 0) {
             entries.DashboardNames = [];
         }
@@ -2125,10 +2125,10 @@ const serializeAws_queryDeleteDashboardsInput = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryDeleteInsightRulesInput = (input, context) => {
+const se_DeleteInsightRulesInput = (input, context) => {
     const entries = {};
     if (input.RuleNames != null) {
-        const memberEntries = serializeAws_queryInsightRuleNames(input.RuleNames, context);
+        const memberEntries = se_InsightRuleNames(input.RuleNames, context);
         if (input.RuleNames?.length === 0) {
             entries.RuleNames = [];
         }
@@ -2139,20 +2139,20 @@ const serializeAws_queryDeleteInsightRulesInput = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryDeleteMetricStreamInput = (input, context) => {
+const se_DeleteMetricStreamInput = (input, context) => {
     const entries = {};
     if (input.Name != null) {
         entries["Name"] = input.Name;
     }
     return entries;
 };
-const serializeAws_queryDescribeAlarmHistoryInput = (input, context) => {
+const se_DescribeAlarmHistoryInput = (input, context) => {
     const entries = {};
     if (input.AlarmName != null) {
         entries["AlarmName"] = input.AlarmName;
     }
     if (input.AlarmTypes != null) {
-        const memberEntries = serializeAws_queryAlarmTypes(input.AlarmTypes, context);
+        const memberEntries = se_AlarmTypes(input.AlarmTypes, context);
         if (input.AlarmTypes?.length === 0) {
             entries.AlarmTypes = [];
         }
@@ -2181,7 +2181,7 @@ const serializeAws_queryDescribeAlarmHistoryInput = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryDescribeAlarmsForMetricInput = (input, context) => {
+const se_DescribeAlarmsForMetricInput = (input, context) => {
     const entries = {};
     if (input.MetricName != null) {
         entries["MetricName"] = input.MetricName;
@@ -2196,7 +2196,7 @@ const serializeAws_queryDescribeAlarmsForMetricInput = (input, context) => {
         entries["ExtendedStatistic"] = input.ExtendedStatistic;
     }
     if (input.Dimensions != null) {
-        const memberEntries = serializeAws_queryDimensions(input.Dimensions, context);
+        const memberEntries = se_Dimensions(input.Dimensions, context);
         if (input.Dimensions?.length === 0) {
             entries.Dimensions = [];
         }
@@ -2213,10 +2213,10 @@ const serializeAws_queryDescribeAlarmsForMetricInput = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryDescribeAlarmsInput = (input, context) => {
+const se_DescribeAlarmsInput = (input, context) => {
     const entries = {};
     if (input.AlarmNames != null) {
-        const memberEntries = serializeAws_queryAlarmNames(input.AlarmNames, context);
+        const memberEntries = se_AlarmNames(input.AlarmNames, context);
         if (input.AlarmNames?.length === 0) {
             entries.AlarmNames = [];
         }
@@ -2229,7 +2229,7 @@ const serializeAws_queryDescribeAlarmsInput = (input, context) => {
         entries["AlarmNamePrefix"] = input.AlarmNamePrefix;
     }
     if (input.AlarmTypes != null) {
-        const memberEntries = serializeAws_queryAlarmTypes(input.AlarmTypes, context);
+        const memberEntries = se_AlarmTypes(input.AlarmTypes, context);
         if (input.AlarmTypes?.length === 0) {
             entries.AlarmTypes = [];
         }
@@ -2258,7 +2258,7 @@ const serializeAws_queryDescribeAlarmsInput = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryDescribeAnomalyDetectorsInput = (input, context) => {
+const se_DescribeAnomalyDetectorsInput = (input, context) => {
     const entries = {};
     if (input.NextToken != null) {
         entries["NextToken"] = input.NextToken;
@@ -2273,7 +2273,7 @@ const serializeAws_queryDescribeAnomalyDetectorsInput = (input, context) => {
         entries["MetricName"] = input.MetricName;
     }
     if (input.Dimensions != null) {
-        const memberEntries = serializeAws_queryDimensions(input.Dimensions, context);
+        const memberEntries = se_Dimensions(input.Dimensions, context);
         if (input.Dimensions?.length === 0) {
             entries.Dimensions = [];
         }
@@ -2283,7 +2283,7 @@ const serializeAws_queryDescribeAnomalyDetectorsInput = (input, context) => {
         });
     }
     if (input.AnomalyDetectorTypes != null) {
-        const memberEntries = serializeAws_queryAnomalyDetectorTypes(input.AnomalyDetectorTypes, context);
+        const memberEntries = se_AnomalyDetectorTypes(input.AnomalyDetectorTypes, context);
         if (input.AnomalyDetectorTypes?.length === 0) {
             entries.AnomalyDetectorTypes = [];
         }
@@ -2294,7 +2294,7 @@ const serializeAws_queryDescribeAnomalyDetectorsInput = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryDescribeInsightRulesInput = (input, context) => {
+const se_DescribeInsightRulesInput = (input, context) => {
     const entries = {};
     if (input.NextToken != null) {
         entries["NextToken"] = input.NextToken;
@@ -2304,7 +2304,7 @@ const serializeAws_queryDescribeInsightRulesInput = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryDimension = (input, context) => {
+const se_Dimension = (input, context) => {
     const entries = {};
     if (input.Name != null) {
         entries["Name"] = input.Name;
@@ -2314,7 +2314,7 @@ const serializeAws_queryDimension = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryDimensionFilter = (input, context) => {
+const se_DimensionFilter = (input, context) => {
     const entries = {};
     if (input.Name != null) {
         entries["Name"] = input.Name;
@@ -2324,14 +2324,14 @@ const serializeAws_queryDimensionFilter = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryDimensionFilters = (input, context) => {
+const se_DimensionFilters = (input, context) => {
     const entries = {};
     let counter = 1;
     for (const entry of input) {
         if (entry === null) {
             continue;
         }
-        const memberEntries = serializeAws_queryDimensionFilter(entry, context);
+        const memberEntries = se_DimensionFilter(entry, context);
         Object.entries(memberEntries).forEach(([key, value]) => {
             entries[`member.${counter}.${key}`] = value;
         });
@@ -2339,14 +2339,14 @@ const serializeAws_queryDimensionFilters = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryDimensions = (input, context) => {
+const se_Dimensions = (input, context) => {
     const entries = {};
     let counter = 1;
     for (const entry of input) {
         if (entry === null) {
             continue;
         }
-        const memberEntries = serializeAws_queryDimension(entry, context);
+        const memberEntries = se_Dimension(entry, context);
         Object.entries(memberEntries).forEach(([key, value]) => {
             entries[`member.${counter}.${key}`] = value;
         });
@@ -2354,10 +2354,10 @@ const serializeAws_queryDimensions = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryDisableAlarmActionsInput = (input, context) => {
+const se_DisableAlarmActionsInput = (input, context) => {
     const entries = {};
     if (input.AlarmNames != null) {
-        const memberEntries = serializeAws_queryAlarmNames(input.AlarmNames, context);
+        const memberEntries = se_AlarmNames(input.AlarmNames, context);
         if (input.AlarmNames?.length === 0) {
             entries.AlarmNames = [];
         }
@@ -2368,10 +2368,10 @@ const serializeAws_queryDisableAlarmActionsInput = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryDisableInsightRulesInput = (input, context) => {
+const se_DisableInsightRulesInput = (input, context) => {
     const entries = {};
     if (input.RuleNames != null) {
-        const memberEntries = serializeAws_queryInsightRuleNames(input.RuleNames, context);
+        const memberEntries = se_InsightRuleNames(input.RuleNames, context);
         if (input.RuleNames?.length === 0) {
             entries.RuleNames = [];
         }
@@ -2382,10 +2382,10 @@ const serializeAws_queryDisableInsightRulesInput = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryEnableAlarmActionsInput = (input, context) => {
+const se_EnableAlarmActionsInput = (input, context) => {
     const entries = {};
     if (input.AlarmNames != null) {
-        const memberEntries = serializeAws_queryAlarmNames(input.AlarmNames, context);
+        const memberEntries = se_AlarmNames(input.AlarmNames, context);
         if (input.AlarmNames?.length === 0) {
             entries.AlarmNames = [];
         }
@@ -2396,10 +2396,10 @@ const serializeAws_queryEnableAlarmActionsInput = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryEnableInsightRulesInput = (input, context) => {
+const se_EnableInsightRulesInput = (input, context) => {
     const entries = {};
     if (input.RuleNames != null) {
-        const memberEntries = serializeAws_queryInsightRuleNames(input.RuleNames, context);
+        const memberEntries = se_InsightRuleNames(input.RuleNames, context);
         if (input.RuleNames?.length === 0) {
             entries.RuleNames = [];
         }
@@ -2410,7 +2410,7 @@ const serializeAws_queryEnableInsightRulesInput = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryExtendedStatistics = (input, context) => {
+const se_ExtendedStatistics = (input, context) => {
     const entries = {};
     let counter = 1;
     for (const entry of input) {
@@ -2422,14 +2422,14 @@ const serializeAws_queryExtendedStatistics = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryGetDashboardInput = (input, context) => {
+const se_GetDashboardInput = (input, context) => {
     const entries = {};
     if (input.DashboardName != null) {
         entries["DashboardName"] = input.DashboardName;
     }
     return entries;
 };
-const serializeAws_queryGetInsightRuleReportInput = (input, context) => {
+const se_GetInsightRuleReportInput = (input, context) => {
     const entries = {};
     if (input.RuleName != null) {
         entries["RuleName"] = input.RuleName;
@@ -2447,7 +2447,7 @@ const serializeAws_queryGetInsightRuleReportInput = (input, context) => {
         entries["MaxContributorCount"] = input.MaxContributorCount;
     }
     if (input.Metrics != null) {
-        const memberEntries = serializeAws_queryInsightRuleMetricList(input.Metrics, context);
+        const memberEntries = se_InsightRuleMetricList(input.Metrics, context);
         if (input.Metrics?.length === 0) {
             entries.Metrics = [];
         }
@@ -2461,10 +2461,10 @@ const serializeAws_queryGetInsightRuleReportInput = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryGetMetricDataInput = (input, context) => {
+const se_GetMetricDataInput = (input, context) => {
     const entries = {};
     if (input.MetricDataQueries != null) {
-        const memberEntries = serializeAws_queryMetricDataQueries(input.MetricDataQueries, context);
+        const memberEntries = se_MetricDataQueries(input.MetricDataQueries, context);
         if (input.MetricDataQueries?.length === 0) {
             entries.MetricDataQueries = [];
         }
@@ -2489,7 +2489,7 @@ const serializeAws_queryGetMetricDataInput = (input, context) => {
         entries["MaxDatapoints"] = input.MaxDatapoints;
     }
     if (input.LabelOptions != null) {
-        const memberEntries = serializeAws_queryLabelOptions(input.LabelOptions, context);
+        const memberEntries = se_LabelOptions(input.LabelOptions, context);
         Object.entries(memberEntries).forEach(([key, value]) => {
             const loc = `LabelOptions.${key}`;
             entries[loc] = value;
@@ -2497,7 +2497,7 @@ const serializeAws_queryGetMetricDataInput = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryGetMetricStatisticsInput = (input, context) => {
+const se_GetMetricStatisticsInput = (input, context) => {
     const entries = {};
     if (input.Namespace != null) {
         entries["Namespace"] = input.Namespace;
@@ -2506,7 +2506,7 @@ const serializeAws_queryGetMetricStatisticsInput = (input, context) => {
         entries["MetricName"] = input.MetricName;
     }
     if (input.Dimensions != null) {
-        const memberEntries = serializeAws_queryDimensions(input.Dimensions, context);
+        const memberEntries = se_Dimensions(input.Dimensions, context);
         if (input.Dimensions?.length === 0) {
             entries.Dimensions = [];
         }
@@ -2525,7 +2525,7 @@ const serializeAws_queryGetMetricStatisticsInput = (input, context) => {
         entries["Period"] = input.Period;
     }
     if (input.Statistics != null) {
-        const memberEntries = serializeAws_queryStatistics(input.Statistics, context);
+        const memberEntries = se_Statistics(input.Statistics, context);
         if (input.Statistics?.length === 0) {
             entries.Statistics = [];
         }
@@ -2535,7 +2535,7 @@ const serializeAws_queryGetMetricStatisticsInput = (input, context) => {
         });
     }
     if (input.ExtendedStatistics != null) {
-        const memberEntries = serializeAws_queryExtendedStatistics(input.ExtendedStatistics, context);
+        const memberEntries = se_ExtendedStatistics(input.ExtendedStatistics, context);
         if (input.ExtendedStatistics?.length === 0) {
             entries.ExtendedStatistics = [];
         }
@@ -2549,14 +2549,14 @@ const serializeAws_queryGetMetricStatisticsInput = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryGetMetricStreamInput = (input, context) => {
+const se_GetMetricStreamInput = (input, context) => {
     const entries = {};
     if (input.Name != null) {
         entries["Name"] = input.Name;
     }
     return entries;
 };
-const serializeAws_queryGetMetricWidgetImageInput = (input, context) => {
+const se_GetMetricWidgetImageInput = (input, context) => {
     const entries = {};
     if (input.MetricWidget != null) {
         entries["MetricWidget"] = input.MetricWidget;
@@ -2566,7 +2566,7 @@ const serializeAws_queryGetMetricWidgetImageInput = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryInsightRuleMetricList = (input, context) => {
+const se_InsightRuleMetricList = (input, context) => {
     const entries = {};
     let counter = 1;
     for (const entry of input) {
@@ -2578,7 +2578,7 @@ const serializeAws_queryInsightRuleMetricList = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryInsightRuleNames = (input, context) => {
+const se_InsightRuleNames = (input, context) => {
     const entries = {};
     let counter = 1;
     for (const entry of input) {
@@ -2590,14 +2590,14 @@ const serializeAws_queryInsightRuleNames = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryLabelOptions = (input, context) => {
+const se_LabelOptions = (input, context) => {
     const entries = {};
     if (input.Timezone != null) {
         entries["Timezone"] = input.Timezone;
     }
     return entries;
 };
-const serializeAws_queryListDashboardsInput = (input, context) => {
+const se_ListDashboardsInput = (input, context) => {
     const entries = {};
     if (input.DashboardNamePrefix != null) {
         entries["DashboardNamePrefix"] = input.DashboardNamePrefix;
@@ -2607,7 +2607,7 @@ const serializeAws_queryListDashboardsInput = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryListManagedInsightRulesInput = (input, context) => {
+const se_ListManagedInsightRulesInput = (input, context) => {
     const entries = {};
     if (input.ResourceARN != null) {
         entries["ResourceARN"] = input.ResourceARN;
@@ -2620,7 +2620,7 @@ const serializeAws_queryListManagedInsightRulesInput = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryListMetricsInput = (input, context) => {
+const se_ListMetricsInput = (input, context) => {
     const entries = {};
     if (input.Namespace != null) {
         entries["Namespace"] = input.Namespace;
@@ -2629,7 +2629,7 @@ const serializeAws_queryListMetricsInput = (input, context) => {
         entries["MetricName"] = input.MetricName;
     }
     if (input.Dimensions != null) {
-        const memberEntries = serializeAws_queryDimensionFilters(input.Dimensions, context);
+        const memberEntries = se_DimensionFilters(input.Dimensions, context);
         if (input.Dimensions?.length === 0) {
             entries.Dimensions = [];
         }
@@ -2652,7 +2652,7 @@ const serializeAws_queryListMetricsInput = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryListMetricStreamsInput = (input, context) => {
+const se_ListMetricStreamsInput = (input, context) => {
     const entries = {};
     if (input.NextToken != null) {
         entries["NextToken"] = input.NextToken;
@@ -2662,14 +2662,14 @@ const serializeAws_queryListMetricStreamsInput = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryListTagsForResourceInput = (input, context) => {
+const se_ListTagsForResourceInput = (input, context) => {
     const entries = {};
     if (input.ResourceARN != null) {
         entries["ResourceARN"] = input.ResourceARN;
     }
     return entries;
 };
-const serializeAws_queryManagedRule = (input, context) => {
+const se_ManagedRule = (input, context) => {
     const entries = {};
     if (input.TemplateName != null) {
         entries["TemplateName"] = input.TemplateName;
@@ -2678,7 +2678,7 @@ const serializeAws_queryManagedRule = (input, context) => {
         entries["ResourceARN"] = input.ResourceARN;
     }
     if (input.Tags != null) {
-        const memberEntries = serializeAws_queryTagList(input.Tags, context);
+        const memberEntries = se_TagList(input.Tags, context);
         if (input.Tags?.length === 0) {
             entries.Tags = [];
         }
@@ -2689,14 +2689,14 @@ const serializeAws_queryManagedRule = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryManagedRules = (input, context) => {
+const se_ManagedRules = (input, context) => {
     const entries = {};
     let counter = 1;
     for (const entry of input) {
         if (entry === null) {
             continue;
         }
-        const memberEntries = serializeAws_queryManagedRule(entry, context);
+        const memberEntries = se_ManagedRule(entry, context);
         Object.entries(memberEntries).forEach(([key, value]) => {
             entries[`member.${counter}.${key}`] = value;
         });
@@ -2704,7 +2704,7 @@ const serializeAws_queryManagedRules = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryMetric = (input, context) => {
+const se_Metric = (input, context) => {
     const entries = {};
     if (input.Namespace != null) {
         entries["Namespace"] = input.Namespace;
@@ -2713,7 +2713,7 @@ const serializeAws_queryMetric = (input, context) => {
         entries["MetricName"] = input.MetricName;
     }
     if (input.Dimensions != null) {
-        const memberEntries = serializeAws_queryDimensions(input.Dimensions, context);
+        const memberEntries = se_Dimensions(input.Dimensions, context);
         if (input.Dimensions?.length === 0) {
             entries.Dimensions = [];
         }
@@ -2724,14 +2724,14 @@ const serializeAws_queryMetric = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryMetricData = (input, context) => {
+const se_MetricData = (input, context) => {
     const entries = {};
     let counter = 1;
     for (const entry of input) {
         if (entry === null) {
             continue;
         }
-        const memberEntries = serializeAws_queryMetricDatum(entry, context);
+        const memberEntries = se_MetricDatum(entry, context);
         Object.entries(memberEntries).forEach(([key, value]) => {
             entries[`member.${counter}.${key}`] = value;
         });
@@ -2739,14 +2739,14 @@ const serializeAws_queryMetricData = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryMetricDataQueries = (input, context) => {
+const se_MetricDataQueries = (input, context) => {
     const entries = {};
     let counter = 1;
     for (const entry of input) {
         if (entry === null) {
             continue;
         }
-        const memberEntries = serializeAws_queryMetricDataQuery(entry, context);
+        const memberEntries = se_MetricDataQuery(entry, context);
         Object.entries(memberEntries).forEach(([key, value]) => {
             entries[`member.${counter}.${key}`] = value;
         });
@@ -2754,13 +2754,13 @@ const serializeAws_queryMetricDataQueries = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryMetricDataQuery = (input, context) => {
+const se_MetricDataQuery = (input, context) => {
     const entries = {};
     if (input.Id != null) {
         entries["Id"] = input.Id;
     }
     if (input.MetricStat != null) {
-        const memberEntries = serializeAws_queryMetricStat(input.MetricStat, context);
+        const memberEntries = se_MetricStat(input.MetricStat, context);
         Object.entries(memberEntries).forEach(([key, value]) => {
             const loc = `MetricStat.${key}`;
             entries[loc] = value;
@@ -2783,13 +2783,13 @@ const serializeAws_queryMetricDataQuery = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryMetricDatum = (input, context) => {
+const se_MetricDatum = (input, context) => {
     const entries = {};
     if (input.MetricName != null) {
         entries["MetricName"] = input.MetricName;
     }
     if (input.Dimensions != null) {
-        const memberEntries = serializeAws_queryDimensions(input.Dimensions, context);
+        const memberEntries = se_Dimensions(input.Dimensions, context);
         if (input.Dimensions?.length === 0) {
             entries.Dimensions = [];
         }
@@ -2805,14 +2805,14 @@ const serializeAws_queryMetricDatum = (input, context) => {
         entries["Value"] = __serializeFloat(input.Value);
     }
     if (input.StatisticValues != null) {
-        const memberEntries = serializeAws_queryStatisticSet(input.StatisticValues, context);
+        const memberEntries = se_StatisticSet(input.StatisticValues, context);
         Object.entries(memberEntries).forEach(([key, value]) => {
             const loc = `StatisticValues.${key}`;
             entries[loc] = value;
         });
     }
     if (input.Values != null) {
-        const memberEntries = serializeAws_queryValues(input.Values, context);
+        const memberEntries = se_Values(input.Values, context);
         if (input.Values?.length === 0) {
             entries.Values = [];
         }
@@ -2822,7 +2822,7 @@ const serializeAws_queryMetricDatum = (input, context) => {
         });
     }
     if (input.Counts != null) {
-        const memberEntries = serializeAws_queryCounts(input.Counts, context);
+        const memberEntries = se_Counts(input.Counts, context);
         if (input.Counts?.length === 0) {
             entries.Counts = [];
         }
@@ -2839,10 +2839,10 @@ const serializeAws_queryMetricDatum = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryMetricMathAnomalyDetector = (input, context) => {
+const se_MetricMathAnomalyDetector = (input, context) => {
     const entries = {};
     if (input.MetricDataQueries != null) {
-        const memberEntries = serializeAws_queryMetricDataQueries(input.MetricDataQueries, context);
+        const memberEntries = se_MetricDataQueries(input.MetricDataQueries, context);
         if (input.MetricDataQueries?.length === 0) {
             entries.MetricDataQueries = [];
         }
@@ -2853,10 +2853,10 @@ const serializeAws_queryMetricMathAnomalyDetector = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryMetricStat = (input, context) => {
+const se_MetricStat = (input, context) => {
     const entries = {};
     if (input.Metric != null) {
-        const memberEntries = serializeAws_queryMetric(input.Metric, context);
+        const memberEntries = se_Metric(input.Metric, context);
         Object.entries(memberEntries).forEach(([key, value]) => {
             const loc = `Metric.${key}`;
             entries[loc] = value;
@@ -2873,21 +2873,21 @@ const serializeAws_queryMetricStat = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryMetricStreamFilter = (input, context) => {
+const se_MetricStreamFilter = (input, context) => {
     const entries = {};
     if (input.Namespace != null) {
         entries["Namespace"] = input.Namespace;
     }
     return entries;
 };
-const serializeAws_queryMetricStreamFilters = (input, context) => {
+const se_MetricStreamFilters = (input, context) => {
     const entries = {};
     let counter = 1;
     for (const entry of input) {
         if (entry === null) {
             continue;
         }
-        const memberEntries = serializeAws_queryMetricStreamFilter(entry, context);
+        const memberEntries = se_MetricStreamFilter(entry, context);
         Object.entries(memberEntries).forEach(([key, value]) => {
             entries[`member.${counter}.${key}`] = value;
         });
@@ -2895,7 +2895,7 @@ const serializeAws_queryMetricStreamFilters = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryMetricStreamNames = (input, context) => {
+const se_MetricStreamNames = (input, context) => {
     const entries = {};
     let counter = 1;
     for (const entry of input) {
@@ -2907,7 +2907,7 @@ const serializeAws_queryMetricStreamNames = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryMetricStreamStatisticsAdditionalStatistics = (input, context) => {
+const se_MetricStreamStatisticsAdditionalStatistics = (input, context) => {
     const entries = {};
     let counter = 1;
     for (const entry of input) {
@@ -2919,10 +2919,10 @@ const serializeAws_queryMetricStreamStatisticsAdditionalStatistics = (input, con
     }
     return entries;
 };
-const serializeAws_queryMetricStreamStatisticsConfiguration = (input, context) => {
+const se_MetricStreamStatisticsConfiguration = (input, context) => {
     const entries = {};
     if (input.IncludeMetrics != null) {
-        const memberEntries = serializeAws_queryMetricStreamStatisticsIncludeMetrics(input.IncludeMetrics, context);
+        const memberEntries = se_MetricStreamStatisticsIncludeMetrics(input.IncludeMetrics, context);
         if (input.IncludeMetrics?.length === 0) {
             entries.IncludeMetrics = [];
         }
@@ -2932,7 +2932,7 @@ const serializeAws_queryMetricStreamStatisticsConfiguration = (input, context) =
         });
     }
     if (input.AdditionalStatistics != null) {
-        const memberEntries = serializeAws_queryMetricStreamStatisticsAdditionalStatistics(input.AdditionalStatistics, context);
+        const memberEntries = se_MetricStreamStatisticsAdditionalStatistics(input.AdditionalStatistics, context);
         if (input.AdditionalStatistics?.length === 0) {
             entries.AdditionalStatistics = [];
         }
@@ -2943,14 +2943,14 @@ const serializeAws_queryMetricStreamStatisticsConfiguration = (input, context) =
     }
     return entries;
 };
-const serializeAws_queryMetricStreamStatisticsConfigurations = (input, context) => {
+const se_MetricStreamStatisticsConfigurations = (input, context) => {
     const entries = {};
     let counter = 1;
     for (const entry of input) {
         if (entry === null) {
             continue;
         }
-        const memberEntries = serializeAws_queryMetricStreamStatisticsConfiguration(entry, context);
+        const memberEntries = se_MetricStreamStatisticsConfiguration(entry, context);
         Object.entries(memberEntries).forEach(([key, value]) => {
             entries[`member.${counter}.${key}`] = value;
         });
@@ -2958,14 +2958,14 @@ const serializeAws_queryMetricStreamStatisticsConfigurations = (input, context)
     }
     return entries;
 };
-const serializeAws_queryMetricStreamStatisticsIncludeMetrics = (input, context) => {
+const se_MetricStreamStatisticsIncludeMetrics = (input, context) => {
     const entries = {};
     let counter = 1;
     for (const entry of input) {
         if (entry === null) {
             continue;
         }
-        const memberEntries = serializeAws_queryMetricStreamStatisticsMetric(entry, context);
+        const memberEntries = se_MetricStreamStatisticsMetric(entry, context);
         Object.entries(memberEntries).forEach(([key, value]) => {
             entries[`member.${counter}.${key}`] = value;
         });
@@ -2973,7 +2973,7 @@ const serializeAws_queryMetricStreamStatisticsIncludeMetrics = (input, context)
     }
     return entries;
 };
-const serializeAws_queryMetricStreamStatisticsMetric = (input, context) => {
+const se_MetricStreamStatisticsMetric = (input, context) => {
     const entries = {};
     if (input.Namespace != null) {
         entries["Namespace"] = input.Namespace;
@@ -2983,7 +2983,7 @@ const serializeAws_queryMetricStreamStatisticsMetric = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryPutAnomalyDetectorInput = (input, context) => {
+const se_PutAnomalyDetectorInput = (input, context) => {
     const entries = {};
     if (input.Namespace != null) {
         entries["Namespace"] = input.Namespace;
@@ -2992,7 +2992,7 @@ const serializeAws_queryPutAnomalyDetectorInput = (input, context) => {
         entries["MetricName"] = input.MetricName;
     }
     if (input.Dimensions != null) {
-        const memberEntries = serializeAws_queryDimensions(input.Dimensions, context);
+        const memberEntries = se_Dimensions(input.Dimensions, context);
         if (input.Dimensions?.length === 0) {
             entries.Dimensions = [];
         }
@@ -3005,21 +3005,21 @@ const serializeAws_queryPutAnomalyDetectorInput = (input, context) => {
         entries["Stat"] = input.Stat;
     }
     if (input.Configuration != null) {
-        const memberEntries = serializeAws_queryAnomalyDetectorConfiguration(input.Configuration, context);
+        const memberEntries = se_AnomalyDetectorConfiguration(input.Configuration, context);
         Object.entries(memberEntries).forEach(([key, value]) => {
             const loc = `Configuration.${key}`;
             entries[loc] = value;
         });
     }
     if (input.SingleMetricAnomalyDetector != null) {
-        const memberEntries = serializeAws_querySingleMetricAnomalyDetector(input.SingleMetricAnomalyDetector, context);
+        const memberEntries = se_SingleMetricAnomalyDetector(input.SingleMetricAnomalyDetector, context);
         Object.entries(memberEntries).forEach(([key, value]) => {
             const loc = `SingleMetricAnomalyDetector.${key}`;
             entries[loc] = value;
         });
     }
     if (input.MetricMathAnomalyDetector != null) {
-        const memberEntries = serializeAws_queryMetricMathAnomalyDetector(input.MetricMathAnomalyDetector, context);
+        const memberEntries = se_MetricMathAnomalyDetector(input.MetricMathAnomalyDetector, context);
         Object.entries(memberEntries).forEach(([key, value]) => {
             const loc = `MetricMathAnomalyDetector.${key}`;
             entries[loc] = value;
@@ -3027,13 +3027,13 @@ const serializeAws_queryPutAnomalyDetectorInput = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryPutCompositeAlarmInput = (input, context) => {
+const se_PutCompositeAlarmInput = (input, context) => {
     const entries = {};
     if (input.ActionsEnabled != null) {
         entries["ActionsEnabled"] = input.ActionsEnabled;
     }
     if (input.AlarmActions != null) {
-        const memberEntries = serializeAws_queryResourceList(input.AlarmActions, context);
+        const memberEntries = se_ResourceList(input.AlarmActions, context);
         if (input.AlarmActions?.length === 0) {
             entries.AlarmActions = [];
         }
@@ -3052,7 +3052,7 @@ const serializeAws_queryPutCompositeAlarmInput = (input, context) => {
         entries["AlarmRule"] = input.AlarmRule;
     }
     if (input.InsufficientDataActions != null) {
-        const memberEntries = serializeAws_queryResourceList(input.InsufficientDataActions, context);
+        const memberEntries = se_ResourceList(input.InsufficientDataActions, context);
         if (input.InsufficientDataActions?.length === 0) {
             entries.InsufficientDataActions = [];
         }
@@ -3062,7 +3062,7 @@ const serializeAws_queryPutCompositeAlarmInput = (input, context) => {
         });
     }
     if (input.OKActions != null) {
-        const memberEntries = serializeAws_queryResourceList(input.OKActions, context);
+        const memberEntries = se_ResourceList(input.OKActions, context);
         if (input.OKActions?.length === 0) {
             entries.OKActions = [];
         }
@@ -3072,7 +3072,7 @@ const serializeAws_queryPutCompositeAlarmInput = (input, context) => {
         });
     }
     if (input.Tags != null) {
-        const memberEntries = serializeAws_queryTagList(input.Tags, context);
+        const memberEntries = se_TagList(input.Tags, context);
         if (input.Tags?.length === 0) {
             entries.Tags = [];
         }
@@ -3092,7 +3092,7 @@ const serializeAws_queryPutCompositeAlarmInput = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryPutDashboardInput = (input, context) => {
+const se_PutDashboardInput = (input, context) => {
     const entries = {};
     if (input.DashboardName != null) {
         entries["DashboardName"] = input.DashboardName;
@@ -3102,7 +3102,7 @@ const serializeAws_queryPutDashboardInput = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryPutInsightRuleInput = (input, context) => {
+const se_PutInsightRuleInput = (input, context) => {
     const entries = {};
     if (input.RuleName != null) {
         entries["RuleName"] = input.RuleName;
@@ -3114,7 +3114,7 @@ const serializeAws_queryPutInsightRuleInput = (input, context) => {
         entries["RuleDefinition"] = input.RuleDefinition;
     }
     if (input.Tags != null) {
-        const memberEntries = serializeAws_queryTagList(input.Tags, context);
+        const memberEntries = se_TagList(input.Tags, context);
         if (input.Tags?.length === 0) {
             entries.Tags = [];
         }
@@ -3125,10 +3125,10 @@ const serializeAws_queryPutInsightRuleInput = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryPutManagedInsightRulesInput = (input, context) => {
+const se_PutManagedInsightRulesInput = (input, context) => {
     const entries = {};
     if (input.ManagedRules != null) {
-        const memberEntries = serializeAws_queryManagedRules(input.ManagedRules, context);
+        const memberEntries = se_ManagedRules(input.ManagedRules, context);
         if (input.ManagedRules?.length === 0) {
             entries.ManagedRules = [];
         }
@@ -3139,7 +3139,7 @@ const serializeAws_queryPutManagedInsightRulesInput = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryPutMetricAlarmInput = (input, context) => {
+const se_PutMetricAlarmInput = (input, context) => {
     const entries = {};
     if (input.AlarmName != null) {
         entries["AlarmName"] = input.AlarmName;
@@ -3151,7 +3151,7 @@ const serializeAws_queryPutMetricAlarmInput = (input, context) => {
         entries["ActionsEnabled"] = input.ActionsEnabled;
     }
     if (input.OKActions != null) {
-        const memberEntries = serializeAws_queryResourceList(input.OKActions, context);
+        const memberEntries = se_ResourceList(input.OKActions, context);
         if (input.OKActions?.length === 0) {
             entries.OKActions = [];
         }
@@ -3161,7 +3161,7 @@ const serializeAws_queryPutMetricAlarmInput = (input, context) => {
         });
     }
     if (input.AlarmActions != null) {
-        const memberEntries = serializeAws_queryResourceList(input.AlarmActions, context);
+        const memberEntries = se_ResourceList(input.AlarmActions, context);
         if (input.AlarmActions?.length === 0) {
             entries.AlarmActions = [];
         }
@@ -3171,7 +3171,7 @@ const serializeAws_queryPutMetricAlarmInput = (input, context) => {
         });
     }
     if (input.InsufficientDataActions != null) {
-        const memberEntries = serializeAws_queryResourceList(input.InsufficientDataActions, context);
+        const memberEntries = se_ResourceList(input.InsufficientDataActions, context);
         if (input.InsufficientDataActions?.length === 0) {
             entries.InsufficientDataActions = [];
         }
@@ -3193,7 +3193,7 @@ const serializeAws_queryPutMetricAlarmInput = (input, context) => {
         entries["ExtendedStatistic"] = input.ExtendedStatistic;
     }
     if (input.Dimensions != null) {
-        const memberEntries = serializeAws_queryDimensions(input.Dimensions, context);
+        const memberEntries = se_Dimensions(input.Dimensions, context);
         if (input.Dimensions?.length === 0) {
             entries.Dimensions = [];
         }
@@ -3227,7 +3227,7 @@ const serializeAws_queryPutMetricAlarmInput = (input, context) => {
         entries["EvaluateLowSampleCountPercentile"] = input.EvaluateLowSampleCountPercentile;
     }
     if (input.Metrics != null) {
-        const memberEntries = serializeAws_queryMetricDataQueries(input.Metrics, context);
+        const memberEntries = se_MetricDataQueries(input.Metrics, context);
         if (input.Metrics?.length === 0) {
             entries.Metrics = [];
         }
@@ -3237,7 +3237,7 @@ const serializeAws_queryPutMetricAlarmInput = (input, context) => {
         });
     }
     if (input.Tags != null) {
-        const memberEntries = serializeAws_queryTagList(input.Tags, context);
+        const memberEntries = se_TagList(input.Tags, context);
         if (input.Tags?.length === 0) {
             entries.Tags = [];
         }
@@ -3251,13 +3251,13 @@ const serializeAws_queryPutMetricAlarmInput = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryPutMetricDataInput = (input, context) => {
+const se_PutMetricDataInput = (input, context) => {
     const entries = {};
     if (input.Namespace != null) {
         entries["Namespace"] = input.Namespace;
     }
     if (input.MetricData != null) {
-        const memberEntries = serializeAws_queryMetricData(input.MetricData, context);
+        const memberEntries = se_MetricData(input.MetricData, context);
         if (input.MetricData?.length === 0) {
             entries.MetricData = [];
         }
@@ -3268,13 +3268,13 @@ const serializeAws_queryPutMetricDataInput = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryPutMetricStreamInput = (input, context) => {
+const se_PutMetricStreamInput = (input, context) => {
     const entries = {};
     if (input.Name != null) {
         entries["Name"] = input.Name;
     }
     if (input.IncludeFilters != null) {
-        const memberEntries = serializeAws_queryMetricStreamFilters(input.IncludeFilters, context);
+        const memberEntries = se_MetricStreamFilters(input.IncludeFilters, context);
         if (input.IncludeFilters?.length === 0) {
             entries.IncludeFilters = [];
         }
@@ -3284,7 +3284,7 @@ const serializeAws_queryPutMetricStreamInput = (input, context) => {
         });
     }
     if (input.ExcludeFilters != null) {
-        const memberEntries = serializeAws_queryMetricStreamFilters(input.ExcludeFilters, context);
+        const memberEntries = se_MetricStreamFilters(input.ExcludeFilters, context);
         if (input.ExcludeFilters?.length === 0) {
             entries.ExcludeFilters = [];
         }
@@ -3303,7 +3303,7 @@ const serializeAws_queryPutMetricStreamInput = (input, context) => {
         entries["OutputFormat"] = input.OutputFormat;
     }
     if (input.Tags != null) {
-        const memberEntries = serializeAws_queryTagList(input.Tags, context);
+        const memberEntries = se_TagList(input.Tags, context);
         if (input.Tags?.length === 0) {
             entries.Tags = [];
         }
@@ -3313,7 +3313,7 @@ const serializeAws_queryPutMetricStreamInput = (input, context) => {
         });
     }
     if (input.StatisticsConfigurations != null) {
-        const memberEntries = serializeAws_queryMetricStreamStatisticsConfigurations(input.StatisticsConfigurations, context);
+        const memberEntries = se_MetricStreamStatisticsConfigurations(input.StatisticsConfigurations, context);
         if (input.StatisticsConfigurations?.length === 0) {
             entries.StatisticsConfigurations = [];
         }
@@ -3327,7 +3327,7 @@ const serializeAws_queryPutMetricStreamInput = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryRange = (input, context) => {
+const se_Range = (input, context) => {
     const entries = {};
     if (input.StartTime != null) {
         entries["StartTime"] = input.StartTime.toISOString().split(".")[0] + "Z";
@@ -3337,7 +3337,7 @@ const serializeAws_queryRange = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryResourceList = (input, context) => {
+const se_ResourceList = (input, context) => {
     const entries = {};
     let counter = 1;
     for (const entry of input) {
@@ -3349,7 +3349,7 @@ const serializeAws_queryResourceList = (input, context) => {
     }
     return entries;
 };
-const serializeAws_querySetAlarmStateInput = (input, context) => {
+const se_SetAlarmStateInput = (input, context) => {
     const entries = {};
     if (input.AlarmName != null) {
         entries["AlarmName"] = input.AlarmName;
@@ -3365,7 +3365,7 @@ const serializeAws_querySetAlarmStateInput = (input, context) => {
     }
     return entries;
 };
-const serializeAws_querySingleMetricAnomalyDetector = (input, context) => {
+const se_SingleMetricAnomalyDetector = (input, context) => {
     const entries = {};
     if (input.Namespace != null) {
         entries["Namespace"] = input.Namespace;
@@ -3374,7 +3374,7 @@ const serializeAws_querySingleMetricAnomalyDetector = (input, context) => {
         entries["MetricName"] = input.MetricName;
     }
     if (input.Dimensions != null) {
-        const memberEntries = serializeAws_queryDimensions(input.Dimensions, context);
+        const memberEntries = se_Dimensions(input.Dimensions, context);
         if (input.Dimensions?.length === 0) {
             entries.Dimensions = [];
         }
@@ -3388,10 +3388,10 @@ const serializeAws_querySingleMetricAnomalyDetector = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryStartMetricStreamsInput = (input, context) => {
+const se_StartMetricStreamsInput = (input, context) => {
     const entries = {};
     if (input.Names != null) {
-        const memberEntries = serializeAws_queryMetricStreamNames(input.Names, context);
+        const memberEntries = se_MetricStreamNames(input.Names, context);
         if (input.Names?.length === 0) {
             entries.Names = [];
         }
@@ -3402,7 +3402,7 @@ const serializeAws_queryStartMetricStreamsInput = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryStatistics = (input, context) => {
+const se_Statistics = (input, context) => {
     const entries = {};
     let counter = 1;
     for (const entry of input) {
@@ -3414,7 +3414,7 @@ const serializeAws_queryStatistics = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryStatisticSet = (input, context) => {
+const se_StatisticSet = (input, context) => {
     const entries = {};
     if (input.SampleCount != null) {
         entries["SampleCount"] = __serializeFloat(input.SampleCount);
@@ -3430,10 +3430,10 @@ const serializeAws_queryStatisticSet = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryStopMetricStreamsInput = (input, context) => {
+const se_StopMetricStreamsInput = (input, context) => {
     const entries = {};
     if (input.Names != null) {
-        const memberEntries = serializeAws_queryMetricStreamNames(input.Names, context);
+        const memberEntries = se_MetricStreamNames(input.Names, context);
         if (input.Names?.length === 0) {
             entries.Names = [];
         }
@@ -3444,7 +3444,7 @@ const serializeAws_queryStopMetricStreamsInput = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryTag = (input, context) => {
+const se_Tag = (input, context) => {
     const entries = {};
     if (input.Key != null) {
         entries["Key"] = input.Key;
@@ -3454,7 +3454,7 @@ const serializeAws_queryTag = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryTagKeyList = (input, context) => {
+const se_TagKeyList = (input, context) => {
     const entries = {};
     let counter = 1;
     for (const entry of input) {
@@ -3466,14 +3466,14 @@ const serializeAws_queryTagKeyList = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryTagList = (input, context) => {
+const se_TagList = (input, context) => {
     const entries = {};
     let counter = 1;
     for (const entry of input) {
         if (entry === null) {
             continue;
         }
-        const memberEntries = serializeAws_queryTag(entry, context);
+        const memberEntries = se_Tag(entry, context);
         Object.entries(memberEntries).forEach(([key, value]) => {
             entries[`member.${counter}.${key}`] = value;
         });
@@ -3481,13 +3481,13 @@ const serializeAws_queryTagList = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryTagResourceInput = (input, context) => {
+const se_TagResourceInput = (input, context) => {
     const entries = {};
     if (input.ResourceARN != null) {
         entries["ResourceARN"] = input.ResourceARN;
     }
     if (input.Tags != null) {
-        const memberEntries = serializeAws_queryTagList(input.Tags, context);
+        const memberEntries = se_TagList(input.Tags, context);
         if (input.Tags?.length === 0) {
             entries.Tags = [];
         }
@@ -3498,13 +3498,13 @@ const serializeAws_queryTagResourceInput = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryUntagResourceInput = (input, context) => {
+const se_UntagResourceInput = (input, context) => {
     const entries = {};
     if (input.ResourceARN != null) {
         entries["ResourceARN"] = input.ResourceARN;
     }
     if (input.TagKeys != null) {
-        const memberEntries = serializeAws_queryTagKeyList(input.TagKeys, context);
+        const memberEntries = se_TagKeyList(input.TagKeys, context);
         if (input.TagKeys?.length === 0) {
             entries.TagKeys = [];
         }
@@ -3515,7 +3515,7 @@ const serializeAws_queryUntagResourceInput = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryValues = (input, context) => {
+const se_Values = (input, context) => {
     const entries = {};
     let counter = 1;
     for (const entry of input) {
@@ -3527,7 +3527,7 @@ const serializeAws_queryValues = (input, context) => {
     }
     return entries;
 };
-const deserializeAws_queryAlarmHistoryItem = (output, context) => {
+const de_AlarmHistoryItem = (output, context) => {
     const contents = {};
     if (output["AlarmName"] !== undefined) {
         contents.AlarmName = __expectString(output["AlarmName"]);
@@ -3549,14 +3549,14 @@ const deserializeAws_queryAlarmHistoryItem = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_queryAlarmHistoryItems = (output, context) => {
+const de_AlarmHistoryItems = (output, context) => {
     return (output || [])
         .filter((e) => e != null)
         .map((entry) => {
-        return deserializeAws_queryAlarmHistoryItem(entry, context);
+        return de_AlarmHistoryItem(entry, context);
     });
 };
-const deserializeAws_queryAnomalyDetector = (output, context) => {
+const de_AnomalyDetector = (output, context) => {
     const contents = {};
     if (output["Namespace"] !== undefined) {
         contents.Namespace = __expectString(output["Namespace"]);
@@ -3568,60 +3568,60 @@ const deserializeAws_queryAnomalyDetector = (output, context) => {
         contents.Dimensions = [];
     }
     else if (output["Dimensions"] !== undefined && output["Dimensions"]["member"] !== undefined) {
-        contents.Dimensions = deserializeAws_queryDimensions(__getArrayIfSingleItem(output["Dimensions"]["member"]), context);
+        contents.Dimensions = de_Dimensions(__getArrayIfSingleItem(output["Dimensions"]["member"]), context);
     }
     if (output["Stat"] !== undefined) {
         contents.Stat = __expectString(output["Stat"]);
     }
     if (output["Configuration"] !== undefined) {
-        contents.Configuration = deserializeAws_queryAnomalyDetectorConfiguration(output["Configuration"], context);
+        contents.Configuration = de_AnomalyDetectorConfiguration(output["Configuration"], context);
     }
     if (output["StateValue"] !== undefined) {
         contents.StateValue = __expectString(output["StateValue"]);
     }
     if (output["SingleMetricAnomalyDetector"] !== undefined) {
-        contents.SingleMetricAnomalyDetector = deserializeAws_querySingleMetricAnomalyDetector(output["SingleMetricAnomalyDetector"], context);
+        contents.SingleMetricAnomalyDetector = de_SingleMetricAnomalyDetector(output["SingleMetricAnomalyDetector"], context);
     }
     if (output["MetricMathAnomalyDetector"] !== undefined) {
-        contents.MetricMathAnomalyDetector = deserializeAws_queryMetricMathAnomalyDetector(output["MetricMathAnomalyDetector"], context);
+        contents.MetricMathAnomalyDetector = de_MetricMathAnomalyDetector(output["MetricMathAnomalyDetector"], context);
     }
     return contents;
 };
-const deserializeAws_queryAnomalyDetectorConfiguration = (output, context) => {
+const de_AnomalyDetectorConfiguration = (output, context) => {
     const contents = {};
     if (output.ExcludedTimeRanges === "") {
         contents.ExcludedTimeRanges = [];
     }
     else if (output["ExcludedTimeRanges"] !== undefined && output["ExcludedTimeRanges"]["member"] !== undefined) {
-        contents.ExcludedTimeRanges = deserializeAws_queryAnomalyDetectorExcludedTimeRanges(__getArrayIfSingleItem(output["ExcludedTimeRanges"]["member"]), context);
+        contents.ExcludedTimeRanges = de_AnomalyDetectorExcludedTimeRanges(__getArrayIfSingleItem(output["ExcludedTimeRanges"]["member"]), context);
     }
     if (output["MetricTimezone"] !== undefined) {
         contents.MetricTimezone = __expectString(output["MetricTimezone"]);
     }
     return contents;
 };
-const deserializeAws_queryAnomalyDetectorExcludedTimeRanges = (output, context) => {
+const de_AnomalyDetectorExcludedTimeRanges = (output, context) => {
     return (output || [])
         .filter((e) => e != null)
         .map((entry) => {
-        return deserializeAws_queryRange(entry, context);
+        return de_Range(entry, context);
     });
 };
-const deserializeAws_queryAnomalyDetectors = (output, context) => {
+const de_AnomalyDetectors = (output, context) => {
     return (output || [])
         .filter((e) => e != null)
         .map((entry) => {
-        return deserializeAws_queryAnomalyDetector(entry, context);
+        return de_AnomalyDetector(entry, context);
     });
 };
-const deserializeAws_queryBatchFailures = (output, context) => {
+const de_BatchFailures = (output, context) => {
     return (output || [])
         .filter((e) => e != null)
         .map((entry) => {
-        return deserializeAws_queryPartialFailure(entry, context);
+        return de_PartialFailure(entry, context);
     });
 };
-const deserializeAws_queryCompositeAlarm = (output, context) => {
+const de_CompositeAlarm = (output, context) => {
     const contents = {};
     if (output["ActionsEnabled"] !== undefined) {
         contents.ActionsEnabled = __parseBoolean(output["ActionsEnabled"]);
@@ -3630,7 +3630,7 @@ const deserializeAws_queryCompositeAlarm = (output, context) => {
         contents.AlarmActions = [];
     }
     else if (output["AlarmActions"] !== undefined && output["AlarmActions"]["member"] !== undefined) {
-        contents.AlarmActions = deserializeAws_queryResourceList(__getArrayIfSingleItem(output["AlarmActions"]["member"]), context);
+        contents.AlarmActions = de_ResourceList(__getArrayIfSingleItem(output["AlarmActions"]["member"]), context);
     }
     if (output["AlarmArn"] !== undefined) {
         contents.AlarmArn = __expectString(output["AlarmArn"]);
@@ -3652,13 +3652,13 @@ const deserializeAws_queryCompositeAlarm = (output, context) => {
     }
     else if (output["InsufficientDataActions"] !== undefined &&
         output["InsufficientDataActions"]["member"] !== undefined) {
-        contents.InsufficientDataActions = deserializeAws_queryResourceList(__getArrayIfSingleItem(output["InsufficientDataActions"]["member"]), context);
+        contents.InsufficientDataActions = de_ResourceList(__getArrayIfSingleItem(output["InsufficientDataActions"]["member"]), context);
     }
     if (output.OKActions === "") {
         contents.OKActions = [];
     }
     else if (output["OKActions"] !== undefined && output["OKActions"]["member"] !== undefined) {
-        contents.OKActions = deserializeAws_queryResourceList(__getArrayIfSingleItem(output["OKActions"]["member"]), context);
+        contents.OKActions = de_ResourceList(__getArrayIfSingleItem(output["OKActions"]["member"]), context);
     }
     if (output["StateReason"] !== undefined) {
         contents.StateReason = __expectString(output["StateReason"]);
@@ -3692,28 +3692,28 @@ const deserializeAws_queryCompositeAlarm = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_queryCompositeAlarms = (output, context) => {
+const de_CompositeAlarms = (output, context) => {
     return (output || [])
         .filter((e) => e != null)
         .map((entry) => {
-        return deserializeAws_queryCompositeAlarm(entry, context);
+        return de_CompositeAlarm(entry, context);
     });
 };
-const deserializeAws_queryConcurrentModificationException = (output, context) => {
+const de_ConcurrentModificationException = (output, context) => {
     const contents = {};
     if (output["Message"] !== undefined) {
         contents.Message = __expectString(output["Message"]);
     }
     return contents;
 };
-const deserializeAws_queryDashboardEntries = (output, context) => {
+const de_DashboardEntries = (output, context) => {
     return (output || [])
         .filter((e) => e != null)
         .map((entry) => {
-        return deserializeAws_queryDashboardEntry(entry, context);
+        return de_DashboardEntry(entry, context);
     });
 };
-const deserializeAws_queryDashboardEntry = (output, context) => {
+const de_DashboardEntry = (output, context) => {
     const contents = {};
     if (output["DashboardName"] !== undefined) {
         contents.DashboardName = __expectString(output["DashboardName"]);
@@ -3729,7 +3729,7 @@ const deserializeAws_queryDashboardEntry = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_queryDashboardInvalidInputError = (output, context) => {
+const de_DashboardInvalidInputError = (output, context) => {
     const contents = {};
     if (output["message"] !== undefined) {
         contents.message = __expectString(output["message"]);
@@ -3739,18 +3739,18 @@ const deserializeAws_queryDashboardInvalidInputError = (output, context) => {
     }
     else if (output["dashboardValidationMessages"] !== undefined &&
         output["dashboardValidationMessages"]["member"] !== undefined) {
-        contents.dashboardValidationMessages = deserializeAws_queryDashboardValidationMessages(__getArrayIfSingleItem(output["dashboardValidationMessages"]["member"]), context);
+        contents.dashboardValidationMessages = de_DashboardValidationMessages(__getArrayIfSingleItem(output["dashboardValidationMessages"]["member"]), context);
     }
     return contents;
 };
-const deserializeAws_queryDashboardNotFoundError = (output, context) => {
+const de_DashboardNotFoundError = (output, context) => {
     const contents = {};
     if (output["message"] !== undefined) {
         contents.message = __expectString(output["message"]);
     }
     return contents;
 };
-const deserializeAws_queryDashboardValidationMessage = (output, context) => {
+const de_DashboardValidationMessage = (output, context) => {
     const contents = {};
     if (output["DataPath"] !== undefined) {
         contents.DataPath = __expectString(output["DataPath"]);
@@ -3760,14 +3760,14 @@ const deserializeAws_queryDashboardValidationMessage = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_queryDashboardValidationMessages = (output, context) => {
+const de_DashboardValidationMessages = (output, context) => {
     return (output || [])
         .filter((e) => e != null)
         .map((entry) => {
-        return deserializeAws_queryDashboardValidationMessage(entry, context);
+        return de_DashboardValidationMessage(entry, context);
     });
 };
-const deserializeAws_queryDatapoint = (output, context) => {
+const de_Datapoint = (output, context) => {
     const contents = {};
     if (output["Timestamp"] !== undefined) {
         contents.Timestamp = __expectNonNull(__parseRfc3339DateTimeWithOffset(output["Timestamp"]));
@@ -3794,18 +3794,18 @@ const deserializeAws_queryDatapoint = (output, context) => {
         contents.ExtendedStatistics = {};
     }
     else if (output["ExtendedStatistics"] !== undefined && output["ExtendedStatistics"]["entry"] !== undefined) {
-        contents.ExtendedStatistics = deserializeAws_queryDatapointValueMap(__getArrayIfSingleItem(output["ExtendedStatistics"]["entry"]), context);
+        contents.ExtendedStatistics = de_DatapointValueMap(__getArrayIfSingleItem(output["ExtendedStatistics"]["entry"]), context);
     }
     return contents;
 };
-const deserializeAws_queryDatapoints = (output, context) => {
+const de_Datapoints = (output, context) => {
     return (output || [])
         .filter((e) => e != null)
         .map((entry) => {
-        return deserializeAws_queryDatapoint(entry, context);
+        return de_Datapoint(entry, context);
     });
 };
-const deserializeAws_queryDatapointValueMap = (output, context) => {
+const de_DatapointValueMap = (output, context) => {
     return output.reduce((acc, pair) => {
         if (pair["value"] === null) {
             return acc;
@@ -3814,91 +3814,91 @@ const deserializeAws_queryDatapointValueMap = (output, context) => {
         return acc;
     }, {});
 };
-const deserializeAws_queryDatapointValues = (output, context) => {
+const de_DatapointValues = (output, context) => {
     return (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         return __strictParseFloat(entry);
     });
 };
-const deserializeAws_queryDeleteAnomalyDetectorOutput = (output, context) => {
+const de_DeleteAnomalyDetectorOutput = (output, context) => {
     const contents = {};
     return contents;
 };
-const deserializeAws_queryDeleteDashboardsOutput = (output, context) => {
+const de_DeleteDashboardsOutput = (output, context) => {
     const contents = {};
     return contents;
 };
-const deserializeAws_queryDeleteInsightRulesOutput = (output, context) => {
+const de_DeleteInsightRulesOutput = (output, context) => {
     const contents = {};
     if (output.Failures === "") {
         contents.Failures = [];
     }
     else if (output["Failures"] !== undefined && output["Failures"]["member"] !== undefined) {
-        contents.Failures = deserializeAws_queryBatchFailures(__getArrayIfSingleItem(output["Failures"]["member"]), context);
+        contents.Failures = de_BatchFailures(__getArrayIfSingleItem(output["Failures"]["member"]), context);
     }
     return contents;
 };
-const deserializeAws_queryDeleteMetricStreamOutput = (output, context) => {
+const de_DeleteMetricStreamOutput = (output, context) => {
     const contents = {};
     return contents;
 };
-const deserializeAws_queryDescribeAlarmHistoryOutput = (output, context) => {
+const de_DescribeAlarmHistoryOutput = (output, context) => {
     const contents = {};
     if (output.AlarmHistoryItems === "") {
         contents.AlarmHistoryItems = [];
     }
     else if (output["AlarmHistoryItems"] !== undefined && output["AlarmHistoryItems"]["member"] !== undefined) {
-        contents.AlarmHistoryItems = deserializeAws_queryAlarmHistoryItems(__getArrayIfSingleItem(output["AlarmHistoryItems"]["member"]), context);
+        contents.AlarmHistoryItems = de_AlarmHistoryItems(__getArrayIfSingleItem(output["AlarmHistoryItems"]["member"]), context);
     }
     if (output["NextToken"] !== undefined) {
         contents.NextToken = __expectString(output["NextToken"]);
     }
     return contents;
 };
-const deserializeAws_queryDescribeAlarmsForMetricOutput = (output, context) => {
+const de_DescribeAlarmsForMetricOutput = (output, context) => {
     const contents = {};
     if (output.MetricAlarms === "") {
         contents.MetricAlarms = [];
     }
     else if (output["MetricAlarms"] !== undefined && output["MetricAlarms"]["member"] !== undefined) {
-        contents.MetricAlarms = deserializeAws_queryMetricAlarms(__getArrayIfSingleItem(output["MetricAlarms"]["member"]), context);
+        contents.MetricAlarms = de_MetricAlarms(__getArrayIfSingleItem(output["MetricAlarms"]["member"]), context);
     }
     return contents;
 };
-const deserializeAws_queryDescribeAlarmsOutput = (output, context) => {
+const de_DescribeAlarmsOutput = (output, context) => {
     const contents = {};
     if (output.CompositeAlarms === "") {
         contents.CompositeAlarms = [];
     }
     else if (output["CompositeAlarms"] !== undefined && output["CompositeAlarms"]["member"] !== undefined) {
-        contents.CompositeAlarms = deserializeAws_queryCompositeAlarms(__getArrayIfSingleItem(output["CompositeAlarms"]["member"]), context);
+        contents.CompositeAlarms = de_CompositeAlarms(__getArrayIfSingleItem(output["CompositeAlarms"]["member"]), context);
     }
     if (output.MetricAlarms === "") {
         contents.MetricAlarms = [];
     }
     else if (output["MetricAlarms"] !== undefined && output["MetricAlarms"]["member"] !== undefined) {
-        contents.MetricAlarms = deserializeAws_queryMetricAlarms(__getArrayIfSingleItem(output["MetricAlarms"]["member"]), context);
+        contents.MetricAlarms = de_MetricAlarms(__getArrayIfSingleItem(output["MetricAlarms"]["member"]), context);
     }
     if (output["NextToken"] !== undefined) {
         contents.NextToken = __expectString(output["NextToken"]);
     }
     return contents;
 };
-const deserializeAws_queryDescribeAnomalyDetectorsOutput = (output, context) => {
+const de_DescribeAnomalyDetectorsOutput = (output, context) => {
     const contents = {};
     if (output.AnomalyDetectors === "") {
         contents.AnomalyDetectors = [];
     }
     else if (output["AnomalyDetectors"] !== undefined && output["AnomalyDetectors"]["member"] !== undefined) {
-        contents.AnomalyDetectors = deserializeAws_queryAnomalyDetectors(__getArrayIfSingleItem(output["AnomalyDetectors"]["member"]), context);
+        contents.AnomalyDetectors = de_AnomalyDetectors(__getArrayIfSingleItem(output["AnomalyDetectors"]["member"]), context);
     }
     if (output["NextToken"] !== undefined) {
         contents.NextToken = __expectString(output["NextToken"]);
     }
     return contents;
 };
-const deserializeAws_queryDescribeInsightRulesOutput = (output, context) => {
+const de_DescribeInsightRulesOutput = (output, context) => {
     const contents = {};
     if (output["NextToken"] !== undefined) {
         contents.NextToken = __expectString(output["NextToken"]);
@@ -3907,11 +3907,11 @@ const deserializeAws_queryDescribeInsightRulesOutput = (output, context) => {
         contents.InsightRules = [];
     }
     else if (output["InsightRules"] !== undefined && output["InsightRules"]["member"] !== undefined) {
-        contents.InsightRules = deserializeAws_queryInsightRules(__getArrayIfSingleItem(output["InsightRules"]["member"]), context);
+        contents.InsightRules = de_InsightRules(__getArrayIfSingleItem(output["InsightRules"]["member"]), context);
     }
     return contents;
 };
-const deserializeAws_queryDimension = (output, context) => {
+const de_Dimension = (output, context) => {
     const contents = {};
     if (output["Name"] !== undefined) {
         contents.Name = __expectString(output["Name"]);
@@ -3921,34 +3921,34 @@ const deserializeAws_queryDimension = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_queryDimensions = (output, context) => {
+const de_Dimensions = (output, context) => {
     return (output || [])
         .filter((e) => e != null)
         .map((entry) => {
-        return deserializeAws_queryDimension(entry, context);
+        return de_Dimension(entry, context);
     });
 };
-const deserializeAws_queryDisableInsightRulesOutput = (output, context) => {
+const de_DisableInsightRulesOutput = (output, context) => {
     const contents = {};
     if (output.Failures === "") {
         contents.Failures = [];
     }
     else if (output["Failures"] !== undefined && output["Failures"]["member"] !== undefined) {
-        contents.Failures = deserializeAws_queryBatchFailures(__getArrayIfSingleItem(output["Failures"]["member"]), context);
+        contents.Failures = de_BatchFailures(__getArrayIfSingleItem(output["Failures"]["member"]), context);
     }
     return contents;
 };
-const deserializeAws_queryEnableInsightRulesOutput = (output, context) => {
+const de_EnableInsightRulesOutput = (output, context) => {
     const contents = {};
     if (output.Failures === "") {
         contents.Failures = [];
     }
     else if (output["Failures"] !== undefined && output["Failures"]["member"] !== undefined) {
-        contents.Failures = deserializeAws_queryBatchFailures(__getArrayIfSingleItem(output["Failures"]["member"]), context);
+        contents.Failures = de_BatchFailures(__getArrayIfSingleItem(output["Failures"]["member"]), context);
     }
     return contents;
 };
-const deserializeAws_queryGetDashboardOutput = (output, context) => {
+const de_GetDashboardOutput = (output, context) => {
     const contents = {};
     if (output["DashboardArn"] !== undefined) {
         contents.DashboardArn = __expectString(output["DashboardArn"]);
@@ -3961,13 +3961,13 @@ const deserializeAws_queryGetDashboardOutput = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_queryGetInsightRuleReportOutput = (output, context) => {
+const de_GetInsightRuleReportOutput = (output, context) => {
     const contents = {};
     if (output.KeyLabels === "") {
         contents.KeyLabels = [];
     }
     else if (output["KeyLabels"] !== undefined && output["KeyLabels"]["member"] !== undefined) {
-        contents.KeyLabels = deserializeAws_queryInsightRuleContributorKeyLabels(__getArrayIfSingleItem(output["KeyLabels"]["member"]), context);
+        contents.KeyLabels = de_InsightRuleContributorKeyLabels(__getArrayIfSingleItem(output["KeyLabels"]["member"]), context);
     }
     if (output["AggregationStatistic"] !== undefined) {
         contents.AggregationStatistic = __expectString(output["AggregationStatistic"]);
@@ -3982,23 +3982,23 @@ const deserializeAws_queryGetInsightRuleReportOutput = (output, context) => {
         contents.Contributors = [];
     }
     else if (output["Contributors"] !== undefined && output["Contributors"]["member"] !== undefined) {
-        contents.Contributors = deserializeAws_queryInsightRuleContributors(__getArrayIfSingleItem(output["Contributors"]["member"]), context);
+        contents.Contributors = de_InsightRuleContributors(__getArrayIfSingleItem(output["Contributors"]["member"]), context);
     }
     if (output.MetricDatapoints === "") {
         contents.MetricDatapoints = [];
     }
     else if (output["MetricDatapoints"] !== undefined && output["MetricDatapoints"]["member"] !== undefined) {
-        contents.MetricDatapoints = deserializeAws_queryInsightRuleMetricDatapoints(__getArrayIfSingleItem(output["MetricDatapoints"]["member"]), context);
+        contents.MetricDatapoints = de_InsightRuleMetricDatapoints(__getArrayIfSingleItem(output["MetricDatapoints"]["member"]), context);
     }
     return contents;
 };
-const deserializeAws_queryGetMetricDataOutput = (output, context) => {
+const de_GetMetricDataOutput = (output, context) => {
     const contents = {};
     if (output.MetricDataResults === "") {
         contents.MetricDataResults = [];
     }
     else if (output["MetricDataResults"] !== undefined && output["MetricDataResults"]["member"] !== undefined) {
-        contents.MetricDataResults = deserializeAws_queryMetricDataResults(__getArrayIfSingleItem(output["MetricDataResults"]["member"]), context);
+        contents.MetricDataResults = de_MetricDataResults(__getArrayIfSingleItem(output["MetricDataResults"]["member"]), context);
     }
     if (output["NextToken"] !== undefined) {
         contents.NextToken = __expectString(output["NextToken"]);
@@ -4007,11 +4007,11 @@ const deserializeAws_queryGetMetricDataOutput = (output, context) => {
         contents.Messages = [];
     }
     else if (output["Messages"] !== undefined && output["Messages"]["member"] !== undefined) {
-        contents.Messages = deserializeAws_queryMetricDataResultMessages(__getArrayIfSingleItem(output["Messages"]["member"]), context);
+        contents.Messages = de_MetricDataResultMessages(__getArrayIfSingleItem(output["Messages"]["member"]), context);
     }
     return contents;
 };
-const deserializeAws_queryGetMetricStatisticsOutput = (output, context) => {
+const de_GetMetricStatisticsOutput = (output, context) => {
     const contents = {};
     if (output["Label"] !== undefined) {
         contents.Label = __expectString(output["Label"]);
@@ -4020,11 +4020,11 @@ const deserializeAws_queryGetMetricStatisticsOutput = (output, context) => {
         contents.Datapoints = [];
     }
     else if (output["Datapoints"] !== undefined && output["Datapoints"]["member"] !== undefined) {
-        contents.Datapoints = deserializeAws_queryDatapoints(__getArrayIfSingleItem(output["Datapoints"]["member"]), context);
+        contents.Datapoints = de_Datapoints(__getArrayIfSingleItem(output["Datapoints"]["member"]), context);
     }
     return contents;
 };
-const deserializeAws_queryGetMetricStreamOutput = (output, context) => {
+const de_GetMetricStreamOutput = (output, context) => {
     const contents = {};
     if (output["Arn"] !== undefined) {
         contents.Arn = __expectString(output["Arn"]);
@@ -4036,13 +4036,13 @@ const deserializeAws_queryGetMetricStreamOutput = (output, context) => {
         contents.IncludeFilters = [];
     }
     else if (output["IncludeFilters"] !== undefined && output["IncludeFilters"]["member"] !== undefined) {
-        contents.IncludeFilters = deserializeAws_queryMetricStreamFilters(__getArrayIfSingleItem(output["IncludeFilters"]["member"]), context);
+        contents.IncludeFilters = de_MetricStreamFilters(__getArrayIfSingleItem(output["IncludeFilters"]["member"]), context);
     }
     if (output.ExcludeFilters === "") {
         contents.ExcludeFilters = [];
     }
     else if (output["ExcludeFilters"] !== undefined && output["ExcludeFilters"]["member"] !== undefined) {
-        contents.ExcludeFilters = deserializeAws_queryMetricStreamFilters(__getArrayIfSingleItem(output["ExcludeFilters"]["member"]), context);
+        contents.ExcludeFilters = de_MetricStreamFilters(__getArrayIfSingleItem(output["ExcludeFilters"]["member"]), context);
     }
     if (output["FirehoseArn"] !== undefined) {
         contents.FirehoseArn = __expectString(output["FirehoseArn"]);
@@ -4067,21 +4067,21 @@ const deserializeAws_queryGetMetricStreamOutput = (output, context) => {
     }
     else if (output["StatisticsConfigurations"] !== undefined &&
         output["StatisticsConfigurations"]["member"] !== undefined) {
-        contents.StatisticsConfigurations = deserializeAws_queryMetricStreamStatisticsConfigurations(__getArrayIfSingleItem(output["StatisticsConfigurations"]["member"]), context);
+        contents.StatisticsConfigurations = de_MetricStreamStatisticsConfigurations(__getArrayIfSingleItem(output["StatisticsConfigurations"]["member"]), context);
     }
     if (output["IncludeLinkedAccountsMetrics"] !== undefined) {
         contents.IncludeLinkedAccountsMetrics = __parseBoolean(output["IncludeLinkedAccountsMetrics"]);
     }
     return contents;
 };
-const deserializeAws_queryGetMetricWidgetImageOutput = (output, context) => {
+const de_GetMetricWidgetImageOutput = (output, context) => {
     const contents = {};
     if (output["MetricWidgetImage"] !== undefined) {
         contents.MetricWidgetImage = context.base64Decoder(output["MetricWidgetImage"]);
     }
     return contents;
 };
-const deserializeAws_queryInsightRule = (output, context) => {
+const de_InsightRule = (output, context) => {
     const contents = {};
     if (output["Name"] !== undefined) {
         contents.Name = __expectString(output["Name"]);
@@ -4100,13 +4100,13 @@ const deserializeAws_queryInsightRule = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_queryInsightRuleContributor = (output, context) => {
+const de_InsightRuleContributor = (output, context) => {
     const contents = {};
     if (output.Keys === "") {
         contents.Keys = [];
     }
     else if (output["Keys"] !== undefined && output["Keys"]["member"] !== undefined) {
-        contents.Keys = deserializeAws_queryInsightRuleContributorKeys(__getArrayIfSingleItem(output["Keys"]["member"]), context);
+        contents.Keys = de_InsightRuleContributorKeys(__getArrayIfSingleItem(output["Keys"]["member"]), context);
     }
     if (output["ApproximateAggregateValue"] !== undefined) {
         contents.ApproximateAggregateValue = __strictParseFloat(output["ApproximateAggregateValue"]);
@@ -4115,11 +4115,11 @@ const deserializeAws_queryInsightRuleContributor = (output, context) => {
         contents.Datapoints = [];
     }
     else if (output["Datapoints"] !== undefined && output["Datapoints"]["member"] !== undefined) {
-        contents.Datapoints = deserializeAws_queryInsightRuleContributorDatapoints(__getArrayIfSingleItem(output["Datapoints"]["member"]), context);
+        contents.Datapoints = de_InsightRuleContributorDatapoints(__getArrayIfSingleItem(output["Datapoints"]["member"]), context);
     }
     return contents;
 };
-const deserializeAws_queryInsightRuleContributorDatapoint = (output, context) => {
+const de_InsightRuleContributorDatapoint = (output, context) => {
     const contents = {};
     if (output["Timestamp"] !== undefined) {
         contents.Timestamp = __expectNonNull(__parseRfc3339DateTimeWithOffset(output["Timestamp"]));
@@ -4129,35 +4129,35 @@ const deserializeAws_queryInsightRuleContributorDatapoint = (output, context) =>
     }
     return contents;
 };
-const deserializeAws_queryInsightRuleContributorDatapoints = (output, context) => {
+const de_InsightRuleContributorDatapoints = (output, context) => {
     return (output || [])
         .filter((e) => e != null)
         .map((entry) => {
-        return deserializeAws_queryInsightRuleContributorDatapoint(entry, context);
+        return de_InsightRuleContributorDatapoint(entry, context);
     });
 };
-const deserializeAws_queryInsightRuleContributorKeyLabels = (output, context) => {
+const de_InsightRuleContributorKeyLabels = (output, context) => {
     return (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         return __expectString(entry);
     });
 };
-const deserializeAws_queryInsightRuleContributorKeys = (output, context) => {
+const de_InsightRuleContributorKeys = (output, context) => {
     return (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         return __expectString(entry);
     });
 };
-const deserializeAws_queryInsightRuleContributors = (output, context) => {
+const de_InsightRuleContributors = (output, context) => {
     return (output || [])
         .filter((e) => e != null)
         .map((entry) => {
-        return deserializeAws_queryInsightRuleContributor(entry, context);
+        return de_InsightRuleContributor(entry, context);
     });
 };
-const deserializeAws_queryInsightRuleMetricDatapoint = (output, context) => {
+const de_InsightRuleMetricDatapoint = (output, context) => {
     const contents = {};
     if (output["Timestamp"] !== undefined) {
         contents.Timestamp = __expectNonNull(__parseRfc3339DateTimeWithOffset(output["Timestamp"]));
@@ -4185,102 +4185,102 @@ const deserializeAws_queryInsightRuleMetricDatapoint = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_queryInsightRuleMetricDatapoints = (output, context) => {
+const de_InsightRuleMetricDatapoints = (output, context) => {
     return (output || [])
         .filter((e) => e != null)
         .map((entry) => {
-        return deserializeAws_queryInsightRuleMetricDatapoint(entry, context);
+        return de_InsightRuleMetricDatapoint(entry, context);
     });
 };
-const deserializeAws_queryInsightRules = (output, context) => {
+const de_InsightRules = (output, context) => {
     return (output || [])
         .filter((e) => e != null)
         .map((entry) => {
-        return deserializeAws_queryInsightRule(entry, context);
+        return de_InsightRule(entry, context);
     });
 };
-const deserializeAws_queryInternalServiceFault = (output, context) => {
+const de_InternalServiceFault = (output, context) => {
     const contents = {};
     if (output["Message"] !== undefined) {
         contents.Message = __expectString(output["Message"]);
     }
     return contents;
 };
-const deserializeAws_queryInvalidFormatFault = (output, context) => {
+const de_InvalidFormatFault = (output, context) => {
     const contents = {};
     if (output["message"] !== undefined) {
         contents.message = __expectString(output["message"]);
     }
     return contents;
 };
-const deserializeAws_queryInvalidNextToken = (output, context) => {
+const de_InvalidNextToken = (output, context) => {
     const contents = {};
     if (output["message"] !== undefined) {
         contents.message = __expectString(output["message"]);
     }
     return contents;
 };
-const deserializeAws_queryInvalidParameterCombinationException = (output, context) => {
+const de_InvalidParameterCombinationException = (output, context) => {
     const contents = {};
     if (output["message"] !== undefined) {
         contents.message = __expectString(output["message"]);
     }
     return contents;
 };
-const deserializeAws_queryInvalidParameterValueException = (output, context) => {
+const de_InvalidParameterValueException = (output, context) => {
     const contents = {};
     if (output["message"] !== undefined) {
         contents.message = __expectString(output["message"]);
     }
     return contents;
 };
-const deserializeAws_queryLimitExceededException = (output, context) => {
+const de_LimitExceededException = (output, context) => {
     const contents = {};
     if (output["Message"] !== undefined) {
         contents.Message = __expectString(output["Message"]);
     }
     return contents;
 };
-const deserializeAws_queryLimitExceededFault = (output, context) => {
+const de_LimitExceededFault = (output, context) => {
     const contents = {};
     if (output["message"] !== undefined) {
         contents.message = __expectString(output["message"]);
     }
     return contents;
 };
-const deserializeAws_queryListDashboardsOutput = (output, context) => {
+const de_ListDashboardsOutput = (output, context) => {
     const contents = {};
     if (output.DashboardEntries === "") {
         contents.DashboardEntries = [];
     }
     else if (output["DashboardEntries"] !== undefined && output["DashboardEntries"]["member"] !== undefined) {
-        contents.DashboardEntries = deserializeAws_queryDashboardEntries(__getArrayIfSingleItem(output["DashboardEntries"]["member"]), context);
+        contents.DashboardEntries = de_DashboardEntries(__getArrayIfSingleItem(output["DashboardEntries"]["member"]), context);
     }
     if (output["NextToken"] !== undefined) {
         contents.NextToken = __expectString(output["NextToken"]);
     }
     return contents;
 };
-const deserializeAws_queryListManagedInsightRulesOutput = (output, context) => {
+const de_ListManagedInsightRulesOutput = (output, context) => {
     const contents = {};
     if (output.ManagedRules === "") {
         contents.ManagedRules = [];
     }
     else if (output["ManagedRules"] !== undefined && output["ManagedRules"]["member"] !== undefined) {
-        contents.ManagedRules = deserializeAws_queryManagedRuleDescriptions(__getArrayIfSingleItem(output["ManagedRules"]["member"]), context);
+        contents.ManagedRules = de_ManagedRuleDescriptions(__getArrayIfSingleItem(output["ManagedRules"]["member"]), context);
     }
     if (output["NextToken"] !== undefined) {
         contents.NextToken = __expectString(output["NextToken"]);
     }
     return contents;
 };
-const deserializeAws_queryListMetricsOutput = (output, context) => {
+const de_ListMetricsOutput = (output, context) => {
     const contents = {};
     if (output.Metrics === "") {
         contents.Metrics = [];
     }
     else if (output["Metrics"] !== undefined && output["Metrics"]["member"] !== undefined) {
-        contents.Metrics = deserializeAws_queryMetrics(__getArrayIfSingleItem(output["Metrics"]["member"]), context);
+        contents.Metrics = de_Metrics(__getArrayIfSingleItem(output["Metrics"]["member"]), context);
     }
     if (output["NextToken"] !== undefined) {
         contents.NextToken = __expectString(output["NextToken"]);
@@ -4289,11 +4289,11 @@ const deserializeAws_queryListMetricsOutput = (output, context) => {
         contents.OwningAccounts = [];
     }
     else if (output["OwningAccounts"] !== undefined && output["OwningAccounts"]["member"] !== undefined) {
-        contents.OwningAccounts = deserializeAws_queryOwningAccounts(__getArrayIfSingleItem(output["OwningAccounts"]["member"]), context);
+        contents.OwningAccounts = de_OwningAccounts(__getArrayIfSingleItem(output["OwningAccounts"]["member"]), context);
     }
     return contents;
 };
-const deserializeAws_queryListMetricStreamsOutput = (output, context) => {
+const de_ListMetricStreamsOutput = (output, context) => {
     const contents = {};
     if (output["NextToken"] !== undefined) {
         contents.NextToken = __expectString(output["NextToken"]);
@@ -4302,21 +4302,21 @@ const deserializeAws_queryListMetricStreamsOutput = (output, context) => {
         contents.Entries = [];
     }
     else if (output["Entries"] !== undefined && output["Entries"]["member"] !== undefined) {
-        contents.Entries = deserializeAws_queryMetricStreamEntries(__getArrayIfSingleItem(output["Entries"]["member"]), context);
+        contents.Entries = de_MetricStreamEntries(__getArrayIfSingleItem(output["Entries"]["member"]), context);
     }
     return contents;
 };
-const deserializeAws_queryListTagsForResourceOutput = (output, context) => {
+const de_ListTagsForResourceOutput = (output, context) => {
     const contents = {};
     if (output.Tags === "") {
         contents.Tags = [];
     }
     else if (output["Tags"] !== undefined && output["Tags"]["member"] !== undefined) {
-        contents.Tags = deserializeAws_queryTagList(__getArrayIfSingleItem(output["Tags"]["member"]), context);
+        contents.Tags = de_TagList(__getArrayIfSingleItem(output["Tags"]["member"]), context);
     }
     return contents;
 };
-const deserializeAws_queryManagedRuleDescription = (output, context) => {
+const de_ManagedRuleDescription = (output, context) => {
     const contents = {};
     if (output["TemplateName"] !== undefined) {
         contents.TemplateName = __expectString(output["TemplateName"]);
@@ -4325,18 +4325,18 @@ const deserializeAws_queryManagedRuleDescription = (output, context) => {
         contents.ResourceARN = __expectString(output["ResourceARN"]);
     }
     if (output["RuleState"] !== undefined) {
-        contents.RuleState = deserializeAws_queryManagedRuleState(output["RuleState"], context);
+        contents.RuleState = de_ManagedRuleState(output["RuleState"], context);
     }
     return contents;
 };
-const deserializeAws_queryManagedRuleDescriptions = (output, context) => {
+const de_ManagedRuleDescriptions = (output, context) => {
     return (output || [])
         .filter((e) => e != null)
         .map((entry) => {
-        return deserializeAws_queryManagedRuleDescription(entry, context);
+        return de_ManagedRuleDescription(entry, context);
     });
 };
-const deserializeAws_queryManagedRuleState = (output, context) => {
+const de_ManagedRuleState = (output, context) => {
     const contents = {};
     if (output["RuleName"] !== undefined) {
         contents.RuleName = __expectString(output["RuleName"]);
@@ -4346,7 +4346,7 @@ const deserializeAws_queryManagedRuleState = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_queryMessageData = (output, context) => {
+const de_MessageData = (output, context) => {
     const contents = {};
     if (output["Code"] !== undefined) {
         contents.Code = __expectString(output["Code"]);
@@ -4356,7 +4356,7 @@ const deserializeAws_queryMessageData = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_queryMetric = (output, context) => {
+const de_Metric = (output, context) => {
     const contents = {};
     if (output["Namespace"] !== undefined) {
         contents.Namespace = __expectString(output["Namespace"]);
@@ -4368,11 +4368,11 @@ const deserializeAws_queryMetric = (output, context) => {
         contents.Dimensions = [];
     }
     else if (output["Dimensions"] !== undefined && output["Dimensions"]["member"] !== undefined) {
-        contents.Dimensions = deserializeAws_queryDimensions(__getArrayIfSingleItem(output["Dimensions"]["member"]), context);
+        contents.Dimensions = de_Dimensions(__getArrayIfSingleItem(output["Dimensions"]["member"]), context);
     }
     return contents;
 };
-const deserializeAws_queryMetricAlarm = (output, context) => {
+const de_MetricAlarm = (output, context) => {
     const contents = {};
     if (output["AlarmName"] !== undefined) {
         contents.AlarmName = __expectString(output["AlarmName"]);
@@ -4393,20 +4393,20 @@ const deserializeAws_queryMetricAlarm = (output, context) => {
         contents.OKActions = [];
     }
     else if (output["OKActions"] !== undefined && output["OKActions"]["member"] !== undefined) {
-        contents.OKActions = deserializeAws_queryResourceList(__getArrayIfSingleItem(output["OKActions"]["member"]), context);
+        contents.OKActions = de_ResourceList(__getArrayIfSingleItem(output["OKActions"]["member"]), context);
     }
     if (output.AlarmActions === "") {
         contents.AlarmActions = [];
     }
     else if (output["AlarmActions"] !== undefined && output["AlarmActions"]["member"] !== undefined) {
-        contents.AlarmActions = deserializeAws_queryResourceList(__getArrayIfSingleItem(output["AlarmActions"]["member"]), context);
+        contents.AlarmActions = de_ResourceList(__getArrayIfSingleItem(output["AlarmActions"]["member"]), context);
     }
     if (output.InsufficientDataActions === "") {
         contents.InsufficientDataActions = [];
     }
     else if (output["InsufficientDataActions"] !== undefined &&
         output["InsufficientDataActions"]["member"] !== undefined) {
-        contents.InsufficientDataActions = deserializeAws_queryResourceList(__getArrayIfSingleItem(output["InsufficientDataActions"]["member"]), context);
+        contents.InsufficientDataActions = de_ResourceList(__getArrayIfSingleItem(output["InsufficientDataActions"]["member"]), context);
     }
     if (output["StateValue"] !== undefined) {
         contents.StateValue = __expectString(output["StateValue"]);
@@ -4436,7 +4436,7 @@ const deserializeAws_queryMetricAlarm = (output, context) => {
         contents.Dimensions = [];
     }
     else if (output["Dimensions"] !== undefined && output["Dimensions"]["member"] !== undefined) {
-        contents.Dimensions = deserializeAws_queryDimensions(__getArrayIfSingleItem(output["Dimensions"]["member"]), context);
+        contents.Dimensions = de_Dimensions(__getArrayIfSingleItem(output["Dimensions"]["member"]), context);
     }
     if (output["Period"] !== undefined) {
         contents.Period = __strictParseInt32(output["Period"]);
@@ -4466,7 +4466,7 @@ const deserializeAws_queryMetricAlarm = (output, context) => {
         contents.Metrics = [];
     }
     else if (output["Metrics"] !== undefined && output["Metrics"]["member"] !== undefined) {
-        contents.Metrics = deserializeAws_queryMetricDataQueries(__getArrayIfSingleItem(output["Metrics"]["member"]), context);
+        contents.Metrics = de_MetricDataQueries(__getArrayIfSingleItem(output["Metrics"]["member"]), context);
     }
     if (output["ThresholdMetricId"] !== undefined) {
         contents.ThresholdMetricId = __expectString(output["ThresholdMetricId"]);
@@ -4479,27 +4479,27 @@ const deserializeAws_queryMetricAlarm = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_queryMetricAlarms = (output, context) => {
+const de_MetricAlarms = (output, context) => {
     return (output || [])
         .filter((e) => e != null)
         .map((entry) => {
-        return deserializeAws_queryMetricAlarm(entry, context);
+        return de_MetricAlarm(entry, context);
     });
 };
-const deserializeAws_queryMetricDataQueries = (output, context) => {
+const de_MetricDataQueries = (output, context) => {
     return (output || [])
         .filter((e) => e != null)
         .map((entry) => {
-        return deserializeAws_queryMetricDataQuery(entry, context);
+        return de_MetricDataQuery(entry, context);
     });
 };
-const deserializeAws_queryMetricDataQuery = (output, context) => {
+const de_MetricDataQuery = (output, context) => {
     const contents = {};
     if (output["Id"] !== undefined) {
         contents.Id = __expectString(output["Id"]);
     }
     if (output["MetricStat"] !== undefined) {
-        contents.MetricStat = deserializeAws_queryMetricStat(output["MetricStat"], context);
+        contents.MetricStat = de_MetricStat(output["MetricStat"], context);
     }
     if (output["Expression"] !== undefined) {
         contents.Expression = __expectString(output["Expression"]);
@@ -4518,7 +4518,7 @@ const deserializeAws_queryMetricDataQuery = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_queryMetricDataResult = (output, context) => {
+const de_MetricDataResult = (output, context) => {
     const contents = {};
     if (output["Id"] !== undefined) {
         contents.Id = __expectString(output["Id"]);
@@ -4530,13 +4530,13 @@ const deserializeAws_queryMetricDataResult = (output, context) => {
         contents.Timestamps = [];
     }
     else if (output["Timestamps"] !== undefined && output["Timestamps"]["member"] !== undefined) {
-        contents.Timestamps = deserializeAws_queryTimestamps(__getArrayIfSingleItem(output["Timestamps"]["member"]), context);
+        contents.Timestamps = de_Timestamps(__getArrayIfSingleItem(output["Timestamps"]["member"]), context);
     }
     if (output.Values === "") {
         contents.Values = [];
     }
     else if (output["Values"] !== undefined && output["Values"]["member"] !== undefined) {
-        contents.Values = deserializeAws_queryDatapointValues(__getArrayIfSingleItem(output["Values"]["member"]), context);
+        contents.Values = de_DatapointValues(__getArrayIfSingleItem(output["Values"]["member"]), context);
     }
     if (output["StatusCode"] !== undefined) {
         contents.StatusCode = __expectString(output["StatusCode"]);
@@ -4545,45 +4545,45 @@ const deserializeAws_queryMetricDataResult = (output, context) => {
         contents.Messages = [];
     }
     else if (output["Messages"] !== undefined && output["Messages"]["member"] !== undefined) {
-        contents.Messages = deserializeAws_queryMetricDataResultMessages(__getArrayIfSingleItem(output["Messages"]["member"]), context);
+        contents.Messages = de_MetricDataResultMessages(__getArrayIfSingleItem(output["Messages"]["member"]), context);
     }
     return contents;
 };
-const deserializeAws_queryMetricDataResultMessages = (output, context) => {
+const de_MetricDataResultMessages = (output, context) => {
     return (output || [])
         .filter((e) => e != null)
         .map((entry) => {
-        return deserializeAws_queryMessageData(entry, context);
+        return de_MessageData(entry, context);
     });
 };
-const deserializeAws_queryMetricDataResults = (output, context) => {
+const de_MetricDataResults = (output, context) => {
     return (output || [])
         .filter((e) => e != null)
         .map((entry) => {
-        return deserializeAws_queryMetricDataResult(entry, context);
+        return de_MetricDataResult(entry, context);
     });
 };
-const deserializeAws_queryMetricMathAnomalyDetector = (output, context) => {
+const de_MetricMathAnomalyDetector = (output, context) => {
     const contents = {};
     if (output.MetricDataQueries === "") {
         contents.MetricDataQueries = [];
     }
     else if (output["MetricDataQueries"] !== undefined && output["MetricDataQueries"]["member"] !== undefined) {
-        contents.MetricDataQueries = deserializeAws_queryMetricDataQueries(__getArrayIfSingleItem(output["MetricDataQueries"]["member"]), context);
+        contents.MetricDataQueries = de_MetricDataQueries(__getArrayIfSingleItem(output["MetricDataQueries"]["member"]), context);
     }
     return contents;
 };
-const deserializeAws_queryMetrics = (output, context) => {
+const de_Metrics = (output, context) => {
     return (output || [])
         .filter((e) => e != null)
         .map((entry) => {
-        return deserializeAws_queryMetric(entry, context);
+        return de_Metric(entry, context);
     });
 };
-const deserializeAws_queryMetricStat = (output, context) => {
+const de_MetricStat = (output, context) => {
     const contents = {};
     if (output["Metric"] !== undefined) {
-        contents.Metric = deserializeAws_queryMetric(output["Metric"], context);
+        contents.Metric = de_Metric(output["Metric"], context);
     }
     if (output["Period"] !== undefined) {
         contents.Period = __strictParseInt32(output["Period"]);
@@ -4596,14 +4596,14 @@ const deserializeAws_queryMetricStat = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_queryMetricStreamEntries = (output, context) => {
+const de_MetricStreamEntries = (output, context) => {
     return (output || [])
         .filter((e) => e != null)
         .map((entry) => {
-        return deserializeAws_queryMetricStreamEntry(entry, context);
+        return de_MetricStreamEntry(entry, context);
     });
 };
-const deserializeAws_queryMetricStreamEntry = (output, context) => {
+const de_MetricStreamEntry = (output, context) => {
     const contents = {};
     if (output["Arn"] !== undefined) {
         contents.Arn = __expectString(output["Arn"]);
@@ -4628,58 +4628,58 @@ const deserializeAws_queryMetricStreamEntry = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_queryMetricStreamFilter = (output, context) => {
+const de_MetricStreamFilter = (output, context) => {
     const contents = {};
     if (output["Namespace"] !== undefined) {
         contents.Namespace = __expectString(output["Namespace"]);
     }
     return contents;
 };
-const deserializeAws_queryMetricStreamFilters = (output, context) => {
+const de_MetricStreamFilters = (output, context) => {
     return (output || [])
         .filter((e) => e != null)
         .map((entry) => {
-        return deserializeAws_queryMetricStreamFilter(entry, context);
+        return de_MetricStreamFilter(entry, context);
     });
 };
-const deserializeAws_queryMetricStreamStatisticsAdditionalStatistics = (output, context) => {
+const de_MetricStreamStatisticsAdditionalStatistics = (output, context) => {
     return (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         return __expectString(entry);
     });
 };
-const deserializeAws_queryMetricStreamStatisticsConfiguration = (output, context) => {
+const de_MetricStreamStatisticsConfiguration = (output, context) => {
     const contents = {};
     if (output.IncludeMetrics === "") {
         contents.IncludeMetrics = [];
     }
     else if (output["IncludeMetrics"] !== undefined && output["IncludeMetrics"]["member"] !== undefined) {
-        contents.IncludeMetrics = deserializeAws_queryMetricStreamStatisticsIncludeMetrics(__getArrayIfSingleItem(output["IncludeMetrics"]["member"]), context);
+        contents.IncludeMetrics = de_MetricStreamStatisticsIncludeMetrics(__getArrayIfSingleItem(output["IncludeMetrics"]["member"]), context);
     }
     if (output.AdditionalStatistics === "") {
         contents.AdditionalStatistics = [];
     }
     else if (output["AdditionalStatistics"] !== undefined && output["AdditionalStatistics"]["member"] !== undefined) {
-        contents.AdditionalStatistics = deserializeAws_queryMetricStreamStatisticsAdditionalStatistics(__getArrayIfSingleItem(output["AdditionalStatistics"]["member"]), context);
+        contents.AdditionalStatistics = de_MetricStreamStatisticsAdditionalStatistics(__getArrayIfSingleItem(output["AdditionalStatistics"]["member"]), context);
     }
     return contents;
 };
-const deserializeAws_queryMetricStreamStatisticsConfigurations = (output, context) => {
+const de_MetricStreamStatisticsConfigurations = (output, context) => {
     return (output || [])
         .filter((e) => e != null)
         .map((entry) => {
-        return deserializeAws_queryMetricStreamStatisticsConfiguration(entry, context);
+        return de_MetricStreamStatisticsConfiguration(entry, context);
     });
 };
-const deserializeAws_queryMetricStreamStatisticsIncludeMetrics = (output, context) => {
+const de_MetricStreamStatisticsIncludeMetrics = (output, context) => {
     return (output || [])
         .filter((e) => e != null)
         .map((entry) => {
-        return deserializeAws_queryMetricStreamStatisticsMetric(entry, context);
+        return de_MetricStreamStatisticsMetric(entry, context);
     });
 };
-const deserializeAws_queryMetricStreamStatisticsMetric = (output, context) => {
+const de_MetricStreamStatisticsMetric = (output, context) => {
     const contents = {};
     if (output["Namespace"] !== undefined) {
         contents.Namespace = __expectString(output["Namespace"]);
@@ -4689,21 +4689,21 @@ const deserializeAws_queryMetricStreamStatisticsMetric = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_queryMissingRequiredParameterException = (output, context) => {
+const de_MissingRequiredParameterException = (output, context) => {
     const contents = {};
     if (output["message"] !== undefined) {
         contents.message = __expectString(output["message"]);
     }
     return contents;
 };
-const deserializeAws_queryOwningAccounts = (output, context) => {
+const de_OwningAccounts = (output, context) => {
     return (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         return __expectString(entry);
     });
 };
-const deserializeAws_queryPartialFailure = (output, context) => {
+const de_PartialFailure = (output, context) => {
     const contents = {};
     if (output["FailureResource"] !== undefined) {
         contents.FailureResource = __expectString(output["FailureResource"]);
@@ -4719,43 +4719,43 @@ const deserializeAws_queryPartialFailure = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_queryPutAnomalyDetectorOutput = (output, context) => {
+const de_PutAnomalyDetectorOutput = (output, context) => {
     const contents = {};
     return contents;
 };
-const deserializeAws_queryPutDashboardOutput = (output, context) => {
+const de_PutDashboardOutput = (output, context) => {
     const contents = {};
     if (output.DashboardValidationMessages === "") {
         contents.DashboardValidationMessages = [];
     }
     else if (output["DashboardValidationMessages"] !== undefined &&
         output["DashboardValidationMessages"]["member"] !== undefined) {
-        contents.DashboardValidationMessages = deserializeAws_queryDashboardValidationMessages(__getArrayIfSingleItem(output["DashboardValidationMessages"]["member"]), context);
+        contents.DashboardValidationMessages = de_DashboardValidationMessages(__getArrayIfSingleItem(output["DashboardValidationMessages"]["member"]), context);
     }
     return contents;
 };
-const deserializeAws_queryPutInsightRuleOutput = (output, context) => {
+const de_PutInsightRuleOutput = (output, context) => {
     const contents = {};
     return contents;
 };
-const deserializeAws_queryPutManagedInsightRulesOutput = (output, context) => {
+const de_PutManagedInsightRulesOutput = (output, context) => {
     const contents = {};
     if (output.Failures === "") {
         contents.Failures = [];
     }
     else if (output["Failures"] !== undefined && output["Failures"]["member"] !== undefined) {
-        contents.Failures = deserializeAws_queryBatchFailures(__getArrayIfSingleItem(output["Failures"]["member"]), context);
+        contents.Failures = de_BatchFailures(__getArrayIfSingleItem(output["Failures"]["member"]), context);
     }
     return contents;
 };
-const deserializeAws_queryPutMetricStreamOutput = (output, context) => {
+const de_PutMetricStreamOutput = (output, context) => {
     const contents = {};
     if (output["Arn"] !== undefined) {
         contents.Arn = __expectString(output["Arn"]);
     }
     return contents;
 };
-const deserializeAws_queryRange = (output, context) => {
+const de_Range = (output, context) => {
     const contents = {};
     if (output["StartTime"] !== undefined) {
         contents.StartTime = __expectNonNull(__parseRfc3339DateTimeWithOffset(output["StartTime"]));
@@ -4765,21 +4765,21 @@ const deserializeAws_queryRange = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_queryResourceList = (output, context) => {
+const de_ResourceList = (output, context) => {
     return (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         return __expectString(entry);
     });
 };
-const deserializeAws_queryResourceNotFound = (output, context) => {
+const de_ResourceNotFound = (output, context) => {
     const contents = {};
     if (output["message"] !== undefined) {
         contents.message = __expectString(output["message"]);
     }
     return contents;
 };
-const deserializeAws_queryResourceNotFoundException = (output, context) => {
+const de_ResourceNotFoundException = (output, context) => {
     const contents = {};
     if (output["ResourceType"] !== undefined) {
         contents.ResourceType = __expectString(output["ResourceType"]);
@@ -4792,7 +4792,7 @@ const deserializeAws_queryResourceNotFoundException = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_querySingleMetricAnomalyDetector = (output, context) => {
+const de_SingleMetricAnomalyDetector = (output, context) => {
     const contents = {};
     if (output["Namespace"] !== undefined) {
         contents.Namespace = __expectString(output["Namespace"]);
@@ -4804,22 +4804,22 @@ const deserializeAws_querySingleMetricAnomalyDetector = (output, context) => {
         contents.Dimensions = [];
     }
     else if (output["Dimensions"] !== undefined && output["Dimensions"]["member"] !== undefined) {
-        contents.Dimensions = deserializeAws_queryDimensions(__getArrayIfSingleItem(output["Dimensions"]["member"]), context);
+        contents.Dimensions = de_Dimensions(__getArrayIfSingleItem(output["Dimensions"]["member"]), context);
     }
     if (output["Stat"] !== undefined) {
         contents.Stat = __expectString(output["Stat"]);
     }
     return contents;
 };
-const deserializeAws_queryStartMetricStreamsOutput = (output, context) => {
+const de_StartMetricStreamsOutput = (output, context) => {
     const contents = {};
     return contents;
 };
-const deserializeAws_queryStopMetricStreamsOutput = (output, context) => {
+const de_StopMetricStreamsOutput = (output, context) => {
     const contents = {};
     return contents;
 };
-const deserializeAws_queryTag = (output, context) => {
+const de_Tag = (output, context) => {
     const contents = {};
     if (output["Key"] !== undefined) {
         contents.Key = __expectString(output["Key"]);
@@ -4829,25 +4829,25 @@ const deserializeAws_queryTag = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_queryTagList = (output, context) => {
+const de_TagList = (output, context) => {
     return (output || [])
         .filter((e) => e != null)
         .map((entry) => {
-        return deserializeAws_queryTag(entry, context);
+        return de_Tag(entry, context);
     });
 };
-const deserializeAws_queryTagResourceOutput = (output, context) => {
+const de_TagResourceOutput = (output, context) => {
     const contents = {};
     return contents;
 };
-const deserializeAws_queryTimestamps = (output, context) => {
+const de_Timestamps = (output, context) => {
     return (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         return __expectNonNull(__parseRfc3339DateTimeWithOffset(entry));
     });
 };
-const deserializeAws_queryUntagResourceOutput = (output, context) => {
+const de_UntagResourceOutput = (output, context) => {
     const contents = {};
     return contents;
 };