@aws-sdk/client-iot-events 3.303.0 → 3.309.0

package/dist-es/protocols/Aws_restJson1.js

@@ -2,7 +2,7 @@ import { HttpRequest as __HttpRequest } from "@aws-sdk/protocol-http";
 import { decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectInt32 as __expectInt32, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectObject as __expectObject, expectString as __expectString, map as __map, parseEpochTimestamp as __parseEpochTimestamp, resolvedPath as __resolvedPath, throwDefaultError, } from "@aws-sdk/smithy-client";
 import { IoTEventsServiceException as __BaseException } from "../models/IoTEventsServiceException";
 import { InternalFailureException, InvalidRequestException, LimitExceededException, ResourceAlreadyExistsException, ResourceInUseException, ResourceNotFoundException, ServiceUnavailableException, ThrottlingException, UnsupportedOperationException, } from "../models/models_0";
-export const serializeAws_restJson1CreateAlarmModelCommand = async (input, context) => {
+export const se_CreateAlarmModelCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -11,21 +11,21 @@ export const serializeAws_restJson1CreateAlarmModelCommand = async (input, conte
     let body;
     body = JSON.stringify({
         ...(input.alarmCapabilities != null && {
-            alarmCapabilities: serializeAws_restJson1AlarmCapabilities(input.alarmCapabilities, context),
+            alarmCapabilities: se_AlarmCapabilities(input.alarmCapabilities, context),
         }),
         ...(input.alarmEventActions != null && {
-            alarmEventActions: serializeAws_restJson1AlarmEventActions(input.alarmEventActions, context),
+            alarmEventActions: se_AlarmEventActions(input.alarmEventActions, context),
         }),
         ...(input.alarmModelDescription != null && { alarmModelDescription: input.alarmModelDescription }),
         ...(input.alarmModelName != null && { alarmModelName: input.alarmModelName }),
         ...(input.alarmNotification != null && {
-            alarmNotification: serializeAws_restJson1AlarmNotification(input.alarmNotification, context),
+            alarmNotification: se_AlarmNotification(input.alarmNotification, context),
         }),
-        ...(input.alarmRule != null && { alarmRule: serializeAws_restJson1AlarmRule(input.alarmRule, context) }),
+        ...(input.alarmRule != null && { alarmRule: se_AlarmRule(input.alarmRule, context) }),
         ...(input.key != null && { key: input.key }),
         ...(input.roleArn != null && { roleArn: input.roleArn }),
         ...(input.severity != null && { severity: input.severity }),
-        ...(input.tags != null && { tags: serializeAws_restJson1Tags(input.tags, context) }),
+        ...(input.tags != null && { tags: se_Tags(input.tags, context) }),
     });
     return new __HttpRequest({
         protocol,
@@ -37,7 +37,7 @@ export const serializeAws_restJson1CreateAlarmModelCommand = async (input, conte
         body,
     });
 };
-export const serializeAws_restJson1CreateDetectorModelCommand = async (input, context) => {
+export const se_CreateDetectorModelCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -46,14 +46,14 @@ export const serializeAws_restJson1CreateDetectorModelCommand = async (input, co
     let body;
     body = JSON.stringify({
         ...(input.detectorModelDefinition != null && {
-            detectorModelDefinition: serializeAws_restJson1DetectorModelDefinition(input.detectorModelDefinition, context),
+            detectorModelDefinition: se_DetectorModelDefinition(input.detectorModelDefinition, context),
         }),
         ...(input.detectorModelDescription != null && { detectorModelDescription: input.detectorModelDescription }),
         ...(input.detectorModelName != null && { detectorModelName: input.detectorModelName }),
         ...(input.evaluationMethod != null && { evaluationMethod: input.evaluationMethod }),
         ...(input.key != null && { key: input.key }),
         ...(input.roleArn != null && { roleArn: input.roleArn }),
-        ...(input.tags != null && { tags: serializeAws_restJson1Tags(input.tags, context) }),
+        ...(input.tags != null && { tags: se_Tags(input.tags, context) }),
     });
     return new __HttpRequest({
         protocol,
@@ -65,7 +65,7 @@ export const serializeAws_restJson1CreateDetectorModelCommand = async (input, co
         body,
     });
 };
-export const serializeAws_restJson1CreateInputCommand = async (input, context) => {
+export const se_CreateInputCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -73,12 +73,10 @@ export const serializeAws_restJson1CreateInputCommand = async (input, context) =
     const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/inputs";
     let body;
     body = JSON.stringify({
-        ...(input.inputDefinition != null && {
-            inputDefinition: serializeAws_restJson1InputDefinition(input.inputDefinition, context),
-        }),
+        ...(input.inputDefinition != null && { inputDefinition: se_InputDefinition(input.inputDefinition, context) }),
         ...(input.inputDescription != null && { inputDescription: input.inputDescription }),
         ...(input.inputName != null && { inputName: input.inputName }),
-        ...(input.tags != null && { tags: serializeAws_restJson1Tags(input.tags, context) }),
+        ...(input.tags != null && { tags: se_Tags(input.tags, context) }),
     });
     return new __HttpRequest({
         protocol,
@@ -90,7 +88,7 @@ export const serializeAws_restJson1CreateInputCommand = async (input, context) =
         body,
     });
 };
-export const serializeAws_restJson1DeleteAlarmModelCommand = async (input, context) => {
+export const se_DeleteAlarmModelCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/alarm-models/{alarmModelName}";
@@ -106,7 +104,7 @@ export const serializeAws_restJson1DeleteAlarmModelCommand = async (input, conte
         body,
     });
 };
-export const serializeAws_restJson1DeleteDetectorModelCommand = async (input, context) => {
+export const se_DeleteDetectorModelCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/detector-models/{detectorModelName}";
@@ -122,7 +120,7 @@ export const serializeAws_restJson1DeleteDetectorModelCommand = async (input, co
         body,
     });
 };
-export const serializeAws_restJson1DeleteInputCommand = async (input, context) => {
+export const se_DeleteInputCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/inputs/{inputName}";
@@ -138,7 +136,7 @@ export const serializeAws_restJson1DeleteInputCommand = async (input, context) =
         body,
     });
 };
-export const serializeAws_restJson1DescribeAlarmModelCommand = async (input, context) => {
+export const se_DescribeAlarmModelCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/alarm-models/{alarmModelName}";
@@ -158,7 +156,7 @@ export const serializeAws_restJson1DescribeAlarmModelCommand = async (input, con
         body,
     });
 };
-export const serializeAws_restJson1DescribeDetectorModelCommand = async (input, context) => {
+export const se_DescribeDetectorModelCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/detector-models/{detectorModelName}";
@@ -178,7 +176,7 @@ export const serializeAws_restJson1DescribeDetectorModelCommand = async (input,
         body,
     });
 };
-export const serializeAws_restJson1DescribeDetectorModelAnalysisCommand = async (input, context) => {
+export const se_DescribeDetectorModelAnalysisCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/analysis/detector-models/{analysisId}";
@@ -194,7 +192,7 @@ export const serializeAws_restJson1DescribeDetectorModelAnalysisCommand = async
         body,
     });
 };
-export const serializeAws_restJson1DescribeInputCommand = async (input, context) => {
+export const se_DescribeInputCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/inputs/{inputName}";
@@ -210,7 +208,7 @@ export const serializeAws_restJson1DescribeInputCommand = async (input, context)
         body,
     });
 };
-export const serializeAws_restJson1DescribeLoggingOptionsCommand = async (input, context) => {
+export const se_DescribeLoggingOptionsCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -228,7 +226,7 @@ export const serializeAws_restJson1DescribeLoggingOptionsCommand = async (input,
         body,
     });
 };
-export const serializeAws_restJson1GetDetectorModelAnalysisResultsCommand = async (input, context) => {
+export const se_GetDetectorModelAnalysisResultsCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
@@ -250,7 +248,7 @@ export const serializeAws_restJson1GetDetectorModelAnalysisResultsCommand = asyn
         body,
     });
 };
-export const serializeAws_restJson1ListAlarmModelsCommand = async (input, context) => {
+export const se_ListAlarmModelsCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/alarm-models";
@@ -270,7 +268,7 @@ export const serializeAws_restJson1ListAlarmModelsCommand = async (input, contex
         body,
     });
 };
-export const serializeAws_restJson1ListAlarmModelVersionsCommand = async (input, context) => {
+export const se_ListAlarmModelVersionsCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/alarm-models/{alarmModelName}/versions";
@@ -291,7 +289,7 @@ export const serializeAws_restJson1ListAlarmModelVersionsCommand = async (input,
         body,
     });
 };
-export const serializeAws_restJson1ListDetectorModelsCommand = async (input, context) => {
+export const se_ListDetectorModelsCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/detector-models";
@@ -311,7 +309,7 @@ export const serializeAws_restJson1ListDetectorModelsCommand = async (input, con
         body,
     });
 };
-export const serializeAws_restJson1ListDetectorModelVersionsCommand = async (input, context) => {
+export const se_ListDetectorModelVersionsCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
@@ -333,7 +331,7 @@ export const serializeAws_restJson1ListDetectorModelVersionsCommand = async (inp
         body,
     });
 };
-export const serializeAws_restJson1ListInputRoutingsCommand = async (input, context) => {
+export const se_ListInputRoutingsCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -341,9 +339,7 @@ export const serializeAws_restJson1ListInputRoutingsCommand = async (input, cont
     const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/input-routings";
     let body;
     body = JSON.stringify({
-        ...(input.inputIdentifier != null && {
-            inputIdentifier: serializeAws_restJson1InputIdentifier(input.inputIdentifier, context),
-        }),
+        ...(input.inputIdentifier != null && { inputIdentifier: se_InputIdentifier(input.inputIdentifier, context) }),
         ...(input.maxResults != null && { maxResults: input.maxResults }),
         ...(input.nextToken != null && { nextToken: input.nextToken }),
     });
@@ -357,7 +353,7 @@ export const serializeAws_restJson1ListInputRoutingsCommand = async (input, cont
         body,
     });
 };
-export const serializeAws_restJson1ListInputsCommand = async (input, context) => {
+export const se_ListInputsCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/inputs";
@@ -377,7 +373,7 @@ export const serializeAws_restJson1ListInputsCommand = async (input, context) =>
         body,
     });
 };
-export const serializeAws_restJson1ListTagsForResourceCommand = async (input, context) => {
+export const se_ListTagsForResourceCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags";
@@ -396,7 +392,7 @@ export const serializeAws_restJson1ListTagsForResourceCommand = async (input, co
         body,
     });
 };
-export const serializeAws_restJson1PutLoggingOptionsCommand = async (input, context) => {
+export const se_PutLoggingOptionsCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -404,9 +400,7 @@ export const serializeAws_restJson1PutLoggingOptionsCommand = async (input, cont
     const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/logging";
     let body;
     body = JSON.stringify({
-        ...(input.loggingOptions != null && {
-            loggingOptions: serializeAws_restJson1LoggingOptions(input.loggingOptions, context),
-        }),
+        ...(input.loggingOptions != null && { loggingOptions: se_LoggingOptions(input.loggingOptions, context) }),
     });
     return new __HttpRequest({
         protocol,
@@ -418,7 +412,7 @@ export const serializeAws_restJson1PutLoggingOptionsCommand = async (input, cont
         body,
     });
 };
-export const serializeAws_restJson1StartDetectorModelAnalysisCommand = async (input, context) => {
+export const se_StartDetectorModelAnalysisCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -427,7 +421,7 @@ export const serializeAws_restJson1StartDetectorModelAnalysisCommand = async (in
     let body;
     body = JSON.stringify({
         ...(input.detectorModelDefinition != null && {
-            detectorModelDefinition: serializeAws_restJson1DetectorModelDefinition(input.detectorModelDefinition, context),
+            detectorModelDefinition: se_DetectorModelDefinition(input.detectorModelDefinition, context),
         }),
     });
     return new __HttpRequest({
@@ -440,7 +434,7 @@ export const serializeAws_restJson1StartDetectorModelAnalysisCommand = async (in
         body,
     });
 };
-export const serializeAws_restJson1TagResourceCommand = async (input, context) => {
+export const se_TagResourceCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -451,7 +445,7 @@ export const serializeAws_restJson1TagResourceCommand = async (input, context) =
     });
     let body;
     body = JSON.stringify({
-        ...(input.tags != null && { tags: serializeAws_restJson1Tags(input.tags, context) }),
+        ...(input.tags != null && { tags: se_Tags(input.tags, context) }),
     });
     return new __HttpRequest({
         protocol,
@@ -464,7 +458,7 @@ export const serializeAws_restJson1TagResourceCommand = async (input, context) =
         body,
     });
 };
-export const serializeAws_restJson1UntagResourceCommand = async (input, context) => {
+export const se_UntagResourceCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags";
@@ -487,7 +481,7 @@ export const serializeAws_restJson1UntagResourceCommand = async (input, context)
         body,
     });
 };
-export const serializeAws_restJson1UpdateAlarmModelCommand = async (input, context) => {
+export const se_UpdateAlarmModelCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -497,16 +491,16 @@ export const serializeAws_restJson1UpdateAlarmModelCommand = async (input, conte
     let body;
     body = JSON.stringify({
         ...(input.alarmCapabilities != null && {
-            alarmCapabilities: serializeAws_restJson1AlarmCapabilities(input.alarmCapabilities, context),
+            alarmCapabilities: se_AlarmCapabilities(input.alarmCapabilities, context),
         }),
         ...(input.alarmEventActions != null && {
-            alarmEventActions: serializeAws_restJson1AlarmEventActions(input.alarmEventActions, context),
+            alarmEventActions: se_AlarmEventActions(input.alarmEventActions, context),
         }),
         ...(input.alarmModelDescription != null && { alarmModelDescription: input.alarmModelDescription }),
         ...(input.alarmNotification != null && {
-            alarmNotification: serializeAws_restJson1AlarmNotification(input.alarmNotification, context),
+            alarmNotification: se_AlarmNotification(input.alarmNotification, context),
         }),
-        ...(input.alarmRule != null && { alarmRule: serializeAws_restJson1AlarmRule(input.alarmRule, context) }),
+        ...(input.alarmRule != null && { alarmRule: se_AlarmRule(input.alarmRule, context) }),
         ...(input.roleArn != null && { roleArn: input.roleArn }),
         ...(input.severity != null && { severity: input.severity }),
     });
@@ -520,7 +514,7 @@ export const serializeAws_restJson1UpdateAlarmModelCommand = async (input, conte
         body,
     });
 };
-export const serializeAws_restJson1UpdateDetectorModelCommand = async (input, context) => {
+export const se_UpdateDetectorModelCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -530,7 +524,7 @@ export const serializeAws_restJson1UpdateDetectorModelCommand = async (input, co
     let body;
     body = JSON.stringify({
         ...(input.detectorModelDefinition != null && {
-            detectorModelDefinition: serializeAws_restJson1DetectorModelDefinition(input.detectorModelDefinition, context),
+            detectorModelDefinition: se_DetectorModelDefinition(input.detectorModelDefinition, context),
         }),
         ...(input.detectorModelDescription != null && { detectorModelDescription: input.detectorModelDescription }),
         ...(input.evaluationMethod != null && { evaluationMethod: input.evaluationMethod }),
@@ -546,7 +540,7 @@ export const serializeAws_restJson1UpdateDetectorModelCommand = async (input, co
         body,
     });
 };
-export const serializeAws_restJson1UpdateInputCommand = async (input, context) => {
+export const se_UpdateInputCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -555,9 +549,7 @@ export const serializeAws_restJson1UpdateInputCommand = async (input, context) =
     resolvedPath = __resolvedPath(resolvedPath, input, "inputName", () => input.inputName, "{inputName}", false);
     let body;
     body = JSON.stringify({
-        ...(input.inputDefinition != null && {
-            inputDefinition: serializeAws_restJson1InputDefinition(input.inputDefinition, context),
-        }),
+        ...(input.inputDefinition != null && { inputDefinition: se_InputDefinition(input.inputDefinition, context) }),
         ...(input.inputDescription != null && { inputDescription: input.inputDescription }),
     });
     return new __HttpRequest({
@@ -570,9 +562,9 @@ export const serializeAws_restJson1UpdateInputCommand = async (input, context) =
         body,
     });
 };
-export const deserializeAws_restJson1CreateAlarmModelCommand = async (output, context) => {
+export const de_CreateAlarmModelCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1CreateAlarmModelCommandError(output, context);
+        return de_CreateAlarmModelCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -595,7 +587,7 @@ export const deserializeAws_restJson1CreateAlarmModelCommand = async (output, co
     }
     return contents;
 };
-const deserializeAws_restJson1CreateAlarmModelCommandError = async (output, context) => {
+const de_CreateAlarmModelCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -604,25 +596,25 @@ const deserializeAws_restJson1CreateAlarmModelCommandError = async (output, cont
     switch (errorCode) {
         case "InternalFailureException":
         case "com.amazonaws.iotevents#InternalFailureException":
-            throw await deserializeAws_restJson1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "InvalidRequestException":
         case "com.amazonaws.iotevents#InvalidRequestException":
-            throw await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context);
+            throw await de_InvalidRequestExceptionRes(parsedOutput, context);
         case "LimitExceededException":
         case "com.amazonaws.iotevents#LimitExceededException":
-            throw await deserializeAws_restJson1LimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         case "ResourceAlreadyExistsException":
         case "com.amazonaws.iotevents#ResourceAlreadyExistsException":
-            throw await deserializeAws_restJson1ResourceAlreadyExistsExceptionResponse(parsedOutput, context);
+            throw await de_ResourceAlreadyExistsExceptionRes(parsedOutput, context);
         case "ResourceInUseException":
         case "com.amazonaws.iotevents#ResourceInUseException":
-            throw await deserializeAws_restJson1ResourceInUseExceptionResponse(parsedOutput, context);
+            throw await de_ResourceInUseExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.iotevents#ServiceUnavailableException":
-            throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.iotevents#ThrottlingException":
-            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -633,20 +625,20 @@ const deserializeAws_restJson1CreateAlarmModelCommandError = async (output, cont
             });
     }
 };
-export const deserializeAws_restJson1CreateDetectorModelCommand = async (output, context) => {
+export const de_CreateDetectorModelCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1CreateDetectorModelCommandError(output, context);
+        return de_CreateDetectorModelCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.detectorModelConfiguration != null) {
-        contents.detectorModelConfiguration = deserializeAws_restJson1DetectorModelConfiguration(data.detectorModelConfiguration, context);
+        contents.detectorModelConfiguration = de_DetectorModelConfiguration(data.detectorModelConfiguration, context);
     }
     return contents;
 };
-const deserializeAws_restJson1CreateDetectorModelCommandError = async (output, context) => {
+const de_CreateDetectorModelCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -655,25 +647,25 @@ const deserializeAws_restJson1CreateDetectorModelCommandError = async (output, c
     switch (errorCode) {
         case "InternalFailureException":
         case "com.amazonaws.iotevents#InternalFailureException":
-            throw await deserializeAws_restJson1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "InvalidRequestException":
         case "com.amazonaws.iotevents#InvalidRequestException":
-            throw await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context);
+            throw await de_InvalidRequestExceptionRes(parsedOutput, context);
         case "LimitExceededException":
         case "com.amazonaws.iotevents#LimitExceededException":
-            throw await deserializeAws_restJson1LimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         case "ResourceAlreadyExistsException":
         case "com.amazonaws.iotevents#ResourceAlreadyExistsException":
-            throw await deserializeAws_restJson1ResourceAlreadyExistsExceptionResponse(parsedOutput, context);
+            throw await de_ResourceAlreadyExistsExceptionRes(parsedOutput, context);
         case "ResourceInUseException":
         case "com.amazonaws.iotevents#ResourceInUseException":
-            throw await deserializeAws_restJson1ResourceInUseExceptionResponse(parsedOutput, context);
+            throw await de_ResourceInUseExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.iotevents#ServiceUnavailableException":
-            throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.iotevents#ThrottlingException":
-            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -684,20 +676,20 @@ const deserializeAws_restJson1CreateDetectorModelCommandError = async (output, c
             });
     }
 };
-export const deserializeAws_restJson1CreateInputCommand = async (output, context) => {
+export const de_CreateInputCommand = async (output, context) => {
     if (output.statusCode !== 201 && output.statusCode >= 300) {
-        return deserializeAws_restJson1CreateInputCommandError(output, context);
+        return de_CreateInputCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.inputConfiguration != null) {
-        contents.inputConfiguration = deserializeAws_restJson1InputConfiguration(data.inputConfiguration, context);
+        contents.inputConfiguration = de_InputConfiguration(data.inputConfiguration, context);
     }
     return contents;
 };
-const deserializeAws_restJson1CreateInputCommandError = async (output, context) => {
+const de_CreateInputCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -706,19 +698,19 @@ const deserializeAws_restJson1CreateInputCommandError = async (output, context)
     switch (errorCode) {
         case "InternalFailureException":
         case "com.amazonaws.iotevents#InternalFailureException":
-            throw await deserializeAws_restJson1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "InvalidRequestException":
         case "com.amazonaws.iotevents#InvalidRequestException":
-            throw await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context);
+            throw await de_InvalidRequestExceptionRes(parsedOutput, context);
         case "ResourceAlreadyExistsException":
         case "com.amazonaws.iotevents#ResourceAlreadyExistsException":
-            throw await deserializeAws_restJson1ResourceAlreadyExistsExceptionResponse(parsedOutput, context);
+            throw await de_ResourceAlreadyExistsExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.iotevents#ServiceUnavailableException":
-            throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.iotevents#ThrottlingException":
-            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -729,9 +721,9 @@ const deserializeAws_restJson1CreateInputCommandError = async (output, context)
             });
     }
 };
-export const deserializeAws_restJson1DeleteAlarmModelCommand = async (output, context) => {
+export const de_DeleteAlarmModelCommand = async (output, context) => {
     if (output.statusCode !== 204 && output.statusCode >= 300) {
-        return deserializeAws_restJson1DeleteAlarmModelCommandError(output, context);
+        return de_DeleteAlarmModelCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -739,7 +731,7 @@ export const deserializeAws_restJson1DeleteAlarmModelCommand = async (output, co
     await collectBody(output.body, context);
     return contents;
 };
-const deserializeAws_restJson1DeleteAlarmModelCommandError = async (output, context) => {
+const de_DeleteAlarmModelCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -748,22 +740,22 @@ const deserializeAws_restJson1DeleteAlarmModelCommandError = async (output, cont
     switch (errorCode) {
         case "InternalFailureException":
         case "com.amazonaws.iotevents#InternalFailureException":
-            throw await deserializeAws_restJson1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "InvalidRequestException":
         case "com.amazonaws.iotevents#InvalidRequestException":
-            throw await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context);
+            throw await de_InvalidRequestExceptionRes(parsedOutput, context);
         case "ResourceInUseException":
         case "com.amazonaws.iotevents#ResourceInUseException":
-            throw await deserializeAws_restJson1ResourceInUseExceptionResponse(parsedOutput, context);
+            throw await de_ResourceInUseExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.iotevents#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.iotevents#ServiceUnavailableException":
-            throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.iotevents#ThrottlingException":
-            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -774,9 +766,9 @@ const deserializeAws_restJson1DeleteAlarmModelCommandError = async (output, cont
             });
     }
 };
-export const deserializeAws_restJson1DeleteDetectorModelCommand = async (output, context) => {
+export const de_DeleteDetectorModelCommand = async (output, context) => {
     if (output.statusCode !== 204 && output.statusCode >= 300) {
-        return deserializeAws_restJson1DeleteDetectorModelCommandError(output, context);
+        return de_DeleteDetectorModelCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -784,7 +776,7 @@ export const deserializeAws_restJson1DeleteDetectorModelCommand = async (output,
     await collectBody(output.body, context);
     return contents;
 };
-const deserializeAws_restJson1DeleteDetectorModelCommandError = async (output, context) => {
+const de_DeleteDetectorModelCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -793,22 +785,22 @@ const deserializeAws_restJson1DeleteDetectorModelCommandError = async (output, c
     switch (errorCode) {
         case "InternalFailureException":
         case "com.amazonaws.iotevents#InternalFailureException":
-            throw await deserializeAws_restJson1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "InvalidRequestException":
         case "com.amazonaws.iotevents#InvalidRequestException":
-            throw await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context);
+            throw await de_InvalidRequestExceptionRes(parsedOutput, context);
         case "ResourceInUseException":
         case "com.amazonaws.iotevents#ResourceInUseException":
-            throw await deserializeAws_restJson1ResourceInUseExceptionResponse(parsedOutput, context);
+            throw await de_ResourceInUseExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.iotevents#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.iotevents#ServiceUnavailableException":
-            throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.iotevents#ThrottlingException":
-            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -819,9 +811,9 @@ const deserializeAws_restJson1DeleteDetectorModelCommandError = async (output, c
             });
     }
 };
-export const deserializeAws_restJson1DeleteInputCommand = async (output, context) => {
+export const de_DeleteInputCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1DeleteInputCommandError(output, context);
+        return de_DeleteInputCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -829,7 +821,7 @@ export const deserializeAws_restJson1DeleteInputCommand = async (output, context
     await collectBody(output.body, context);
     return contents;
 };
-const deserializeAws_restJson1DeleteInputCommandError = async (output, context) => {
+const de_DeleteInputCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -838,22 +830,22 @@ const deserializeAws_restJson1DeleteInputCommandError = async (output, context)
     switch (errorCode) {
         case "InternalFailureException":
         case "com.amazonaws.iotevents#InternalFailureException":
-            throw await deserializeAws_restJson1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "InvalidRequestException":
         case "com.amazonaws.iotevents#InvalidRequestException":
-            throw await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context);
+            throw await de_InvalidRequestExceptionRes(parsedOutput, context);
         case "ResourceInUseException":
         case "com.amazonaws.iotevents#ResourceInUseException":
-            throw await deserializeAws_restJson1ResourceInUseExceptionResponse(parsedOutput, context);
+            throw await de_ResourceInUseExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.iotevents#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.iotevents#ServiceUnavailableException":
-            throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.iotevents#ThrottlingException":
-            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -864,19 +856,19 @@ const deserializeAws_restJson1DeleteInputCommandError = async (output, context)
             });
     }
 };
-export const deserializeAws_restJson1DescribeAlarmModelCommand = async (output, context) => {
+export const de_DescribeAlarmModelCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1DescribeAlarmModelCommandError(output, context);
+        return de_DescribeAlarmModelCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.alarmCapabilities != null) {
-        contents.alarmCapabilities = deserializeAws_restJson1AlarmCapabilities(data.alarmCapabilities, context);
+        contents.alarmCapabilities = de_AlarmCapabilities(data.alarmCapabilities, context);
     }
     if (data.alarmEventActions != null) {
-        contents.alarmEventActions = deserializeAws_restJson1AlarmEventActions(data.alarmEventActions, context);
+        contents.alarmEventActions = de_AlarmEventActions(data.alarmEventActions, context);
     }
     if (data.alarmModelArn != null) {
         contents.alarmModelArn = __expectString(data.alarmModelArn);
@@ -891,10 +883,10 @@ export const deserializeAws_restJson1DescribeAlarmModelCommand = async (output,
         contents.alarmModelVersion = __expectString(data.alarmModelVersion);
     }
     if (data.alarmNotification != null) {
-        contents.alarmNotification = deserializeAws_restJson1AlarmNotification(data.alarmNotification, context);
+        contents.alarmNotification = de_AlarmNotification(data.alarmNotification, context);
     }
     if (data.alarmRule != null) {
-        contents.alarmRule = deserializeAws_restJson1AlarmRule(data.alarmRule, context);
+        contents.alarmRule = de_AlarmRule(data.alarmRule, context);
     }
     if (data.creationTime != null) {
         contents.creationTime = __expectNonNull(__parseEpochTimestamp(__expectNumber(data.creationTime)));
@@ -919,7 +911,7 @@ export const deserializeAws_restJson1DescribeAlarmModelCommand = async (output,
     }
     return contents;
 };
-const deserializeAws_restJson1DescribeAlarmModelCommandError = async (output, context) => {
+const de_DescribeAlarmModelCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -928,19 +920,19 @@ const deserializeAws_restJson1DescribeAlarmModelCommandError = async (output, co
     switch (errorCode) {
         case "InternalFailureException":
         case "com.amazonaws.iotevents#InternalFailureException":
-            throw await deserializeAws_restJson1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "InvalidRequestException":
         case "com.amazonaws.iotevents#InvalidRequestException":
-            throw await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context);
+            throw await de_InvalidRequestExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.iotevents#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.iotevents#ServiceUnavailableException":
-            throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.iotevents#ThrottlingException":
-            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -951,20 +943,20 @@ const deserializeAws_restJson1DescribeAlarmModelCommandError = async (output, co
             });
     }
 };
-export const deserializeAws_restJson1DescribeDetectorModelCommand = async (output, context) => {
+export const de_DescribeDetectorModelCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1DescribeDetectorModelCommandError(output, context);
+        return de_DescribeDetectorModelCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.detectorModel != null) {
-        contents.detectorModel = deserializeAws_restJson1DetectorModel(data.detectorModel, context);
+        contents.detectorModel = de_DetectorModel(data.detectorModel, context);
     }
     return contents;
 };
-const deserializeAws_restJson1DescribeDetectorModelCommandError = async (output, context) => {
+const de_DescribeDetectorModelCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -973,19 +965,19 @@ const deserializeAws_restJson1DescribeDetectorModelCommandError = async (output,
     switch (errorCode) {
         case "InternalFailureException":
         case "com.amazonaws.iotevents#InternalFailureException":
-            throw await deserializeAws_restJson1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "InvalidRequestException":
         case "com.amazonaws.iotevents#InvalidRequestException":
-            throw await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context);
+            throw await de_InvalidRequestExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.iotevents#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.iotevents#ServiceUnavailableException":
-            throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.iotevents#ThrottlingException":
-            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -996,9 +988,9 @@ const deserializeAws_restJson1DescribeDetectorModelCommandError = async (output,
             });
     }
 };
-export const deserializeAws_restJson1DescribeDetectorModelAnalysisCommand = async (output, context) => {
+export const de_DescribeDetectorModelAnalysisCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1DescribeDetectorModelAnalysisCommandError(output, context);
+        return de_DescribeDetectorModelAnalysisCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1009,7 +1001,7 @@ export const deserializeAws_restJson1DescribeDetectorModelAnalysisCommand = asyn
     }
     return contents;
 };
-const deserializeAws_restJson1DescribeDetectorModelAnalysisCommandError = async (output, context) => {
+const de_DescribeDetectorModelAnalysisCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1018,19 +1010,19 @@ const deserializeAws_restJson1DescribeDetectorModelAnalysisCommandError = async
     switch (errorCode) {
         case "InternalFailureException":
         case "com.amazonaws.iotevents#InternalFailureException":
-            throw await deserializeAws_restJson1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "InvalidRequestException":
         case "com.amazonaws.iotevents#InvalidRequestException":
-            throw await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context);
+            throw await de_InvalidRequestExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.iotevents#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.iotevents#ServiceUnavailableException":
-            throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.iotevents#ThrottlingException":
-            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1041,20 +1033,20 @@ const deserializeAws_restJson1DescribeDetectorModelAnalysisCommandError = async
             });
     }
 };
-export const deserializeAws_restJson1DescribeInputCommand = async (output, context) => {
+export const de_DescribeInputCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1DescribeInputCommandError(output, context);
+        return de_DescribeInputCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.input != null) {
-        contents.input = deserializeAws_restJson1Input(data.input, context);
+        contents.input = de_Input(data.input, context);
     }
     return contents;
 };
-const deserializeAws_restJson1DescribeInputCommandError = async (output, context) => {
+const de_DescribeInputCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1063,19 +1055,19 @@ const deserializeAws_restJson1DescribeInputCommandError = async (output, context
     switch (errorCode) {
         case "InternalFailureException":
         case "com.amazonaws.iotevents#InternalFailureException":
-            throw await deserializeAws_restJson1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "InvalidRequestException":
         case "com.amazonaws.iotevents#InvalidRequestException":
-            throw await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context);
+            throw await de_InvalidRequestExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.iotevents#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.iotevents#ServiceUnavailableException":
-            throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.iotevents#ThrottlingException":
-            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1086,20 +1078,20 @@ const deserializeAws_restJson1DescribeInputCommandError = async (output, context
             });
     }
 };
-export const deserializeAws_restJson1DescribeLoggingOptionsCommand = async (output, context) => {
+export const de_DescribeLoggingOptionsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1DescribeLoggingOptionsCommandError(output, context);
+        return de_DescribeLoggingOptionsCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.loggingOptions != null) {
-        contents.loggingOptions = deserializeAws_restJson1LoggingOptions(data.loggingOptions, context);
+        contents.loggingOptions = de_LoggingOptions(data.loggingOptions, context);
     }
     return contents;
 };
-const deserializeAws_restJson1DescribeLoggingOptionsCommandError = async (output, context) => {
+const de_DescribeLoggingOptionsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1108,22 +1100,22 @@ const deserializeAws_restJson1DescribeLoggingOptionsCommandError = async (output
     switch (errorCode) {
         case "InternalFailureException":
         case "com.amazonaws.iotevents#InternalFailureException":
-            throw await deserializeAws_restJson1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "InvalidRequestException":
         case "com.amazonaws.iotevents#InvalidRequestException":
-            throw await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context);
+            throw await de_InvalidRequestExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.iotevents#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.iotevents#ServiceUnavailableException":
-            throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.iotevents#ThrottlingException":
-            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         case "UnsupportedOperationException":
         case "com.amazonaws.iotevents#UnsupportedOperationException":
-            throw await deserializeAws_restJson1UnsupportedOperationExceptionResponse(parsedOutput, context);
+            throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1134,23 +1126,23 @@ const deserializeAws_restJson1DescribeLoggingOptionsCommandError = async (output
             });
     }
 };
-export const deserializeAws_restJson1GetDetectorModelAnalysisResultsCommand = async (output, context) => {
+export const de_GetDetectorModelAnalysisResultsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1GetDetectorModelAnalysisResultsCommandError(output, context);
+        return de_GetDetectorModelAnalysisResultsCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.analysisResults != null) {
-        contents.analysisResults = deserializeAws_restJson1AnalysisResults(data.analysisResults, context);
+        contents.analysisResults = de_AnalysisResults(data.analysisResults, context);
     }
     if (data.nextToken != null) {
         contents.nextToken = __expectString(data.nextToken);
     }
     return contents;
 };
-const deserializeAws_restJson1GetDetectorModelAnalysisResultsCommandError = async (output, context) => {
+const de_GetDetectorModelAnalysisResultsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1159,19 +1151,19 @@ const deserializeAws_restJson1GetDetectorModelAnalysisResultsCommandError = asyn
     switch (errorCode) {
         case "InternalFailureException":
         case "com.amazonaws.iotevents#InternalFailureException":
-            throw await deserializeAws_restJson1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "InvalidRequestException":
         case "com.amazonaws.iotevents#InvalidRequestException":
-            throw await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context);
+            throw await de_InvalidRequestExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.iotevents#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.iotevents#ServiceUnavailableException":
-            throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.iotevents#ThrottlingException":
-            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1182,23 +1174,23 @@ const deserializeAws_restJson1GetDetectorModelAnalysisResultsCommandError = asyn
             });
     }
 };
-export const deserializeAws_restJson1ListAlarmModelsCommand = async (output, context) => {
+export const de_ListAlarmModelsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1ListAlarmModelsCommandError(output, context);
+        return de_ListAlarmModelsCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.alarmModelSummaries != null) {
-        contents.alarmModelSummaries = deserializeAws_restJson1AlarmModelSummaries(data.alarmModelSummaries, context);
+        contents.alarmModelSummaries = de_AlarmModelSummaries(data.alarmModelSummaries, context);
     }
     if (data.nextToken != null) {
         contents.nextToken = __expectString(data.nextToken);
     }
     return contents;
 };
-const deserializeAws_restJson1ListAlarmModelsCommandError = async (output, context) => {
+const de_ListAlarmModelsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1207,16 +1199,16 @@ const deserializeAws_restJson1ListAlarmModelsCommandError = async (output, conte
     switch (errorCode) {
         case "InternalFailureException":
         case "com.amazonaws.iotevents#InternalFailureException":
-            throw await deserializeAws_restJson1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "InvalidRequestException":
         case "com.amazonaws.iotevents#InvalidRequestException":
-            throw await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context);
+            throw await de_InvalidRequestExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.iotevents#ServiceUnavailableException":
-            throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.iotevents#ThrottlingException":
-            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1227,23 +1219,23 @@ const deserializeAws_restJson1ListAlarmModelsCommandError = async (output, conte
             });
     }
 };
-export const deserializeAws_restJson1ListAlarmModelVersionsCommand = async (output, context) => {
+export const de_ListAlarmModelVersionsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1ListAlarmModelVersionsCommandError(output, context);
+        return de_ListAlarmModelVersionsCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.alarmModelVersionSummaries != null) {
-        contents.alarmModelVersionSummaries = deserializeAws_restJson1AlarmModelVersionSummaries(data.alarmModelVersionSummaries, context);
+        contents.alarmModelVersionSummaries = de_AlarmModelVersionSummaries(data.alarmModelVersionSummaries, context);
     }
     if (data.nextToken != null) {
         contents.nextToken = __expectString(data.nextToken);
     }
     return contents;
 };
-const deserializeAws_restJson1ListAlarmModelVersionsCommandError = async (output, context) => {
+const de_ListAlarmModelVersionsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1252,19 +1244,19 @@ const deserializeAws_restJson1ListAlarmModelVersionsCommandError = async (output
     switch (errorCode) {
         case "InternalFailureException":
         case "com.amazonaws.iotevents#InternalFailureException":
-            throw await deserializeAws_restJson1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "InvalidRequestException":
         case "com.amazonaws.iotevents#InvalidRequestException":
-            throw await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context);
+            throw await de_InvalidRequestExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.iotevents#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.iotevents#ServiceUnavailableException":
-            throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.iotevents#ThrottlingException":
-            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1275,23 +1267,23 @@ const deserializeAws_restJson1ListAlarmModelVersionsCommandError = async (output
             });
     }
 };
-export const deserializeAws_restJson1ListDetectorModelsCommand = async (output, context) => {
+export const de_ListDetectorModelsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1ListDetectorModelsCommandError(output, context);
+        return de_ListDetectorModelsCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.detectorModelSummaries != null) {
-        contents.detectorModelSummaries = deserializeAws_restJson1DetectorModelSummaries(data.detectorModelSummaries, context);
+        contents.detectorModelSummaries = de_DetectorModelSummaries(data.detectorModelSummaries, context);
     }
     if (data.nextToken != null) {
         contents.nextToken = __expectString(data.nextToken);
     }
     return contents;
 };
-const deserializeAws_restJson1ListDetectorModelsCommandError = async (output, context) => {
+const de_ListDetectorModelsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1300,16 +1292,16 @@ const deserializeAws_restJson1ListDetectorModelsCommandError = async (output, co
     switch (errorCode) {
         case "InternalFailureException":
         case "com.amazonaws.iotevents#InternalFailureException":
-            throw await deserializeAws_restJson1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "InvalidRequestException":
         case "com.amazonaws.iotevents#InvalidRequestException":
-            throw await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context);
+            throw await de_InvalidRequestExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.iotevents#ServiceUnavailableException":
-            throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.iotevents#ThrottlingException":
-            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1320,23 +1312,23 @@ const deserializeAws_restJson1ListDetectorModelsCommandError = async (output, co
             });
     }
 };
-export const deserializeAws_restJson1ListDetectorModelVersionsCommand = async (output, context) => {
+export const de_ListDetectorModelVersionsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1ListDetectorModelVersionsCommandError(output, context);
+        return de_ListDetectorModelVersionsCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.detectorModelVersionSummaries != null) {
-        contents.detectorModelVersionSummaries = deserializeAws_restJson1DetectorModelVersionSummaries(data.detectorModelVersionSummaries, context);
+        contents.detectorModelVersionSummaries = de_DetectorModelVersionSummaries(data.detectorModelVersionSummaries, context);
     }
     if (data.nextToken != null) {
         contents.nextToken = __expectString(data.nextToken);
     }
     return contents;
 };
-const deserializeAws_restJson1ListDetectorModelVersionsCommandError = async (output, context) => {
+const de_ListDetectorModelVersionsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1345,19 +1337,19 @@ const deserializeAws_restJson1ListDetectorModelVersionsCommandError = async (out
     switch (errorCode) {
         case "InternalFailureException":
         case "com.amazonaws.iotevents#InternalFailureException":
-            throw await deserializeAws_restJson1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "InvalidRequestException":
         case "com.amazonaws.iotevents#InvalidRequestException":
-            throw await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context);
+            throw await de_InvalidRequestExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.iotevents#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.iotevents#ServiceUnavailableException":
-            throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.iotevents#ThrottlingException":
-            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1368,9 +1360,9 @@ const deserializeAws_restJson1ListDetectorModelVersionsCommandError = async (out
             });
     }
 };
-export const deserializeAws_restJson1ListInputRoutingsCommand = async (output, context) => {
+export const de_ListInputRoutingsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1ListInputRoutingsCommandError(output, context);
+        return de_ListInputRoutingsCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1380,11 +1372,11 @@ export const deserializeAws_restJson1ListInputRoutingsCommand = async (output, c
         contents.nextToken = __expectString(data.nextToken);
     }
     if (data.routedResources != null) {
-        contents.routedResources = deserializeAws_restJson1RoutedResources(data.routedResources, context);
+        contents.routedResources = de_RoutedResources(data.routedResources, context);
     }
     return contents;
 };
-const deserializeAws_restJson1ListInputRoutingsCommandError = async (output, context) => {
+const de_ListInputRoutingsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1393,19 +1385,19 @@ const deserializeAws_restJson1ListInputRoutingsCommandError = async (output, con
     switch (errorCode) {
         case "InternalFailureException":
         case "com.amazonaws.iotevents#InternalFailureException":
-            throw await deserializeAws_restJson1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "InvalidRequestException":
         case "com.amazonaws.iotevents#InvalidRequestException":
-            throw await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context);
+            throw await de_InvalidRequestExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.iotevents#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.iotevents#ServiceUnavailableException":
-            throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.iotevents#ThrottlingException":
-            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1416,23 +1408,23 @@ const deserializeAws_restJson1ListInputRoutingsCommandError = async (output, con
             });
     }
 };
-export const deserializeAws_restJson1ListInputsCommand = async (output, context) => {
+export const de_ListInputsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1ListInputsCommandError(output, context);
+        return de_ListInputsCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.inputSummaries != null) {
-        contents.inputSummaries = deserializeAws_restJson1InputSummaries(data.inputSummaries, context);
+        contents.inputSummaries = de_InputSummaries(data.inputSummaries, context);
     }
     if (data.nextToken != null) {
         contents.nextToken = __expectString(data.nextToken);
     }
     return contents;
 };
-const deserializeAws_restJson1ListInputsCommandError = async (output, context) => {
+const de_ListInputsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1441,16 +1433,16 @@ const deserializeAws_restJson1ListInputsCommandError = async (output, context) =
     switch (errorCode) {
         case "InternalFailureException":
         case "com.amazonaws.iotevents#InternalFailureException":
-            throw await deserializeAws_restJson1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "InvalidRequestException":
         case "com.amazonaws.iotevents#InvalidRequestException":
-            throw await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context);
+            throw await de_InvalidRequestExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.iotevents#ServiceUnavailableException":
-            throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.iotevents#ThrottlingException":
-            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1461,20 +1453,20 @@ const deserializeAws_restJson1ListInputsCommandError = async (output, context) =
             });
     }
 };
-export const deserializeAws_restJson1ListTagsForResourceCommand = async (output, context) => {
+export const de_ListTagsForResourceCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1ListTagsForResourceCommandError(output, context);
+        return de_ListTagsForResourceCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.tags != null) {
-        contents.tags = deserializeAws_restJson1Tags(data.tags, context);
+        contents.tags = de_Tags(data.tags, context);
     }
     return contents;
 };
-const deserializeAws_restJson1ListTagsForResourceCommandError = async (output, context) => {
+const de_ListTagsForResourceCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1483,19 +1475,19 @@ const deserializeAws_restJson1ListTagsForResourceCommandError = async (output, c
     switch (errorCode) {
         case "InternalFailureException":
         case "com.amazonaws.iotevents#InternalFailureException":
-            throw await deserializeAws_restJson1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "InvalidRequestException":
         case "com.amazonaws.iotevents#InvalidRequestException":
-            throw await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context);
+            throw await de_InvalidRequestExceptionRes(parsedOutput, context);
         case "ResourceInUseException":
         case "com.amazonaws.iotevents#ResourceInUseException":
-            throw await deserializeAws_restJson1ResourceInUseExceptionResponse(parsedOutput, context);
+            throw await de_ResourceInUseExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.iotevents#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.iotevents#ThrottlingException":
-            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1506,9 +1498,9 @@ const deserializeAws_restJson1ListTagsForResourceCommandError = async (output, c
             });
     }
 };
-export const deserializeAws_restJson1PutLoggingOptionsCommand = async (output, context) => {
+export const de_PutLoggingOptionsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1PutLoggingOptionsCommandError(output, context);
+        return de_PutLoggingOptionsCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1516,7 +1508,7 @@ export const deserializeAws_restJson1PutLoggingOptionsCommand = async (output, c
     await collectBody(output.body, context);
     return contents;
 };
-const deserializeAws_restJson1PutLoggingOptionsCommandError = async (output, context) => {
+const de_PutLoggingOptionsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1525,22 +1517,22 @@ const deserializeAws_restJson1PutLoggingOptionsCommandError = async (output, con
     switch (errorCode) {
         case "InternalFailureException":
         case "com.amazonaws.iotevents#InternalFailureException":
-            throw await deserializeAws_restJson1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "InvalidRequestException":
         case "com.amazonaws.iotevents#InvalidRequestException":
-            throw await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context);
+            throw await de_InvalidRequestExceptionRes(parsedOutput, context);
         case "ResourceInUseException":
         case "com.amazonaws.iotevents#ResourceInUseException":
-            throw await deserializeAws_restJson1ResourceInUseExceptionResponse(parsedOutput, context);
+            throw await de_ResourceInUseExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.iotevents#ServiceUnavailableException":
-            throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.iotevents#ThrottlingException":
-            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         case "UnsupportedOperationException":
         case "com.amazonaws.iotevents#UnsupportedOperationException":
-            throw await deserializeAws_restJson1UnsupportedOperationExceptionResponse(parsedOutput, context);
+            throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1551,9 +1543,9 @@ const deserializeAws_restJson1PutLoggingOptionsCommandError = async (output, con
             });
     }
 };
-export const deserializeAws_restJson1StartDetectorModelAnalysisCommand = async (output, context) => {
+export const de_StartDetectorModelAnalysisCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1StartDetectorModelAnalysisCommandError(output, context);
+        return de_StartDetectorModelAnalysisCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1564,7 +1556,7 @@ export const deserializeAws_restJson1StartDetectorModelAnalysisCommand = async (
     }
     return contents;
 };
-const deserializeAws_restJson1StartDetectorModelAnalysisCommandError = async (output, context) => {
+const de_StartDetectorModelAnalysisCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1573,19 +1565,19 @@ const deserializeAws_restJson1StartDetectorModelAnalysisCommandError = async (ou
     switch (errorCode) {
         case "InternalFailureException":
         case "com.amazonaws.iotevents#InternalFailureException":
-            throw await deserializeAws_restJson1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "InvalidRequestException":
         case "com.amazonaws.iotevents#InvalidRequestException":
-            throw await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context);
+            throw await de_InvalidRequestExceptionRes(parsedOutput, context);
         case "LimitExceededException":
         case "com.amazonaws.iotevents#LimitExceededException":
-            throw await deserializeAws_restJson1LimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.iotevents#ServiceUnavailableException":
-            throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.iotevents#ThrottlingException":
-            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1596,9 +1588,9 @@ const deserializeAws_restJson1StartDetectorModelAnalysisCommandError = async (ou
             });
     }
 };
-export const deserializeAws_restJson1TagResourceCommand = async (output, context) => {
+export const de_TagResourceCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1TagResourceCommandError(output, context);
+        return de_TagResourceCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1606,7 +1598,7 @@ export const deserializeAws_restJson1TagResourceCommand = async (output, context
     await collectBody(output.body, context);
     return contents;
 };
-const deserializeAws_restJson1TagResourceCommandError = async (output, context) => {
+const de_TagResourceCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1615,22 +1607,22 @@ const deserializeAws_restJson1TagResourceCommandError = async (output, context)
     switch (errorCode) {
         case "InternalFailureException":
         case "com.amazonaws.iotevents#InternalFailureException":
-            throw await deserializeAws_restJson1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "InvalidRequestException":
         case "com.amazonaws.iotevents#InvalidRequestException":
-            throw await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context);
+            throw await de_InvalidRequestExceptionRes(parsedOutput, context);
         case "LimitExceededException":
         case "com.amazonaws.iotevents#LimitExceededException":
-            throw await deserializeAws_restJson1LimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         case "ResourceInUseException":
         case "com.amazonaws.iotevents#ResourceInUseException":
-            throw await deserializeAws_restJson1ResourceInUseExceptionResponse(parsedOutput, context);
+            throw await de_ResourceInUseExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.iotevents#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.iotevents#ThrottlingException":
-            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1641,9 +1633,9 @@ const deserializeAws_restJson1TagResourceCommandError = async (output, context)
             });
     }
 };
-export const deserializeAws_restJson1UntagResourceCommand = async (output, context) => {
+export const de_UntagResourceCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1UntagResourceCommandError(output, context);
+        return de_UntagResourceCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1651,7 +1643,7 @@ export const deserializeAws_restJson1UntagResourceCommand = async (output, conte
     await collectBody(output.body, context);
     return contents;
 };
-const deserializeAws_restJson1UntagResourceCommandError = async (output, context) => {
+const de_UntagResourceCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1660,19 +1652,19 @@ const deserializeAws_restJson1UntagResourceCommandError = async (output, context
     switch (errorCode) {
         case "InternalFailureException":
         case "com.amazonaws.iotevents#InternalFailureException":
-            throw await deserializeAws_restJson1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "InvalidRequestException":
         case "com.amazonaws.iotevents#InvalidRequestException":
-            throw await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context);
+            throw await de_InvalidRequestExceptionRes(parsedOutput, context);
         case "ResourceInUseException":
         case "com.amazonaws.iotevents#ResourceInUseException":
-            throw await deserializeAws_restJson1ResourceInUseExceptionResponse(parsedOutput, context);
+            throw await de_ResourceInUseExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.iotevents#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.iotevents#ThrottlingException":
-            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1683,9 +1675,9 @@ const deserializeAws_restJson1UntagResourceCommandError = async (output, context
             });
     }
 };
-export const deserializeAws_restJson1UpdateAlarmModelCommand = async (output, context) => {
+export const de_UpdateAlarmModelCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1UpdateAlarmModelCommandError(output, context);
+        return de_UpdateAlarmModelCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1708,7 +1700,7 @@ export const deserializeAws_restJson1UpdateAlarmModelCommand = async (output, co
     }
     return contents;
 };
-const deserializeAws_restJson1UpdateAlarmModelCommandError = async (output, context) => {
+const de_UpdateAlarmModelCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1717,22 +1709,22 @@ const deserializeAws_restJson1UpdateAlarmModelCommandError = async (output, cont
     switch (errorCode) {
         case "InternalFailureException":
         case "com.amazonaws.iotevents#InternalFailureException":
-            throw await deserializeAws_restJson1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "InvalidRequestException":
         case "com.amazonaws.iotevents#InvalidRequestException":
-            throw await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context);
+            throw await de_InvalidRequestExceptionRes(parsedOutput, context);
         case "ResourceInUseException":
         case "com.amazonaws.iotevents#ResourceInUseException":
-            throw await deserializeAws_restJson1ResourceInUseExceptionResponse(parsedOutput, context);
+            throw await de_ResourceInUseExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.iotevents#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.iotevents#ServiceUnavailableException":
-            throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.iotevents#ThrottlingException":
-            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1743,20 +1735,20 @@ const deserializeAws_restJson1UpdateAlarmModelCommandError = async (output, cont
             });
     }
 };
-export const deserializeAws_restJson1UpdateDetectorModelCommand = async (output, context) => {
+export const de_UpdateDetectorModelCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1UpdateDetectorModelCommandError(output, context);
+        return de_UpdateDetectorModelCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.detectorModelConfiguration != null) {
-        contents.detectorModelConfiguration = deserializeAws_restJson1DetectorModelConfiguration(data.detectorModelConfiguration, context);
+        contents.detectorModelConfiguration = de_DetectorModelConfiguration(data.detectorModelConfiguration, context);
     }
     return contents;
 };
-const deserializeAws_restJson1UpdateDetectorModelCommandError = async (output, context) => {
+const de_UpdateDetectorModelCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1765,22 +1757,22 @@ const deserializeAws_restJson1UpdateDetectorModelCommandError = async (output, c
     switch (errorCode) {
         case "InternalFailureException":
         case "com.amazonaws.iotevents#InternalFailureException":
-            throw await deserializeAws_restJson1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "InvalidRequestException":
         case "com.amazonaws.iotevents#InvalidRequestException":
-            throw await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context);
+            throw await de_InvalidRequestExceptionRes(parsedOutput, context);
         case "ResourceInUseException":
         case "com.amazonaws.iotevents#ResourceInUseException":
-            throw await deserializeAws_restJson1ResourceInUseExceptionResponse(parsedOutput, context);
+            throw await de_ResourceInUseExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.iotevents#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.iotevents#ServiceUnavailableException":
-            throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.iotevents#ThrottlingException":
-            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1791,20 +1783,20 @@ const deserializeAws_restJson1UpdateDetectorModelCommandError = async (output, c
             });
     }
 };
-export const deserializeAws_restJson1UpdateInputCommand = async (output, context) => {
+export const de_UpdateInputCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1UpdateInputCommandError(output, context);
+        return de_UpdateInputCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.inputConfiguration != null) {
-        contents.inputConfiguration = deserializeAws_restJson1InputConfiguration(data.inputConfiguration, context);
+        contents.inputConfiguration = de_InputConfiguration(data.inputConfiguration, context);
     }
     return contents;
 };
-const deserializeAws_restJson1UpdateInputCommandError = async (output, context) => {
+const de_UpdateInputCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1813,22 +1805,22 @@ const deserializeAws_restJson1UpdateInputCommandError = async (output, context)
     switch (errorCode) {
         case "InternalFailureException":
         case "com.amazonaws.iotevents#InternalFailureException":
-            throw await deserializeAws_restJson1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "InvalidRequestException":
         case "com.amazonaws.iotevents#InvalidRequestException":
-            throw await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context);
+            throw await de_InvalidRequestExceptionRes(parsedOutput, context);
         case "ResourceInUseException":
         case "com.amazonaws.iotevents#ResourceInUseException":
-            throw await deserializeAws_restJson1ResourceInUseExceptionResponse(parsedOutput, context);
+            throw await de_ResourceInUseExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.iotevents#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.iotevents#ServiceUnavailableException":
-            throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.iotevents#ThrottlingException":
-            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1840,7 +1832,7 @@ const deserializeAws_restJson1UpdateInputCommandError = async (output, context)
     }
 };
 const map = __map;
-const deserializeAws_restJson1InternalFailureExceptionResponse = async (parsedOutput, context) => {
+const de_InternalFailureExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     if (data.message != null) {
@@ -1852,7 +1844,7 @@ const deserializeAws_restJson1InternalFailureExceptionResponse = async (parsedOu
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const deserializeAws_restJson1InvalidRequestExceptionResponse = async (parsedOutput, context) => {
+const de_InvalidRequestExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     if (data.message != null) {
@@ -1864,7 +1856,7 @@ const deserializeAws_restJson1InvalidRequestExceptionResponse = async (parsedOut
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const deserializeAws_restJson1LimitExceededExceptionResponse = async (parsedOutput, context) => {
+const de_LimitExceededExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     if (data.message != null) {
@@ -1876,7 +1868,7 @@ const deserializeAws_restJson1LimitExceededExceptionResponse = async (parsedOutp
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const deserializeAws_restJson1ResourceAlreadyExistsExceptionResponse = async (parsedOutput, context) => {
+const de_ResourceAlreadyExistsExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     if (data.message != null) {
@@ -1894,7 +1886,7 @@ const deserializeAws_restJson1ResourceAlreadyExistsExceptionResponse = async (pa
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const deserializeAws_restJson1ResourceInUseExceptionResponse = async (parsedOutput, context) => {
+const de_ResourceInUseExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     if (data.message != null) {
@@ -1906,7 +1898,7 @@ const deserializeAws_restJson1ResourceInUseExceptionResponse = async (parsedOutp
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const deserializeAws_restJson1ResourceNotFoundExceptionResponse = async (parsedOutput, context) => {
+const de_ResourceNotFoundExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     if (data.message != null) {
@@ -1918,7 +1910,7 @@ const deserializeAws_restJson1ResourceNotFoundExceptionResponse = async (parsedO
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const deserializeAws_restJson1ServiceUnavailableExceptionResponse = async (parsedOutput, context) => {
+const de_ServiceUnavailableExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     if (data.message != null) {
@@ -1930,7 +1922,7 @@ const deserializeAws_restJson1ServiceUnavailableExceptionResponse = async (parse
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const deserializeAws_restJson1ThrottlingExceptionResponse = async (parsedOutput, context) => {
+const de_ThrottlingExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     if (data.message != null) {
@@ -1942,7 +1934,7 @@ const deserializeAws_restJson1ThrottlingExceptionResponse = async (parsedOutput,
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const deserializeAws_restJson1UnsupportedOperationExceptionResponse = async (parsedOutput, context) => {
+const de_UnsupportedOperationExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     if (data.message != null) {
@@ -1954,110 +1946,94 @@ const deserializeAws_restJson1UnsupportedOperationExceptionResponse = async (par
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const serializeAws_restJson1AcknowledgeFlow = (input, context) => {
+const se_AcknowledgeFlow = (input, context) => {
     return {
         ...(input.enabled != null && { enabled: input.enabled }),
     };
 };
-const serializeAws_restJson1Action = (input, context) => {
+const se_Action = (input, context) => {
     return {
-        ...(input.clearTimer != null && { clearTimer: serializeAws_restJson1ClearTimerAction(input.clearTimer, context) }),
-        ...(input.dynamoDB != null && { dynamoDB: serializeAws_restJson1DynamoDBAction(input.dynamoDB, context) }),
-        ...(input.dynamoDBv2 != null && { dynamoDBv2: serializeAws_restJson1DynamoDBv2Action(input.dynamoDBv2, context) }),
-        ...(input.firehose != null && { firehose: serializeAws_restJson1FirehoseAction(input.firehose, context) }),
-        ...(input.iotEvents != null && { iotEvents: serializeAws_restJson1IotEventsAction(input.iotEvents, context) }),
-        ...(input.iotSiteWise != null && {
-            iotSiteWise: serializeAws_restJson1IotSiteWiseAction(input.iotSiteWise, context),
-        }),
-        ...(input.iotTopicPublish != null && {
-            iotTopicPublish: serializeAws_restJson1IotTopicPublishAction(input.iotTopicPublish, context),
-        }),
-        ...(input.lambda != null && { lambda: serializeAws_restJson1LambdaAction(input.lambda, context) }),
-        ...(input.resetTimer != null && { resetTimer: serializeAws_restJson1ResetTimerAction(input.resetTimer, context) }),
-        ...(input.setTimer != null && { setTimer: serializeAws_restJson1SetTimerAction(input.setTimer, context) }),
-        ...(input.setVariable != null && {
-            setVariable: serializeAws_restJson1SetVariableAction(input.setVariable, context),
-        }),
-        ...(input.sns != null && { sns: serializeAws_restJson1SNSTopicPublishAction(input.sns, context) }),
-        ...(input.sqs != null && { sqs: serializeAws_restJson1SqsAction(input.sqs, context) }),
+        ...(input.clearTimer != null && { clearTimer: se_ClearTimerAction(input.clearTimer, context) }),
+        ...(input.dynamoDB != null && { dynamoDB: se_DynamoDBAction(input.dynamoDB, context) }),
+        ...(input.dynamoDBv2 != null && { dynamoDBv2: se_DynamoDBv2Action(input.dynamoDBv2, context) }),
+        ...(input.firehose != null && { firehose: se_FirehoseAction(input.firehose, context) }),
+        ...(input.iotEvents != null && { iotEvents: se_IotEventsAction(input.iotEvents, context) }),
+        ...(input.iotSiteWise != null && { iotSiteWise: se_IotSiteWiseAction(input.iotSiteWise, context) }),
+        ...(input.iotTopicPublish != null && { iotTopicPublish: se_IotTopicPublishAction(input.iotTopicPublish, context) }),
+        ...(input.lambda != null && { lambda: se_LambdaAction(input.lambda, context) }),
+        ...(input.resetTimer != null && { resetTimer: se_ResetTimerAction(input.resetTimer, context) }),
+        ...(input.setTimer != null && { setTimer: se_SetTimerAction(input.setTimer, context) }),
+        ...(input.setVariable != null && { setVariable: se_SetVariableAction(input.setVariable, context) }),
+        ...(input.sns != null && { sns: se_SNSTopicPublishAction(input.sns, context) }),
+        ...(input.sqs != null && { sqs: se_SqsAction(input.sqs, context) }),
     };
 };
-const serializeAws_restJson1Actions = (input, context) => {
+const se_Actions = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
-        return serializeAws_restJson1Action(entry, context);
+        return se_Action(entry, context);
     });
 };
-const serializeAws_restJson1AlarmAction = (input, context) => {
+const se_AlarmAction = (input, context) => {
     return {
-        ...(input.dynamoDB != null && { dynamoDB: serializeAws_restJson1DynamoDBAction(input.dynamoDB, context) }),
-        ...(input.dynamoDBv2 != null && { dynamoDBv2: serializeAws_restJson1DynamoDBv2Action(input.dynamoDBv2, context) }),
-        ...(input.firehose != null && { firehose: serializeAws_restJson1FirehoseAction(input.firehose, context) }),
-        ...(input.iotEvents != null && { iotEvents: serializeAws_restJson1IotEventsAction(input.iotEvents, context) }),
-        ...(input.iotSiteWise != null && {
-            iotSiteWise: serializeAws_restJson1IotSiteWiseAction(input.iotSiteWise, context),
-        }),
-        ...(input.iotTopicPublish != null && {
-            iotTopicPublish: serializeAws_restJson1IotTopicPublishAction(input.iotTopicPublish, context),
-        }),
-        ...(input.lambda != null && { lambda: serializeAws_restJson1LambdaAction(input.lambda, context) }),
-        ...(input.sns != null && { sns: serializeAws_restJson1SNSTopicPublishAction(input.sns, context) }),
-        ...(input.sqs != null && { sqs: serializeAws_restJson1SqsAction(input.sqs, context) }),
+        ...(input.dynamoDB != null && { dynamoDB: se_DynamoDBAction(input.dynamoDB, context) }),
+        ...(input.dynamoDBv2 != null && { dynamoDBv2: se_DynamoDBv2Action(input.dynamoDBv2, context) }),
+        ...(input.firehose != null && { firehose: se_FirehoseAction(input.firehose, context) }),
+        ...(input.iotEvents != null && { iotEvents: se_IotEventsAction(input.iotEvents, context) }),
+        ...(input.iotSiteWise != null && { iotSiteWise: se_IotSiteWiseAction(input.iotSiteWise, context) }),
+        ...(input.iotTopicPublish != null && { iotTopicPublish: se_IotTopicPublishAction(input.iotTopicPublish, context) }),
+        ...(input.lambda != null && { lambda: se_LambdaAction(input.lambda, context) }),
+        ...(input.sns != null && { sns: se_SNSTopicPublishAction(input.sns, context) }),
+        ...(input.sqs != null && { sqs: se_SqsAction(input.sqs, context) }),
     };
 };
-const serializeAws_restJson1AlarmActions = (input, context) => {
+const se_AlarmActions = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
-        return serializeAws_restJson1AlarmAction(entry, context);
+        return se_AlarmAction(entry, context);
     });
 };
-const serializeAws_restJson1AlarmCapabilities = (input, context) => {
+const se_AlarmCapabilities = (input, context) => {
     return {
-        ...(input.acknowledgeFlow != null && {
-            acknowledgeFlow: serializeAws_restJson1AcknowledgeFlow(input.acknowledgeFlow, context),
-        }),
+        ...(input.acknowledgeFlow != null && { acknowledgeFlow: se_AcknowledgeFlow(input.acknowledgeFlow, context) }),
         ...(input.initializationConfiguration != null && {
-            initializationConfiguration: serializeAws_restJson1InitializationConfiguration(input.initializationConfiguration, context),
+            initializationConfiguration: se_InitializationConfiguration(input.initializationConfiguration, context),
         }),
     };
 };
-const serializeAws_restJson1AlarmEventActions = (input, context) => {
+const se_AlarmEventActions = (input, context) => {
     return {
-        ...(input.alarmActions != null && {
-            alarmActions: serializeAws_restJson1AlarmActions(input.alarmActions, context),
-        }),
+        ...(input.alarmActions != null && { alarmActions: se_AlarmActions(input.alarmActions, context) }),
     };
 };
-const serializeAws_restJson1AlarmNotification = (input, context) => {
+const se_AlarmNotification = (input, context) => {
     return {
         ...(input.notificationActions != null && {
-            notificationActions: serializeAws_restJson1NotificationActions(input.notificationActions, context),
+            notificationActions: se_NotificationActions(input.notificationActions, context),
         }),
     };
 };
-const serializeAws_restJson1AlarmRule = (input, context) => {
+const se_AlarmRule = (input, context) => {
     return {
-        ...(input.simpleRule != null && { simpleRule: serializeAws_restJson1SimpleRule(input.simpleRule, context) }),
+        ...(input.simpleRule != null && { simpleRule: se_SimpleRule(input.simpleRule, context) }),
     };
 };
-const serializeAws_restJson1AssetPropertyTimestamp = (input, context) => {
+const se_AssetPropertyTimestamp = (input, context) => {
     return {
         ...(input.offsetInNanos != null && { offsetInNanos: input.offsetInNanos }),
         ...(input.timeInSeconds != null && { timeInSeconds: input.timeInSeconds }),
     };
 };
-const serializeAws_restJson1AssetPropertyValue = (input, context) => {
+const se_AssetPropertyValue = (input, context) => {
     return {
         ...(input.quality != null && { quality: input.quality }),
-        ...(input.timestamp != null && {
-            timestamp: serializeAws_restJson1AssetPropertyTimestamp(input.timestamp, context),
-        }),
-        ...(input.value != null && { value: serializeAws_restJson1AssetPropertyVariant(input.value, context) }),
+        ...(input.timestamp != null && { timestamp: se_AssetPropertyTimestamp(input.timestamp, context) }),
+        ...(input.value != null && { value: se_AssetPropertyVariant(input.value, context) }),
     };
 };
-const serializeAws_restJson1AssetPropertyVariant = (input, context) => {
+const se_AssetPropertyVariant = (input, context) => {
     return {
         ...(input.booleanValue != null && { booleanValue: input.booleanValue }),
         ...(input.doubleValue != null && { doubleValue: input.doubleValue }),
@@ -2065,49 +2041,49 @@ const serializeAws_restJson1AssetPropertyVariant = (input, context) => {
         ...(input.stringValue != null && { stringValue: input.stringValue }),
     };
 };
-const serializeAws_restJson1Attribute = (input, context) => {
+const se_Attribute = (input, context) => {
     return {
         ...(input.jsonPath != null && { jsonPath: input.jsonPath }),
     };
 };
-const serializeAws_restJson1Attributes = (input, context) => {
+const se_Attributes = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
-        return serializeAws_restJson1Attribute(entry, context);
+        return se_Attribute(entry, context);
     });
 };
-const serializeAws_restJson1ClearTimerAction = (input, context) => {
+const se_ClearTimerAction = (input, context) => {
     return {
         ...(input.timerName != null && { timerName: input.timerName }),
     };
 };
-const serializeAws_restJson1DetectorDebugOption = (input, context) => {
+const se_DetectorDebugOption = (input, context) => {
     return {
         ...(input.detectorModelName != null && { detectorModelName: input.detectorModelName }),
         ...(input.keyValue != null && { keyValue: input.keyValue }),
     };
 };
-const serializeAws_restJson1DetectorDebugOptions = (input, context) => {
+const se_DetectorDebugOptions = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
-        return serializeAws_restJson1DetectorDebugOption(entry, context);
+        return se_DetectorDebugOption(entry, context);
     });
 };
-const serializeAws_restJson1DetectorModelDefinition = (input, context) => {
+const se_DetectorModelDefinition = (input, context) => {
     return {
         ...(input.initialStateName != null && { initialStateName: input.initialStateName }),
-        ...(input.states != null && { states: serializeAws_restJson1States(input.states, context) }),
+        ...(input.states != null && { states: se_States(input.states, context) }),
     };
 };
-const serializeAws_restJson1DynamoDBAction = (input, context) => {
+const se_DynamoDBAction = (input, context) => {
     return {
         ...(input.hashKeyField != null && { hashKeyField: input.hashKeyField }),
         ...(input.hashKeyType != null && { hashKeyType: input.hashKeyType }),
         ...(input.hashKeyValue != null && { hashKeyValue: input.hashKeyValue }),
         ...(input.operation != null && { operation: input.operation }),
-        ...(input.payload != null && { payload: serializeAws_restJson1Payload(input.payload, context) }),
+        ...(input.payload != null && { payload: se_Payload(input.payload, context) }),
         ...(input.payloadField != null && { payloadField: input.payloadField }),
         ...(input.rangeKeyField != null && { rangeKeyField: input.rangeKeyField }),
         ...(input.rangeKeyType != null && { rangeKeyType: input.rangeKeyType }),
@@ -2115,385 +2091,373 @@ const serializeAws_restJson1DynamoDBAction = (input, context) => {
         ...(input.tableName != null && { tableName: input.tableName }),
     };
 };
-const serializeAws_restJson1DynamoDBv2Action = (input, context) => {
+const se_DynamoDBv2Action = (input, context) => {
     return {
-        ...(input.payload != null && { payload: serializeAws_restJson1Payload(input.payload, context) }),
+        ...(input.payload != null && { payload: se_Payload(input.payload, context) }),
         ...(input.tableName != null && { tableName: input.tableName }),
     };
 };
-const serializeAws_restJson1EmailConfiguration = (input, context) => {
+const se_EmailConfiguration = (input, context) => {
     return {
-        ...(input.content != null && { content: serializeAws_restJson1EmailContent(input.content, context) }),
+        ...(input.content != null && { content: se_EmailContent(input.content, context) }),
         ...(input.from != null && { from: input.from }),
-        ...(input.recipients != null && { recipients: serializeAws_restJson1EmailRecipients(input.recipients, context) }),
+        ...(input.recipients != null && { recipients: se_EmailRecipients(input.recipients, context) }),
     };
 };
-const serializeAws_restJson1EmailConfigurations = (input, context) => {
+const se_EmailConfigurations = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
-        return serializeAws_restJson1EmailConfiguration(entry, context);
+        return se_EmailConfiguration(entry, context);
     });
 };
-const serializeAws_restJson1EmailContent = (input, context) => {
+const se_EmailContent = (input, context) => {
     return {
         ...(input.additionalMessage != null && { additionalMessage: input.additionalMessage }),
         ...(input.subject != null && { subject: input.subject }),
     };
 };
-const serializeAws_restJson1EmailRecipients = (input, context) => {
+const se_EmailRecipients = (input, context) => {
     return {
-        ...(input.to != null && { to: serializeAws_restJson1RecipientDetails(input.to, context) }),
+        ...(input.to != null && { to: se_RecipientDetails(input.to, context) }),
     };
 };
-const serializeAws_restJson1Event = (input, context) => {
+const se_Event = (input, context) => {
     return {
-        ...(input.actions != null && { actions: serializeAws_restJson1Actions(input.actions, context) }),
+        ...(input.actions != null && { actions: se_Actions(input.actions, context) }),
         ...(input.condition != null && { condition: input.condition }),
         ...(input.eventName != null && { eventName: input.eventName }),
     };
 };
-const serializeAws_restJson1Events = (input, context) => {
+const se_Events = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
-        return serializeAws_restJson1Event(entry, context);
+        return se_Event(entry, context);
     });
 };
-const serializeAws_restJson1FirehoseAction = (input, context) => {
+const se_FirehoseAction = (input, context) => {
     return {
         ...(input.deliveryStreamName != null && { deliveryStreamName: input.deliveryStreamName }),
-        ...(input.payload != null && { payload: serializeAws_restJson1Payload(input.payload, context) }),
+        ...(input.payload != null && { payload: se_Payload(input.payload, context) }),
         ...(input.separator != null && { separator: input.separator }),
     };
 };
-const serializeAws_restJson1InitializationConfiguration = (input, context) => {
+const se_InitializationConfiguration = (input, context) => {
     return {
         ...(input.disabledOnInitialization != null && { disabledOnInitialization: input.disabledOnInitialization }),
     };
 };
-const serializeAws_restJson1InputDefinition = (input, context) => {
+const se_InputDefinition = (input, context) => {
     return {
-        ...(input.attributes != null && { attributes: serializeAws_restJson1Attributes(input.attributes, context) }),
+        ...(input.attributes != null && { attributes: se_Attributes(input.attributes, context) }),
     };
 };
-const serializeAws_restJson1InputIdentifier = (input, context) => {
+const se_InputIdentifier = (input, context) => {
     return {
         ...(input.iotEventsInputIdentifier != null && {
-            iotEventsInputIdentifier: serializeAws_restJson1IotEventsInputIdentifier(input.iotEventsInputIdentifier, context),
+            iotEventsInputIdentifier: se_IotEventsInputIdentifier(input.iotEventsInputIdentifier, context),
         }),
         ...(input.iotSiteWiseInputIdentifier != null && {
-            iotSiteWiseInputIdentifier: serializeAws_restJson1IotSiteWiseInputIdentifier(input.iotSiteWiseInputIdentifier, context),
+            iotSiteWiseInputIdentifier: se_IotSiteWiseInputIdentifier(input.iotSiteWiseInputIdentifier, context),
         }),
     };
 };
-const serializeAws_restJson1IotEventsAction = (input, context) => {
+const se_IotEventsAction = (input, context) => {
     return {
         ...(input.inputName != null && { inputName: input.inputName }),
-        ...(input.payload != null && { payload: serializeAws_restJson1Payload(input.payload, context) }),
+        ...(input.payload != null && { payload: se_Payload(input.payload, context) }),
     };
 };
-const serializeAws_restJson1IotEventsInputIdentifier = (input, context) => {
+const se_IotEventsInputIdentifier = (input, context) => {
     return {
         ...(input.inputName != null && { inputName: input.inputName }),
     };
 };
-const serializeAws_restJson1IotSiteWiseAction = (input, context) => {
+const se_IotSiteWiseAction = (input, context) => {
     return {
         ...(input.assetId != null && { assetId: input.assetId }),
         ...(input.entryId != null && { entryId: input.entryId }),
         ...(input.propertyAlias != null && { propertyAlias: input.propertyAlias }),
         ...(input.propertyId != null && { propertyId: input.propertyId }),
-        ...(input.propertyValue != null && {
-            propertyValue: serializeAws_restJson1AssetPropertyValue(input.propertyValue, context),
-        }),
+        ...(input.propertyValue != null && { propertyValue: se_AssetPropertyValue(input.propertyValue, context) }),
     };
 };
-const serializeAws_restJson1IotSiteWiseAssetModelPropertyIdentifier = (input, context) => {
+const se_IotSiteWiseAssetModelPropertyIdentifier = (input, context) => {
     return {
         ...(input.assetModelId != null && { assetModelId: input.assetModelId }),
         ...(input.propertyId != null && { propertyId: input.propertyId }),
     };
 };
-const serializeAws_restJson1IotSiteWiseInputIdentifier = (input, context) => {
+const se_IotSiteWiseInputIdentifier = (input, context) => {
     return {
         ...(input.iotSiteWiseAssetModelPropertyIdentifier != null && {
-            iotSiteWiseAssetModelPropertyIdentifier: serializeAws_restJson1IotSiteWiseAssetModelPropertyIdentifier(input.iotSiteWiseAssetModelPropertyIdentifier, context),
+            iotSiteWiseAssetModelPropertyIdentifier: se_IotSiteWiseAssetModelPropertyIdentifier(input.iotSiteWiseAssetModelPropertyIdentifier, context),
         }),
     };
 };
-const serializeAws_restJson1IotTopicPublishAction = (input, context) => {
+const se_IotTopicPublishAction = (input, context) => {
     return {
         ...(input.mqttTopic != null && { mqttTopic: input.mqttTopic }),
-        ...(input.payload != null && { payload: serializeAws_restJson1Payload(input.payload, context) }),
+        ...(input.payload != null && { payload: se_Payload(input.payload, context) }),
     };
 };
-const serializeAws_restJson1LambdaAction = (input, context) => {
+const se_LambdaAction = (input, context) => {
     return {
         ...(input.functionArn != null && { functionArn: input.functionArn }),
-        ...(input.payload != null && { payload: serializeAws_restJson1Payload(input.payload, context) }),
+        ...(input.payload != null && { payload: se_Payload(input.payload, context) }),
     };
 };
-const serializeAws_restJson1LoggingOptions = (input, context) => {
+const se_LoggingOptions = (input, context) => {
     return {
         ...(input.detectorDebugOptions != null && {
-            detectorDebugOptions: serializeAws_restJson1DetectorDebugOptions(input.detectorDebugOptions, context),
+            detectorDebugOptions: se_DetectorDebugOptions(input.detectorDebugOptions, context),
         }),
         ...(input.enabled != null && { enabled: input.enabled }),
         ...(input.level != null && { level: input.level }),
         ...(input.roleArn != null && { roleArn: input.roleArn }),
     };
 };
-const serializeAws_restJson1NotificationAction = (input, context) => {
+const se_NotificationAction = (input, context) => {
     return {
-        ...(input.action != null && { action: serializeAws_restJson1NotificationTargetActions(input.action, context) }),
+        ...(input.action != null && { action: se_NotificationTargetActions(input.action, context) }),
         ...(input.emailConfigurations != null && {
-            emailConfigurations: serializeAws_restJson1EmailConfigurations(input.emailConfigurations, context),
+            emailConfigurations: se_EmailConfigurations(input.emailConfigurations, context),
         }),
         ...(input.smsConfigurations != null && {
-            smsConfigurations: serializeAws_restJson1SMSConfigurations(input.smsConfigurations, context),
+            smsConfigurations: se_SMSConfigurations(input.smsConfigurations, context),
         }),
     };
 };
-const serializeAws_restJson1NotificationActions = (input, context) => {
+const se_NotificationActions = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
-        return serializeAws_restJson1NotificationAction(entry, context);
+        return se_NotificationAction(entry, context);
     });
 };
-const serializeAws_restJson1NotificationTargetActions = (input, context) => {
+const se_NotificationTargetActions = (input, context) => {
     return {
-        ...(input.lambdaAction != null && {
-            lambdaAction: serializeAws_restJson1LambdaAction(input.lambdaAction, context),
-        }),
+        ...(input.lambdaAction != null && { lambdaAction: se_LambdaAction(input.lambdaAction, context) }),
     };
 };
-const serializeAws_restJson1OnEnterLifecycle = (input, context) => {
+const se_OnEnterLifecycle = (input, context) => {
     return {
-        ...(input.events != null && { events: serializeAws_restJson1Events(input.events, context) }),
+        ...(input.events != null && { events: se_Events(input.events, context) }),
     };
 };
-const serializeAws_restJson1OnExitLifecycle = (input, context) => {
+const se_OnExitLifecycle = (input, context) => {
     return {
-        ...(input.events != null && { events: serializeAws_restJson1Events(input.events, context) }),
+        ...(input.events != null && { events: se_Events(input.events, context) }),
     };
 };
-const serializeAws_restJson1OnInputLifecycle = (input, context) => {
+const se_OnInputLifecycle = (input, context) => {
     return {
-        ...(input.events != null && { events: serializeAws_restJson1Events(input.events, context) }),
-        ...(input.transitionEvents != null && {
-            transitionEvents: serializeAws_restJson1TransitionEvents(input.transitionEvents, context),
-        }),
+        ...(input.events != null && { events: se_Events(input.events, context) }),
+        ...(input.transitionEvents != null && { transitionEvents: se_TransitionEvents(input.transitionEvents, context) }),
     };
 };
-const serializeAws_restJson1Payload = (input, context) => {
+const se_Payload = (input, context) => {
     return {
         ...(input.contentExpression != null && { contentExpression: input.contentExpression }),
         ...(input.type != null && { type: input.type }),
     };
 };
-const serializeAws_restJson1RecipientDetail = (input, context) => {
+const se_RecipientDetail = (input, context) => {
     return {
-        ...(input.ssoIdentity != null && { ssoIdentity: serializeAws_restJson1SSOIdentity(input.ssoIdentity, context) }),
+        ...(input.ssoIdentity != null && { ssoIdentity: se_SSOIdentity(input.ssoIdentity, context) }),
     };
 };
-const serializeAws_restJson1RecipientDetails = (input, context) => {
+const se_RecipientDetails = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
-        return serializeAws_restJson1RecipientDetail(entry, context);
+        return se_RecipientDetail(entry, context);
     });
 };
-const serializeAws_restJson1ResetTimerAction = (input, context) => {
+const se_ResetTimerAction = (input, context) => {
     return {
         ...(input.timerName != null && { timerName: input.timerName }),
     };
 };
-const serializeAws_restJson1SetTimerAction = (input, context) => {
+const se_SetTimerAction = (input, context) => {
     return {
         ...(input.durationExpression != null && { durationExpression: input.durationExpression }),
         ...(input.seconds != null && { seconds: input.seconds }),
         ...(input.timerName != null && { timerName: input.timerName }),
     };
 };
-const serializeAws_restJson1SetVariableAction = (input, context) => {
+const se_SetVariableAction = (input, context) => {
     return {
         ...(input.value != null && { value: input.value }),
         ...(input.variableName != null && { variableName: input.variableName }),
     };
 };
-const serializeAws_restJson1SimpleRule = (input, context) => {
+const se_SimpleRule = (input, context) => {
     return {
         ...(input.comparisonOperator != null && { comparisonOperator: input.comparisonOperator }),
         ...(input.inputProperty != null && { inputProperty: input.inputProperty }),
         ...(input.threshold != null && { threshold: input.threshold }),
     };
 };
-const serializeAws_restJson1SMSConfiguration = (input, context) => {
+const se_SMSConfiguration = (input, context) => {
     return {
         ...(input.additionalMessage != null && { additionalMessage: input.additionalMessage }),
-        ...(input.recipients != null && { recipients: serializeAws_restJson1RecipientDetails(input.recipients, context) }),
+        ...(input.recipients != null && { recipients: se_RecipientDetails(input.recipients, context) }),
         ...(input.senderId != null && { senderId: input.senderId }),
     };
 };
-const serializeAws_restJson1SMSConfigurations = (input, context) => {
+const se_SMSConfigurations = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
-        return serializeAws_restJson1SMSConfiguration(entry, context);
+        return se_SMSConfiguration(entry, context);
     });
 };
-const serializeAws_restJson1SNSTopicPublishAction = (input, context) => {
+const se_SNSTopicPublishAction = (input, context) => {
     return {
-        ...(input.payload != null && { payload: serializeAws_restJson1Payload(input.payload, context) }),
+        ...(input.payload != null && { payload: se_Payload(input.payload, context) }),
         ...(input.targetArn != null && { targetArn: input.targetArn }),
     };
 };
-const serializeAws_restJson1SqsAction = (input, context) => {
+const se_SqsAction = (input, context) => {
     return {
-        ...(input.payload != null && { payload: serializeAws_restJson1Payload(input.payload, context) }),
+        ...(input.payload != null && { payload: se_Payload(input.payload, context) }),
         ...(input.queueUrl != null && { queueUrl: input.queueUrl }),
         ...(input.useBase64 != null && { useBase64: input.useBase64 }),
     };
 };
-const serializeAws_restJson1SSOIdentity = (input, context) => {
+const se_SSOIdentity = (input, context) => {
     return {
         ...(input.identityStoreId != null && { identityStoreId: input.identityStoreId }),
         ...(input.userId != null && { userId: input.userId }),
     };
 };
-const serializeAws_restJson1State = (input, context) => {
+const se_State = (input, context) => {
     return {
-        ...(input.onEnter != null && { onEnter: serializeAws_restJson1OnEnterLifecycle(input.onEnter, context) }),
-        ...(input.onExit != null && { onExit: serializeAws_restJson1OnExitLifecycle(input.onExit, context) }),
-        ...(input.onInput != null && { onInput: serializeAws_restJson1OnInputLifecycle(input.onInput, context) }),
+        ...(input.onEnter != null && { onEnter: se_OnEnterLifecycle(input.onEnter, context) }),
+        ...(input.onExit != null && { onExit: se_OnExitLifecycle(input.onExit, context) }),
+        ...(input.onInput != null && { onInput: se_OnInputLifecycle(input.onInput, context) }),
         ...(input.stateName != null && { stateName: input.stateName }),
     };
 };
-const serializeAws_restJson1States = (input, context) => {
+const se_States = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
-        return serializeAws_restJson1State(entry, context);
+        return se_State(entry, context);
     });
 };
-const serializeAws_restJson1Tag = (input, context) => {
+const se_Tag = (input, context) => {
     return {
         ...(input.key != null && { key: input.key }),
         ...(input.value != null && { value: input.value }),
     };
 };
-const serializeAws_restJson1Tags = (input, context) => {
+const se_Tags = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
-        return serializeAws_restJson1Tag(entry, context);
+        return se_Tag(entry, context);
     });
 };
-const serializeAws_restJson1TransitionEvent = (input, context) => {
+const se_TransitionEvent = (input, context) => {
     return {
-        ...(input.actions != null && { actions: serializeAws_restJson1Actions(input.actions, context) }),
+        ...(input.actions != null && { actions: se_Actions(input.actions, context) }),
         ...(input.condition != null && { condition: input.condition }),
         ...(input.eventName != null && { eventName: input.eventName }),
         ...(input.nextState != null && { nextState: input.nextState }),
     };
 };
-const serializeAws_restJson1TransitionEvents = (input, context) => {
+const se_TransitionEvents = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
-        return serializeAws_restJson1TransitionEvent(entry, context);
+        return se_TransitionEvent(entry, context);
     });
 };
-const deserializeAws_restJson1AcknowledgeFlow = (output, context) => {
+const de_AcknowledgeFlow = (output, context) => {
     return {
         enabled: __expectBoolean(output.enabled),
     };
 };
-const deserializeAws_restJson1Action = (output, context) => {
+const de_Action = (output, context) => {
     return {
-        clearTimer: output.clearTimer != null ? deserializeAws_restJson1ClearTimerAction(output.clearTimer, context) : undefined,
-        dynamoDB: output.dynamoDB != null ? deserializeAws_restJson1DynamoDBAction(output.dynamoDB, context) : undefined,
-        dynamoDBv2: output.dynamoDBv2 != null ? deserializeAws_restJson1DynamoDBv2Action(output.dynamoDBv2, context) : undefined,
-        firehose: output.firehose != null ? deserializeAws_restJson1FirehoseAction(output.firehose, context) : undefined,
-        iotEvents: output.iotEvents != null ? deserializeAws_restJson1IotEventsAction(output.iotEvents, context) : undefined,
-        iotSiteWise: output.iotSiteWise != null ? deserializeAws_restJson1IotSiteWiseAction(output.iotSiteWise, context) : undefined,
-        iotTopicPublish: output.iotTopicPublish != null
-            ? deserializeAws_restJson1IotTopicPublishAction(output.iotTopicPublish, context)
-            : undefined,
-        lambda: output.lambda != null ? deserializeAws_restJson1LambdaAction(output.lambda, context) : undefined,
-        resetTimer: output.resetTimer != null ? deserializeAws_restJson1ResetTimerAction(output.resetTimer, context) : undefined,
-        setTimer: output.setTimer != null ? deserializeAws_restJson1SetTimerAction(output.setTimer, context) : undefined,
-        setVariable: output.setVariable != null ? deserializeAws_restJson1SetVariableAction(output.setVariable, context) : undefined,
-        sns: output.sns != null ? deserializeAws_restJson1SNSTopicPublishAction(output.sns, context) : undefined,
-        sqs: output.sqs != null ? deserializeAws_restJson1SqsAction(output.sqs, context) : undefined,
+        clearTimer: output.clearTimer != null ? de_ClearTimerAction(output.clearTimer, context) : undefined,
+        dynamoDB: output.dynamoDB != null ? de_DynamoDBAction(output.dynamoDB, context) : undefined,
+        dynamoDBv2: output.dynamoDBv2 != null ? de_DynamoDBv2Action(output.dynamoDBv2, context) : undefined,
+        firehose: output.firehose != null ? de_FirehoseAction(output.firehose, context) : undefined,
+        iotEvents: output.iotEvents != null ? de_IotEventsAction(output.iotEvents, context) : undefined,
+        iotSiteWise: output.iotSiteWise != null ? de_IotSiteWiseAction(output.iotSiteWise, context) : undefined,
+        iotTopicPublish: output.iotTopicPublish != null ? de_IotTopicPublishAction(output.iotTopicPublish, context) : undefined,
+        lambda: output.lambda != null ? de_LambdaAction(output.lambda, context) : undefined,
+        resetTimer: output.resetTimer != null ? de_ResetTimerAction(output.resetTimer, context) : undefined,
+        setTimer: output.setTimer != null ? de_SetTimerAction(output.setTimer, context) : undefined,
+        setVariable: output.setVariable != null ? de_SetVariableAction(output.setVariable, context) : undefined,
+        sns: output.sns != null ? de_SNSTopicPublishAction(output.sns, context) : undefined,
+        sqs: output.sqs != null ? de_SqsAction(output.sqs, context) : undefined,
     };
 };
-const deserializeAws_restJson1Actions = (output, context) => {
+const de_Actions = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1Action(entry, context);
+        return de_Action(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1AlarmAction = (output, context) => {
+const de_AlarmAction = (output, context) => {
     return {
-        dynamoDB: output.dynamoDB != null ? deserializeAws_restJson1DynamoDBAction(output.dynamoDB, context) : undefined,
-        dynamoDBv2: output.dynamoDBv2 != null ? deserializeAws_restJson1DynamoDBv2Action(output.dynamoDBv2, context) : undefined,
-        firehose: output.firehose != null ? deserializeAws_restJson1FirehoseAction(output.firehose, context) : undefined,
-        iotEvents: output.iotEvents != null ? deserializeAws_restJson1IotEventsAction(output.iotEvents, context) : undefined,
-        iotSiteWise: output.iotSiteWise != null ? deserializeAws_restJson1IotSiteWiseAction(output.iotSiteWise, context) : undefined,
-        iotTopicPublish: output.iotTopicPublish != null
-            ? deserializeAws_restJson1IotTopicPublishAction(output.iotTopicPublish, context)
-            : undefined,
-        lambda: output.lambda != null ? deserializeAws_restJson1LambdaAction(output.lambda, context) : undefined,
-        sns: output.sns != null ? deserializeAws_restJson1SNSTopicPublishAction(output.sns, context) : undefined,
-        sqs: output.sqs != null ? deserializeAws_restJson1SqsAction(output.sqs, context) : undefined,
+        dynamoDB: output.dynamoDB != null ? de_DynamoDBAction(output.dynamoDB, context) : undefined,
+        dynamoDBv2: output.dynamoDBv2 != null ? de_DynamoDBv2Action(output.dynamoDBv2, context) : undefined,
+        firehose: output.firehose != null ? de_FirehoseAction(output.firehose, context) : undefined,
+        iotEvents: output.iotEvents != null ? de_IotEventsAction(output.iotEvents, context) : undefined,
+        iotSiteWise: output.iotSiteWise != null ? de_IotSiteWiseAction(output.iotSiteWise, context) : undefined,
+        iotTopicPublish: output.iotTopicPublish != null ? de_IotTopicPublishAction(output.iotTopicPublish, context) : undefined,
+        lambda: output.lambda != null ? de_LambdaAction(output.lambda, context) : undefined,
+        sns: output.sns != null ? de_SNSTopicPublishAction(output.sns, context) : undefined,
+        sqs: output.sqs != null ? de_SqsAction(output.sqs, context) : undefined,
     };
 };
-const deserializeAws_restJson1AlarmActions = (output, context) => {
+const de_AlarmActions = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1AlarmAction(entry, context);
+        return de_AlarmAction(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1AlarmCapabilities = (output, context) => {
+const de_AlarmCapabilities = (output, context) => {
     return {
-        acknowledgeFlow: output.acknowledgeFlow != null
-            ? deserializeAws_restJson1AcknowledgeFlow(output.acknowledgeFlow, context)
-            : undefined,
+        acknowledgeFlow: output.acknowledgeFlow != null ? de_AcknowledgeFlow(output.acknowledgeFlow, context) : undefined,
         initializationConfiguration: output.initializationConfiguration != null
-            ? deserializeAws_restJson1InitializationConfiguration(output.initializationConfiguration, context)
+            ? de_InitializationConfiguration(output.initializationConfiguration, context)
             : undefined,
     };
 };
-const deserializeAws_restJson1AlarmEventActions = (output, context) => {
+const de_AlarmEventActions = (output, context) => {
     return {
-        alarmActions: output.alarmActions != null ? deserializeAws_restJson1AlarmActions(output.alarmActions, context) : undefined,
+        alarmActions: output.alarmActions != null ? de_AlarmActions(output.alarmActions, context) : undefined,
     };
 };
-const deserializeAws_restJson1AlarmModelSummaries = (output, context) => {
+const de_AlarmModelSummaries = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1AlarmModelSummary(entry, context);
+        return de_AlarmModelSummary(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1AlarmModelSummary = (output, context) => {
+const de_AlarmModelSummary = (output, context) => {
     return {
         alarmModelDescription: __expectString(output.alarmModelDescription),
         alarmModelName: __expectString(output.alarmModelName),
@@ -2502,18 +2466,18 @@ const deserializeAws_restJson1AlarmModelSummary = (output, context) => {
             : undefined,
     };
 };
-const deserializeAws_restJson1AlarmModelVersionSummaries = (output, context) => {
+const de_AlarmModelVersionSummaries = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1AlarmModelVersionSummary(entry, context);
+        return de_AlarmModelVersionSummary(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1AlarmModelVersionSummary = (output, context) => {
+const de_AlarmModelVersionSummary = (output, context) => {
     return {
         alarmModelArn: __expectString(output.alarmModelArn),
         alarmModelName: __expectString(output.alarmModelName),
@@ -2529,67 +2493,65 @@ const deserializeAws_restJson1AlarmModelVersionSummary = (output, context) => {
         statusMessage: __expectString(output.statusMessage),
     };
 };
-const deserializeAws_restJson1AlarmNotification = (output, context) => {
+const de_AlarmNotification = (output, context) => {
     return {
-        notificationActions: output.notificationActions != null
-            ? deserializeAws_restJson1NotificationActions(output.notificationActions, context)
-            : undefined,
+        notificationActions: output.notificationActions != null ? de_NotificationActions(output.notificationActions, context) : undefined,
     };
 };
-const deserializeAws_restJson1AlarmRule = (output, context) => {
+const de_AlarmRule = (output, context) => {
     return {
-        simpleRule: output.simpleRule != null ? deserializeAws_restJson1SimpleRule(output.simpleRule, context) : undefined,
+        simpleRule: output.simpleRule != null ? de_SimpleRule(output.simpleRule, context) : undefined,
     };
 };
-const deserializeAws_restJson1AnalysisResult = (output, context) => {
+const de_AnalysisResult = (output, context) => {
     return {
         level: __expectString(output.level),
-        locations: output.locations != null ? deserializeAws_restJson1AnalysisResultLocations(output.locations, context) : undefined,
+        locations: output.locations != null ? de_AnalysisResultLocations(output.locations, context) : undefined,
         message: __expectString(output.message),
         type: __expectString(output.type),
     };
 };
-const deserializeAws_restJson1AnalysisResultLocation = (output, context) => {
+const de_AnalysisResultLocation = (output, context) => {
     return {
         path: __expectString(output.path),
     };
 };
-const deserializeAws_restJson1AnalysisResultLocations = (output, context) => {
+const de_AnalysisResultLocations = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1AnalysisResultLocation(entry, context);
+        return de_AnalysisResultLocation(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1AnalysisResults = (output, context) => {
+const de_AnalysisResults = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1AnalysisResult(entry, context);
+        return de_AnalysisResult(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1AssetPropertyTimestamp = (output, context) => {
+const de_AssetPropertyTimestamp = (output, context) => {
     return {
         offsetInNanos: __expectString(output.offsetInNanos),
         timeInSeconds: __expectString(output.timeInSeconds),
     };
 };
-const deserializeAws_restJson1AssetPropertyValue = (output, context) => {
+const de_AssetPropertyValue = (output, context) => {
     return {
         quality: __expectString(output.quality),
-        timestamp: output.timestamp != null ? deserializeAws_restJson1AssetPropertyTimestamp(output.timestamp, context) : undefined,
-        value: output.value != null ? deserializeAws_restJson1AssetPropertyVariant(output.value, context) : undefined,
+        timestamp: output.timestamp != null ? de_AssetPropertyTimestamp(output.timestamp, context) : undefined,
+        value: output.value != null ? de_AssetPropertyVariant(output.value, context) : undefined,
     };
 };
-const deserializeAws_restJson1AssetPropertyVariant = (output, context) => {
+const de_AssetPropertyVariant = (output, context) => {
     return {
         booleanValue: __expectString(output.booleanValue),
         doubleValue: __expectString(output.doubleValue),
@@ -2597,55 +2559,55 @@ const deserializeAws_restJson1AssetPropertyVariant = (output, context) => {
         stringValue: __expectString(output.stringValue),
     };
 };
-const deserializeAws_restJson1Attribute = (output, context) => {
+const de_Attribute = (output, context) => {
     return {
         jsonPath: __expectString(output.jsonPath),
     };
 };
-const deserializeAws_restJson1Attributes = (output, context) => {
+const de_Attributes = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1Attribute(entry, context);
+        return de_Attribute(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1ClearTimerAction = (output, context) => {
+const de_ClearTimerAction = (output, context) => {
     return {
         timerName: __expectString(output.timerName),
     };
 };
-const deserializeAws_restJson1DetectorDebugOption = (output, context) => {
+const de_DetectorDebugOption = (output, context) => {
     return {
         detectorModelName: __expectString(output.detectorModelName),
         keyValue: __expectString(output.keyValue),
     };
 };
-const deserializeAws_restJson1DetectorDebugOptions = (output, context) => {
+const de_DetectorDebugOptions = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1DetectorDebugOption(entry, context);
+        return de_DetectorDebugOption(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1DetectorModel = (output, context) => {
+const de_DetectorModel = (output, context) => {
     return {
         detectorModelConfiguration: output.detectorModelConfiguration != null
-            ? deserializeAws_restJson1DetectorModelConfiguration(output.detectorModelConfiguration, context)
+            ? de_DetectorModelConfiguration(output.detectorModelConfiguration, context)
             : undefined,
         detectorModelDefinition: output.detectorModelDefinition != null
-            ? deserializeAws_restJson1DetectorModelDefinition(output.detectorModelDefinition, context)
+            ? de_DetectorModelDefinition(output.detectorModelDefinition, context)
             : undefined,
     };
 };
-const deserializeAws_restJson1DetectorModelConfiguration = (output, context) => {
+const de_DetectorModelConfiguration = (output, context) => {
     return {
         creationTime: output.creationTime != null
             ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.creationTime)))
@@ -2663,24 +2625,24 @@ const deserializeAws_restJson1DetectorModelConfiguration = (output, context) =>
         status: __expectString(output.status),
     };
 };
-const deserializeAws_restJson1DetectorModelDefinition = (output, context) => {
+const de_DetectorModelDefinition = (output, context) => {
     return {
         initialStateName: __expectString(output.initialStateName),
-        states: output.states != null ? deserializeAws_restJson1States(output.states, context) : undefined,
+        states: output.states != null ? de_States(output.states, context) : undefined,
     };
 };
-const deserializeAws_restJson1DetectorModelSummaries = (output, context) => {
+const de_DetectorModelSummaries = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1DetectorModelSummary(entry, context);
+        return de_DetectorModelSummary(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1DetectorModelSummary = (output, context) => {
+const de_DetectorModelSummary = (output, context) => {
     return {
         creationTime: output.creationTime != null
             ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.creationTime)))
@@ -2689,18 +2651,18 @@ const deserializeAws_restJson1DetectorModelSummary = (output, context) => {
         detectorModelName: __expectString(output.detectorModelName),
     };
 };
-const deserializeAws_restJson1DetectorModelVersionSummaries = (output, context) => {
+const de_DetectorModelVersionSummaries = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1DetectorModelVersionSummary(entry, context);
+        return de_DetectorModelVersionSummary(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1DetectorModelVersionSummary = (output, context) => {
+const de_DetectorModelVersionSummary = (output, context) => {
     return {
         creationTime: output.creationTime != null
             ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.creationTime)))
@@ -2716,13 +2678,13 @@ const deserializeAws_restJson1DetectorModelVersionSummary = (output, context) =>
         status: __expectString(output.status),
     };
 };
-const deserializeAws_restJson1DynamoDBAction = (output, context) => {
+const de_DynamoDBAction = (output, context) => {
     return {
         hashKeyField: __expectString(output.hashKeyField),
         hashKeyType: __expectString(output.hashKeyType),
         hashKeyValue: __expectString(output.hashKeyValue),
         operation: __expectString(output.operation),
-        payload: output.payload != null ? deserializeAws_restJson1Payload(output.payload, context) : undefined,
+        payload: output.payload != null ? de_Payload(output.payload, context) : undefined,
         payloadField: __expectString(output.payloadField),
         rangeKeyField: __expectString(output.rangeKeyField),
         rangeKeyType: __expectString(output.rangeKeyType),
@@ -2730,82 +2692,78 @@ const deserializeAws_restJson1DynamoDBAction = (output, context) => {
         tableName: __expectString(output.tableName),
     };
 };
-const deserializeAws_restJson1DynamoDBv2Action = (output, context) => {
+const de_DynamoDBv2Action = (output, context) => {
     return {
-        payload: output.payload != null ? deserializeAws_restJson1Payload(output.payload, context) : undefined,
+        payload: output.payload != null ? de_Payload(output.payload, context) : undefined,
         tableName: __expectString(output.tableName),
     };
 };
-const deserializeAws_restJson1EmailConfiguration = (output, context) => {
+const de_EmailConfiguration = (output, context) => {
     return {
-        content: output.content != null ? deserializeAws_restJson1EmailContent(output.content, context) : undefined,
+        content: output.content != null ? de_EmailContent(output.content, context) : undefined,
         from: __expectString(output.from),
-        recipients: output.recipients != null ? deserializeAws_restJson1EmailRecipients(output.recipients, context) : undefined,
+        recipients: output.recipients != null ? de_EmailRecipients(output.recipients, context) : undefined,
     };
 };
-const deserializeAws_restJson1EmailConfigurations = (output, context) => {
+const de_EmailConfigurations = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1EmailConfiguration(entry, context);
+        return de_EmailConfiguration(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1EmailContent = (output, context) => {
+const de_EmailContent = (output, context) => {
     return {
         additionalMessage: __expectString(output.additionalMessage),
         subject: __expectString(output.subject),
     };
 };
-const deserializeAws_restJson1EmailRecipients = (output, context) => {
+const de_EmailRecipients = (output, context) => {
     return {
-        to: output.to != null ? deserializeAws_restJson1RecipientDetails(output.to, context) : undefined,
+        to: output.to != null ? de_RecipientDetails(output.to, context) : undefined,
     };
 };
-const deserializeAws_restJson1Event = (output, context) => {
+const de_Event = (output, context) => {
     return {
-        actions: output.actions != null ? deserializeAws_restJson1Actions(output.actions, context) : undefined,
+        actions: output.actions != null ? de_Actions(output.actions, context) : undefined,
         condition: __expectString(output.condition),
         eventName: __expectString(output.eventName),
     };
 };
-const deserializeAws_restJson1Events = (output, context) => {
+const de_Events = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1Event(entry, context);
+        return de_Event(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1FirehoseAction = (output, context) => {
+const de_FirehoseAction = (output, context) => {
     return {
         deliveryStreamName: __expectString(output.deliveryStreamName),
-        payload: output.payload != null ? deserializeAws_restJson1Payload(output.payload, context) : undefined,
+        payload: output.payload != null ? de_Payload(output.payload, context) : undefined,
         separator: __expectString(output.separator),
     };
 };
-const deserializeAws_restJson1InitializationConfiguration = (output, context) => {
+const de_InitializationConfiguration = (output, context) => {
     return {
         disabledOnInitialization: __expectBoolean(output.disabledOnInitialization),
     };
 };
-const deserializeAws_restJson1Input = (output, context) => {
+const de_Input = (output, context) => {
     return {
-        inputConfiguration: output.inputConfiguration != null
-            ? deserializeAws_restJson1InputConfiguration(output.inputConfiguration, context)
-            : undefined,
-        inputDefinition: output.inputDefinition != null
-            ? deserializeAws_restJson1InputDefinition(output.inputDefinition, context)
-            : undefined,
+        inputConfiguration: output.inputConfiguration != null ? de_InputConfiguration(output.inputConfiguration, context) : undefined,
+        inputDefinition: output.inputDefinition != null ? de_InputDefinition(output.inputDefinition, context) : undefined,
     };
 };
-const deserializeAws_restJson1InputConfiguration = (output, context) => {
+const de_InputConfiguration = (output, context) => {
     return {
         creationTime: output.creationTime != null
             ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.creationTime)))
@@ -2819,23 +2777,23 @@ const deserializeAws_restJson1InputConfiguration = (output, context) => {
         status: __expectString(output.status),
     };
 };
-const deserializeAws_restJson1InputDefinition = (output, context) => {
+const de_InputDefinition = (output, context) => {
     return {
-        attributes: output.attributes != null ? deserializeAws_restJson1Attributes(output.attributes, context) : undefined,
+        attributes: output.attributes != null ? de_Attributes(output.attributes, context) : undefined,
     };
 };
-const deserializeAws_restJson1InputSummaries = (output, context) => {
+const de_InputSummaries = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1InputSummary(entry, context);
+        return de_InputSummary(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1InputSummary = (output, context) => {
+const de_InputSummary = (output, context) => {
     return {
         creationTime: output.creationTime != null
             ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.creationTime)))
@@ -2849,243 +2807,233 @@ const deserializeAws_restJson1InputSummary = (output, context) => {
         status: __expectString(output.status),
     };
 };
-const deserializeAws_restJson1IotEventsAction = (output, context) => {
+const de_IotEventsAction = (output, context) => {
     return {
         inputName: __expectString(output.inputName),
-        payload: output.payload != null ? deserializeAws_restJson1Payload(output.payload, context) : undefined,
+        payload: output.payload != null ? de_Payload(output.payload, context) : undefined,
     };
 };
-const deserializeAws_restJson1IotSiteWiseAction = (output, context) => {
+const de_IotSiteWiseAction = (output, context) => {
     return {
         assetId: __expectString(output.assetId),
         entryId: __expectString(output.entryId),
         propertyAlias: __expectString(output.propertyAlias),
         propertyId: __expectString(output.propertyId),
-        propertyValue: output.propertyValue != null
-            ? deserializeAws_restJson1AssetPropertyValue(output.propertyValue, context)
-            : undefined,
+        propertyValue: output.propertyValue != null ? de_AssetPropertyValue(output.propertyValue, context) : undefined,
     };
 };
-const deserializeAws_restJson1IotTopicPublishAction = (output, context) => {
+const de_IotTopicPublishAction = (output, context) => {
     return {
         mqttTopic: __expectString(output.mqttTopic),
-        payload: output.payload != null ? deserializeAws_restJson1Payload(output.payload, context) : undefined,
+        payload: output.payload != null ? de_Payload(output.payload, context) : undefined,
     };
 };
-const deserializeAws_restJson1LambdaAction = (output, context) => {
+const de_LambdaAction = (output, context) => {
     return {
         functionArn: __expectString(output.functionArn),
-        payload: output.payload != null ? deserializeAws_restJson1Payload(output.payload, context) : undefined,
+        payload: output.payload != null ? de_Payload(output.payload, context) : undefined,
     };
 };
-const deserializeAws_restJson1LoggingOptions = (output, context) => {
+const de_LoggingOptions = (output, context) => {
     return {
-        detectorDebugOptions: output.detectorDebugOptions != null
-            ? deserializeAws_restJson1DetectorDebugOptions(output.detectorDebugOptions, context)
-            : undefined,
+        detectorDebugOptions: output.detectorDebugOptions != null ? de_DetectorDebugOptions(output.detectorDebugOptions, context) : undefined,
         enabled: __expectBoolean(output.enabled),
         level: __expectString(output.level),
         roleArn: __expectString(output.roleArn),
     };
 };
-const deserializeAws_restJson1NotificationAction = (output, context) => {
+const de_NotificationAction = (output, context) => {
     return {
-        action: output.action != null ? deserializeAws_restJson1NotificationTargetActions(output.action, context) : undefined,
-        emailConfigurations: output.emailConfigurations != null
-            ? deserializeAws_restJson1EmailConfigurations(output.emailConfigurations, context)
-            : undefined,
-        smsConfigurations: output.smsConfigurations != null
-            ? deserializeAws_restJson1SMSConfigurations(output.smsConfigurations, context)
-            : undefined,
+        action: output.action != null ? de_NotificationTargetActions(output.action, context) : undefined,
+        emailConfigurations: output.emailConfigurations != null ? de_EmailConfigurations(output.emailConfigurations, context) : undefined,
+        smsConfigurations: output.smsConfigurations != null ? de_SMSConfigurations(output.smsConfigurations, context) : undefined,
     };
 };
-const deserializeAws_restJson1NotificationActions = (output, context) => {
+const de_NotificationActions = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1NotificationAction(entry, context);
+        return de_NotificationAction(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1NotificationTargetActions = (output, context) => {
+const de_NotificationTargetActions = (output, context) => {
     return {
-        lambdaAction: output.lambdaAction != null ? deserializeAws_restJson1LambdaAction(output.lambdaAction, context) : undefined,
+        lambdaAction: output.lambdaAction != null ? de_LambdaAction(output.lambdaAction, context) : undefined,
     };
 };
-const deserializeAws_restJson1OnEnterLifecycle = (output, context) => {
+const de_OnEnterLifecycle = (output, context) => {
     return {
-        events: output.events != null ? deserializeAws_restJson1Events(output.events, context) : undefined,
+        events: output.events != null ? de_Events(output.events, context) : undefined,
     };
 };
-const deserializeAws_restJson1OnExitLifecycle = (output, context) => {
+const de_OnExitLifecycle = (output, context) => {
     return {
-        events: output.events != null ? deserializeAws_restJson1Events(output.events, context) : undefined,
+        events: output.events != null ? de_Events(output.events, context) : undefined,
     };
 };
-const deserializeAws_restJson1OnInputLifecycle = (output, context) => {
+const de_OnInputLifecycle = (output, context) => {
     return {
-        events: output.events != null ? deserializeAws_restJson1Events(output.events, context) : undefined,
-        transitionEvents: output.transitionEvents != null
-            ? deserializeAws_restJson1TransitionEvents(output.transitionEvents, context)
-            : undefined,
+        events: output.events != null ? de_Events(output.events, context) : undefined,
+        transitionEvents: output.transitionEvents != null ? de_TransitionEvents(output.transitionEvents, context) : undefined,
     };
 };
-const deserializeAws_restJson1Payload = (output, context) => {
+const de_Payload = (output, context) => {
     return {
         contentExpression: __expectString(output.contentExpression),
         type: __expectString(output.type),
     };
 };
-const deserializeAws_restJson1RecipientDetail = (output, context) => {
+const de_RecipientDetail = (output, context) => {
     return {
-        ssoIdentity: output.ssoIdentity != null ? deserializeAws_restJson1SSOIdentity(output.ssoIdentity, context) : undefined,
+        ssoIdentity: output.ssoIdentity != null ? de_SSOIdentity(output.ssoIdentity, context) : undefined,
     };
 };
-const deserializeAws_restJson1RecipientDetails = (output, context) => {
+const de_RecipientDetails = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1RecipientDetail(entry, context);
+        return de_RecipientDetail(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1ResetTimerAction = (output, context) => {
+const de_ResetTimerAction = (output, context) => {
     return {
         timerName: __expectString(output.timerName),
     };
 };
-const deserializeAws_restJson1RoutedResource = (output, context) => {
+const de_RoutedResource = (output, context) => {
     return {
         arn: __expectString(output.arn),
         name: __expectString(output.name),
     };
 };
-const deserializeAws_restJson1RoutedResources = (output, context) => {
+const de_RoutedResources = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1RoutedResource(entry, context);
+        return de_RoutedResource(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1SetTimerAction = (output, context) => {
+const de_SetTimerAction = (output, context) => {
     return {
         durationExpression: __expectString(output.durationExpression),
         seconds: __expectInt32(output.seconds),
         timerName: __expectString(output.timerName),
     };
 };
-const deserializeAws_restJson1SetVariableAction = (output, context) => {
+const de_SetVariableAction = (output, context) => {
     return {
         value: __expectString(output.value),
         variableName: __expectString(output.variableName),
     };
 };
-const deserializeAws_restJson1SimpleRule = (output, context) => {
+const de_SimpleRule = (output, context) => {
     return {
         comparisonOperator: __expectString(output.comparisonOperator),
         inputProperty: __expectString(output.inputProperty),
         threshold: __expectString(output.threshold),
     };
 };
-const deserializeAws_restJson1SMSConfiguration = (output, context) => {
+const de_SMSConfiguration = (output, context) => {
     return {
         additionalMessage: __expectString(output.additionalMessage),
-        recipients: output.recipients != null ? deserializeAws_restJson1RecipientDetails(output.recipients, context) : undefined,
+        recipients: output.recipients != null ? de_RecipientDetails(output.recipients, context) : undefined,
         senderId: __expectString(output.senderId),
     };
 };
-const deserializeAws_restJson1SMSConfigurations = (output, context) => {
+const de_SMSConfigurations = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1SMSConfiguration(entry, context);
+        return de_SMSConfiguration(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1SNSTopicPublishAction = (output, context) => {
+const de_SNSTopicPublishAction = (output, context) => {
     return {
-        payload: output.payload != null ? deserializeAws_restJson1Payload(output.payload, context) : undefined,
+        payload: output.payload != null ? de_Payload(output.payload, context) : undefined,
         targetArn: __expectString(output.targetArn),
     };
 };
-const deserializeAws_restJson1SqsAction = (output, context) => {
+const de_SqsAction = (output, context) => {
     return {
-        payload: output.payload != null ? deserializeAws_restJson1Payload(output.payload, context) : undefined,
+        payload: output.payload != null ? de_Payload(output.payload, context) : undefined,
         queueUrl: __expectString(output.queueUrl),
         useBase64: __expectBoolean(output.useBase64),
     };
 };
-const deserializeAws_restJson1SSOIdentity = (output, context) => {
+const de_SSOIdentity = (output, context) => {
     return {
         identityStoreId: __expectString(output.identityStoreId),
         userId: __expectString(output.userId),
     };
 };
-const deserializeAws_restJson1State = (output, context) => {
+const de_State = (output, context) => {
     return {
-        onEnter: output.onEnter != null ? deserializeAws_restJson1OnEnterLifecycle(output.onEnter, context) : undefined,
-        onExit: output.onExit != null ? deserializeAws_restJson1OnExitLifecycle(output.onExit, context) : undefined,
-        onInput: output.onInput != null ? deserializeAws_restJson1OnInputLifecycle(output.onInput, context) : undefined,
+        onEnter: output.onEnter != null ? de_OnEnterLifecycle(output.onEnter, context) : undefined,
+        onExit: output.onExit != null ? de_OnExitLifecycle(output.onExit, context) : undefined,
+        onInput: output.onInput != null ? de_OnInputLifecycle(output.onInput, context) : undefined,
         stateName: __expectString(output.stateName),
     };
 };
-const deserializeAws_restJson1States = (output, context) => {
+const de_States = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1State(entry, context);
+        return de_State(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1Tag = (output, context) => {
+const de_Tag = (output, context) => {
     return {
         key: __expectString(output.key),
         value: __expectString(output.value),
     };
 };
-const deserializeAws_restJson1Tags = (output, context) => {
+const de_Tags = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1Tag(entry, context);
+        return de_Tag(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1TransitionEvent = (output, context) => {
+const de_TransitionEvent = (output, context) => {
     return {
-        actions: output.actions != null ? deserializeAws_restJson1Actions(output.actions, context) : undefined,
+        actions: output.actions != null ? de_Actions(output.actions, context) : undefined,
         condition: __expectString(output.condition),
         eventName: __expectString(output.eventName),
         nextState: __expectString(output.nextState),
     };
 };
-const deserializeAws_restJson1TransitionEvents = (output, context) => {
+const de_TransitionEvents = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1TransitionEvent(entry, context);
+        return de_TransitionEvent(entry, context);
     });
     return retVal;
 };