@aws-sdk/client-data-pipeline 3.306.0 → 3.309.0

package/dist-es/protocols/Aws_json1_1.js

@@ -2,191 +2,191 @@ import { HttpRequest as __HttpRequest } from "@aws-sdk/protocol-http";
 import { decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectString as __expectString, throwDefaultError, } from "@aws-sdk/smithy-client";
 import { DataPipelineServiceException as __BaseException } from "../models/DataPipelineServiceException";
 import { InternalServiceError, InvalidRequestException, PipelineDeletedException, PipelineNotFoundException, TaskNotFoundException, } from "../models/models_0";
-export const serializeAws_json1_1ActivatePipelineCommand = async (input, context) => {
+export const se_ActivatePipelineCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "DataPipeline.ActivatePipeline",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1ActivatePipelineInput(input, context));
+    body = JSON.stringify(se_ActivatePipelineInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1AddTagsCommand = async (input, context) => {
+export const se_AddTagsCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "DataPipeline.AddTags",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1AddTagsInput(input, context));
+    body = JSON.stringify(se_AddTagsInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1CreatePipelineCommand = async (input, context) => {
+export const se_CreatePipelineCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "DataPipeline.CreatePipeline",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1CreatePipelineInput(input, context));
+    body = JSON.stringify(se_CreatePipelineInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1DeactivatePipelineCommand = async (input, context) => {
+export const se_DeactivatePipelineCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "DataPipeline.DeactivatePipeline",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1DeactivatePipelineInput(input, context));
+    body = JSON.stringify(se_DeactivatePipelineInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1DeletePipelineCommand = async (input, context) => {
+export const se_DeletePipelineCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "DataPipeline.DeletePipeline",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1DeletePipelineInput(input, context));
+    body = JSON.stringify(se_DeletePipelineInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1DescribeObjectsCommand = async (input, context) => {
+export const se_DescribeObjectsCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "DataPipeline.DescribeObjects",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1DescribeObjectsInput(input, context));
+    body = JSON.stringify(se_DescribeObjectsInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1DescribePipelinesCommand = async (input, context) => {
+export const se_DescribePipelinesCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "DataPipeline.DescribePipelines",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1DescribePipelinesInput(input, context));
+    body = JSON.stringify(se_DescribePipelinesInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1EvaluateExpressionCommand = async (input, context) => {
+export const se_EvaluateExpressionCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "DataPipeline.EvaluateExpression",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1EvaluateExpressionInput(input, context));
+    body = JSON.stringify(se_EvaluateExpressionInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1GetPipelineDefinitionCommand = async (input, context) => {
+export const se_GetPipelineDefinitionCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "DataPipeline.GetPipelineDefinition",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1GetPipelineDefinitionInput(input, context));
+    body = JSON.stringify(se_GetPipelineDefinitionInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1ListPipelinesCommand = async (input, context) => {
+export const se_ListPipelinesCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "DataPipeline.ListPipelines",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1ListPipelinesInput(input, context));
+    body = JSON.stringify(se_ListPipelinesInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1PollForTaskCommand = async (input, context) => {
+export const se_PollForTaskCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "DataPipeline.PollForTask",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1PollForTaskInput(input, context));
+    body = JSON.stringify(se_PollForTaskInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1PutPipelineDefinitionCommand = async (input, context) => {
+export const se_PutPipelineDefinitionCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "DataPipeline.PutPipelineDefinition",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1PutPipelineDefinitionInput(input, context));
+    body = JSON.stringify(se_PutPipelineDefinitionInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1QueryObjectsCommand = async (input, context) => {
+export const se_QueryObjectsCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "DataPipeline.QueryObjects",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1QueryObjectsInput(input, context));
+    body = JSON.stringify(se_QueryObjectsInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1RemoveTagsCommand = async (input, context) => {
+export const se_RemoveTagsCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "DataPipeline.RemoveTags",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1RemoveTagsInput(input, context));
+    body = JSON.stringify(se_RemoveTagsInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1ReportTaskProgressCommand = async (input, context) => {
+export const se_ReportTaskProgressCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "DataPipeline.ReportTaskProgress",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1ReportTaskProgressInput(input, context));
+    body = JSON.stringify(se_ReportTaskProgressInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1ReportTaskRunnerHeartbeatCommand = async (input, context) => {
+export const se_ReportTaskRunnerHeartbeatCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "DataPipeline.ReportTaskRunnerHeartbeat",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1ReportTaskRunnerHeartbeatInput(input, context));
+    body = JSON.stringify(se_ReportTaskRunnerHeartbeatInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1SetStatusCommand = async (input, context) => {
+export const se_SetStatusCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "DataPipeline.SetStatus",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1SetStatusInput(input, context));
+    body = JSON.stringify(se_SetStatusInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1SetTaskStatusCommand = async (input, context) => {
+export const se_SetTaskStatusCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "DataPipeline.SetTaskStatus",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1SetTaskStatusInput(input, context));
+    body = JSON.stringify(se_SetTaskStatusInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1ValidatePipelineDefinitionCommand = async (input, context) => {
+export const se_ValidatePipelineDefinitionCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "DataPipeline.ValidatePipelineDefinition",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1ValidatePipelineDefinitionInput(input, context));
+    body = JSON.stringify(se_ValidatePipelineDefinitionInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const deserializeAws_json1_1ActivatePipelineCommand = async (output, context) => {
+export const de_ActivatePipelineCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1ActivatePipelineCommandError(output, context);
+        return de_ActivatePipelineCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1ActivatePipelineOutput(data, context);
+    contents = de_ActivatePipelineOutput(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1ActivatePipelineCommandError = async (output, context) => {
+const de_ActivatePipelineCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -195,16 +195,16 @@ const deserializeAws_json1_1ActivatePipelineCommandError = async (output, contex
     switch (errorCode) {
         case "InternalServiceError":
         case "com.amazonaws.datapipeline#InternalServiceError":
-            throw await deserializeAws_json1_1InternalServiceErrorResponse(parsedOutput, context);
+            throw await de_InternalServiceErrorRes(parsedOutput, context);
         case "InvalidRequestException":
         case "com.amazonaws.datapipeline#InvalidRequestException":
-            throw await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context);
+            throw await de_InvalidRequestExceptionRes(parsedOutput, context);
         case "PipelineDeletedException":
         case "com.amazonaws.datapipeline#PipelineDeletedException":
-            throw await deserializeAws_json1_1PipelineDeletedExceptionResponse(parsedOutput, context);
+            throw await de_PipelineDeletedExceptionRes(parsedOutput, context);
         case "PipelineNotFoundException":
         case "com.amazonaws.datapipeline#PipelineNotFoundException":
-            throw await deserializeAws_json1_1PipelineNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_PipelineNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -215,20 +215,20 @@ const deserializeAws_json1_1ActivatePipelineCommandError = async (output, contex
             });
     }
 };
-export const deserializeAws_json1_1AddTagsCommand = async (output, context) => {
+export const de_AddTagsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1AddTagsCommandError(output, context);
+        return de_AddTagsCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1AddTagsOutput(data, context);
+    contents = de_AddTagsOutput(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1AddTagsCommandError = async (output, context) => {
+const de_AddTagsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -237,16 +237,16 @@ const deserializeAws_json1_1AddTagsCommandError = async (output, context) => {
     switch (errorCode) {
         case "InternalServiceError":
         case "com.amazonaws.datapipeline#InternalServiceError":
-            throw await deserializeAws_json1_1InternalServiceErrorResponse(parsedOutput, context);
+            throw await de_InternalServiceErrorRes(parsedOutput, context);
         case "InvalidRequestException":
         case "com.amazonaws.datapipeline#InvalidRequestException":
-            throw await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context);
+            throw await de_InvalidRequestExceptionRes(parsedOutput, context);
         case "PipelineDeletedException":
         case "com.amazonaws.datapipeline#PipelineDeletedException":
-            throw await deserializeAws_json1_1PipelineDeletedExceptionResponse(parsedOutput, context);
+            throw await de_PipelineDeletedExceptionRes(parsedOutput, context);
         case "PipelineNotFoundException":
         case "com.amazonaws.datapipeline#PipelineNotFoundException":
-            throw await deserializeAws_json1_1PipelineNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_PipelineNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -257,20 +257,20 @@ const deserializeAws_json1_1AddTagsCommandError = async (output, context) => {
             });
     }
 };
-export const deserializeAws_json1_1CreatePipelineCommand = async (output, context) => {
+export const de_CreatePipelineCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1CreatePipelineCommandError(output, context);
+        return de_CreatePipelineCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1CreatePipelineOutput(data, context);
+    contents = de_CreatePipelineOutput(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1CreatePipelineCommandError = async (output, context) => {
+const de_CreatePipelineCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -279,10 +279,10 @@ const deserializeAws_json1_1CreatePipelineCommandError = async (output, context)
     switch (errorCode) {
         case "InternalServiceError":
         case "com.amazonaws.datapipeline#InternalServiceError":
-            throw await deserializeAws_json1_1InternalServiceErrorResponse(parsedOutput, context);
+            throw await de_InternalServiceErrorRes(parsedOutput, context);
         case "InvalidRequestException":
         case "com.amazonaws.datapipeline#InvalidRequestException":
-            throw await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context);
+            throw await de_InvalidRequestExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -293,20 +293,20 @@ const deserializeAws_json1_1CreatePipelineCommandError = async (output, context)
             });
     }
 };
-export const deserializeAws_json1_1DeactivatePipelineCommand = async (output, context) => {
+export const de_DeactivatePipelineCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1DeactivatePipelineCommandError(output, context);
+        return de_DeactivatePipelineCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1DeactivatePipelineOutput(data, context);
+    contents = de_DeactivatePipelineOutput(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1DeactivatePipelineCommandError = async (output, context) => {
+const de_DeactivatePipelineCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -315,16 +315,16 @@ const deserializeAws_json1_1DeactivatePipelineCommandError = async (output, cont
     switch (errorCode) {
         case "InternalServiceError":
         case "com.amazonaws.datapipeline#InternalServiceError":
-            throw await deserializeAws_json1_1InternalServiceErrorResponse(parsedOutput, context);
+            throw await de_InternalServiceErrorRes(parsedOutput, context);
         case "InvalidRequestException":
         case "com.amazonaws.datapipeline#InvalidRequestException":
-            throw await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context);
+            throw await de_InvalidRequestExceptionRes(parsedOutput, context);
         case "PipelineDeletedException":
         case "com.amazonaws.datapipeline#PipelineDeletedException":
-            throw await deserializeAws_json1_1PipelineDeletedExceptionResponse(parsedOutput, context);
+            throw await de_PipelineDeletedExceptionRes(parsedOutput, context);
         case "PipelineNotFoundException":
         case "com.amazonaws.datapipeline#PipelineNotFoundException":
-            throw await deserializeAws_json1_1PipelineNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_PipelineNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -335,9 +335,9 @@ const deserializeAws_json1_1DeactivatePipelineCommandError = async (output, cont
             });
     }
 };
-export const deserializeAws_json1_1DeletePipelineCommand = async (output, context) => {
+export const de_DeletePipelineCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1DeletePipelineCommandError(output, context);
+        return de_DeletePipelineCommandError(output, context);
     }
     await collectBody(output.body, context);
     const response = {
@@ -345,7 +345,7 @@ export const deserializeAws_json1_1DeletePipelineCommand = async (output, contex
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1DeletePipelineCommandError = async (output, context) => {
+const de_DeletePipelineCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -354,13 +354,13 @@ const deserializeAws_json1_1DeletePipelineCommandError = async (output, context)
     switch (errorCode) {
         case "InternalServiceError":
         case "com.amazonaws.datapipeline#InternalServiceError":
-            throw await deserializeAws_json1_1InternalServiceErrorResponse(parsedOutput, context);
+            throw await de_InternalServiceErrorRes(parsedOutput, context);
         case "InvalidRequestException":
         case "com.amazonaws.datapipeline#InvalidRequestException":
-            throw await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context);
+            throw await de_InvalidRequestExceptionRes(parsedOutput, context);
         case "PipelineNotFoundException":
         case "com.amazonaws.datapipeline#PipelineNotFoundException":
-            throw await deserializeAws_json1_1PipelineNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_PipelineNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -371,20 +371,20 @@ const deserializeAws_json1_1DeletePipelineCommandError = async (output, context)
             });
     }
 };
-export const deserializeAws_json1_1DescribeObjectsCommand = async (output, context) => {
+export const de_DescribeObjectsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1DescribeObjectsCommandError(output, context);
+        return de_DescribeObjectsCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1DescribeObjectsOutput(data, context);
+    contents = de_DescribeObjectsOutput(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1DescribeObjectsCommandError = async (output, context) => {
+const de_DescribeObjectsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -393,16 +393,16 @@ const deserializeAws_json1_1DescribeObjectsCommandError = async (output, context
     switch (errorCode) {
         case "InternalServiceError":
         case "com.amazonaws.datapipeline#InternalServiceError":
-            throw await deserializeAws_json1_1InternalServiceErrorResponse(parsedOutput, context);
+            throw await de_InternalServiceErrorRes(parsedOutput, context);
         case "InvalidRequestException":
         case "com.amazonaws.datapipeline#InvalidRequestException":
-            throw await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context);
+            throw await de_InvalidRequestExceptionRes(parsedOutput, context);
         case "PipelineDeletedException":
         case "com.amazonaws.datapipeline#PipelineDeletedException":
-            throw await deserializeAws_json1_1PipelineDeletedExceptionResponse(parsedOutput, context);
+            throw await de_PipelineDeletedExceptionRes(parsedOutput, context);
         case "PipelineNotFoundException":
         case "com.amazonaws.datapipeline#PipelineNotFoundException":
-            throw await deserializeAws_json1_1PipelineNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_PipelineNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -413,20 +413,20 @@ const deserializeAws_json1_1DescribeObjectsCommandError = async (output, context
             });
     }
 };
-export const deserializeAws_json1_1DescribePipelinesCommand = async (output, context) => {
+export const de_DescribePipelinesCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1DescribePipelinesCommandError(output, context);
+        return de_DescribePipelinesCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1DescribePipelinesOutput(data, context);
+    contents = de_DescribePipelinesOutput(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1DescribePipelinesCommandError = async (output, context) => {
+const de_DescribePipelinesCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -435,16 +435,16 @@ const deserializeAws_json1_1DescribePipelinesCommandError = async (output, conte
     switch (errorCode) {
         case "InternalServiceError":
         case "com.amazonaws.datapipeline#InternalServiceError":
-            throw await deserializeAws_json1_1InternalServiceErrorResponse(parsedOutput, context);
+            throw await de_InternalServiceErrorRes(parsedOutput, context);
         case "InvalidRequestException":
         case "com.amazonaws.datapipeline#InvalidRequestException":
-            throw await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context);
+            throw await de_InvalidRequestExceptionRes(parsedOutput, context);
         case "PipelineDeletedException":
         case "com.amazonaws.datapipeline#PipelineDeletedException":
-            throw await deserializeAws_json1_1PipelineDeletedExceptionResponse(parsedOutput, context);
+            throw await de_PipelineDeletedExceptionRes(parsedOutput, context);
         case "PipelineNotFoundException":
         case "com.amazonaws.datapipeline#PipelineNotFoundException":
-            throw await deserializeAws_json1_1PipelineNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_PipelineNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -455,20 +455,20 @@ const deserializeAws_json1_1DescribePipelinesCommandError = async (output, conte
             });
     }
 };
-export const deserializeAws_json1_1EvaluateExpressionCommand = async (output, context) => {
+export const de_EvaluateExpressionCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1EvaluateExpressionCommandError(output, context);
+        return de_EvaluateExpressionCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1EvaluateExpressionOutput(data, context);
+    contents = de_EvaluateExpressionOutput(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1EvaluateExpressionCommandError = async (output, context) => {
+const de_EvaluateExpressionCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -477,19 +477,19 @@ const deserializeAws_json1_1EvaluateExpressionCommandError = async (output, cont
     switch (errorCode) {
         case "InternalServiceError":
         case "com.amazonaws.datapipeline#InternalServiceError":
-            throw await deserializeAws_json1_1InternalServiceErrorResponse(parsedOutput, context);
+            throw await de_InternalServiceErrorRes(parsedOutput, context);
         case "InvalidRequestException":
         case "com.amazonaws.datapipeline#InvalidRequestException":
-            throw await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context);
+            throw await de_InvalidRequestExceptionRes(parsedOutput, context);
         case "PipelineDeletedException":
         case "com.amazonaws.datapipeline#PipelineDeletedException":
-            throw await deserializeAws_json1_1PipelineDeletedExceptionResponse(parsedOutput, context);
+            throw await de_PipelineDeletedExceptionRes(parsedOutput, context);
         case "PipelineNotFoundException":
         case "com.amazonaws.datapipeline#PipelineNotFoundException":
-            throw await deserializeAws_json1_1PipelineNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_PipelineNotFoundExceptionRes(parsedOutput, context);
         case "TaskNotFoundException":
         case "com.amazonaws.datapipeline#TaskNotFoundException":
-            throw await deserializeAws_json1_1TaskNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_TaskNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -500,20 +500,20 @@ const deserializeAws_json1_1EvaluateExpressionCommandError = async (output, cont
             });
     }
 };
-export const deserializeAws_json1_1GetPipelineDefinitionCommand = async (output, context) => {
+export const de_GetPipelineDefinitionCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1GetPipelineDefinitionCommandError(output, context);
+        return de_GetPipelineDefinitionCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1GetPipelineDefinitionOutput(data, context);
+    contents = de_GetPipelineDefinitionOutput(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1GetPipelineDefinitionCommandError = async (output, context) => {
+const de_GetPipelineDefinitionCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -522,16 +522,16 @@ const deserializeAws_json1_1GetPipelineDefinitionCommandError = async (output, c
     switch (errorCode) {
         case "InternalServiceError":
         case "com.amazonaws.datapipeline#InternalServiceError":
-            throw await deserializeAws_json1_1InternalServiceErrorResponse(parsedOutput, context);
+            throw await de_InternalServiceErrorRes(parsedOutput, context);
         case "InvalidRequestException":
         case "com.amazonaws.datapipeline#InvalidRequestException":
-            throw await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context);
+            throw await de_InvalidRequestExceptionRes(parsedOutput, context);
         case "PipelineDeletedException":
         case "com.amazonaws.datapipeline#PipelineDeletedException":
-            throw await deserializeAws_json1_1PipelineDeletedExceptionResponse(parsedOutput, context);
+            throw await de_PipelineDeletedExceptionRes(parsedOutput, context);
         case "PipelineNotFoundException":
         case "com.amazonaws.datapipeline#PipelineNotFoundException":
-            throw await deserializeAws_json1_1PipelineNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_PipelineNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -542,20 +542,20 @@ const deserializeAws_json1_1GetPipelineDefinitionCommandError = async (output, c
             });
     }
 };
-export const deserializeAws_json1_1ListPipelinesCommand = async (output, context) => {
+export const de_ListPipelinesCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1ListPipelinesCommandError(output, context);
+        return de_ListPipelinesCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1ListPipelinesOutput(data, context);
+    contents = de_ListPipelinesOutput(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1ListPipelinesCommandError = async (output, context) => {
+const de_ListPipelinesCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -564,10 +564,10 @@ const deserializeAws_json1_1ListPipelinesCommandError = async (output, context)
     switch (errorCode) {
         case "InternalServiceError":
         case "com.amazonaws.datapipeline#InternalServiceError":
-            throw await deserializeAws_json1_1InternalServiceErrorResponse(parsedOutput, context);
+            throw await de_InternalServiceErrorRes(parsedOutput, context);
         case "InvalidRequestException":
         case "com.amazonaws.datapipeline#InvalidRequestException":
-            throw await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context);
+            throw await de_InvalidRequestExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -578,20 +578,20 @@ const deserializeAws_json1_1ListPipelinesCommandError = async (output, context)
             });
     }
 };
-export const deserializeAws_json1_1PollForTaskCommand = async (output, context) => {
+export const de_PollForTaskCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1PollForTaskCommandError(output, context);
+        return de_PollForTaskCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1PollForTaskOutput(data, context);
+    contents = de_PollForTaskOutput(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1PollForTaskCommandError = async (output, context) => {
+const de_PollForTaskCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -600,13 +600,13 @@ const deserializeAws_json1_1PollForTaskCommandError = async (output, context) =>
     switch (errorCode) {
         case "InternalServiceError":
         case "com.amazonaws.datapipeline#InternalServiceError":
-            throw await deserializeAws_json1_1InternalServiceErrorResponse(parsedOutput, context);
+            throw await de_InternalServiceErrorRes(parsedOutput, context);
         case "InvalidRequestException":
         case "com.amazonaws.datapipeline#InvalidRequestException":
-            throw await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context);
+            throw await de_InvalidRequestExceptionRes(parsedOutput, context);
         case "TaskNotFoundException":
         case "com.amazonaws.datapipeline#TaskNotFoundException":
-            throw await deserializeAws_json1_1TaskNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_TaskNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -617,20 +617,20 @@ const deserializeAws_json1_1PollForTaskCommandError = async (output, context) =>
             });
     }
 };
-export const deserializeAws_json1_1PutPipelineDefinitionCommand = async (output, context) => {
+export const de_PutPipelineDefinitionCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1PutPipelineDefinitionCommandError(output, context);
+        return de_PutPipelineDefinitionCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1PutPipelineDefinitionOutput(data, context);
+    contents = de_PutPipelineDefinitionOutput(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1PutPipelineDefinitionCommandError = async (output, context) => {
+const de_PutPipelineDefinitionCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -639,16 +639,16 @@ const deserializeAws_json1_1PutPipelineDefinitionCommandError = async (output, c
     switch (errorCode) {
         case "InternalServiceError":
         case "com.amazonaws.datapipeline#InternalServiceError":
-            throw await deserializeAws_json1_1InternalServiceErrorResponse(parsedOutput, context);
+            throw await de_InternalServiceErrorRes(parsedOutput, context);
         case "InvalidRequestException":
         case "com.amazonaws.datapipeline#InvalidRequestException":
-            throw await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context);
+            throw await de_InvalidRequestExceptionRes(parsedOutput, context);
         case "PipelineDeletedException":
         case "com.amazonaws.datapipeline#PipelineDeletedException":
-            throw await deserializeAws_json1_1PipelineDeletedExceptionResponse(parsedOutput, context);
+            throw await de_PipelineDeletedExceptionRes(parsedOutput, context);
         case "PipelineNotFoundException":
         case "com.amazonaws.datapipeline#PipelineNotFoundException":
-            throw await deserializeAws_json1_1PipelineNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_PipelineNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -659,20 +659,20 @@ const deserializeAws_json1_1PutPipelineDefinitionCommandError = async (output, c
             });
     }
 };
-export const deserializeAws_json1_1QueryObjectsCommand = async (output, context) => {
+export const de_QueryObjectsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1QueryObjectsCommandError(output, context);
+        return de_QueryObjectsCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1QueryObjectsOutput(data, context);
+    contents = de_QueryObjectsOutput(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1QueryObjectsCommandError = async (output, context) => {
+const de_QueryObjectsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -681,16 +681,16 @@ const deserializeAws_json1_1QueryObjectsCommandError = async (output, context) =
     switch (errorCode) {
         case "InternalServiceError":
         case "com.amazonaws.datapipeline#InternalServiceError":
-            throw await deserializeAws_json1_1InternalServiceErrorResponse(parsedOutput, context);
+            throw await de_InternalServiceErrorRes(parsedOutput, context);
         case "InvalidRequestException":
         case "com.amazonaws.datapipeline#InvalidRequestException":
-            throw await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context);
+            throw await de_InvalidRequestExceptionRes(parsedOutput, context);
         case "PipelineDeletedException":
         case "com.amazonaws.datapipeline#PipelineDeletedException":
-            throw await deserializeAws_json1_1PipelineDeletedExceptionResponse(parsedOutput, context);
+            throw await de_PipelineDeletedExceptionRes(parsedOutput, context);
         case "PipelineNotFoundException":
         case "com.amazonaws.datapipeline#PipelineNotFoundException":
-            throw await deserializeAws_json1_1PipelineNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_PipelineNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -701,20 +701,20 @@ const deserializeAws_json1_1QueryObjectsCommandError = async (output, context) =
             });
     }
 };
-export const deserializeAws_json1_1RemoveTagsCommand = async (output, context) => {
+export const de_RemoveTagsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1RemoveTagsCommandError(output, context);
+        return de_RemoveTagsCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1RemoveTagsOutput(data, context);
+    contents = de_RemoveTagsOutput(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1RemoveTagsCommandError = async (output, context) => {
+const de_RemoveTagsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -723,16 +723,16 @@ const deserializeAws_json1_1RemoveTagsCommandError = async (output, context) =>
     switch (errorCode) {
         case "InternalServiceError":
         case "com.amazonaws.datapipeline#InternalServiceError":
-            throw await deserializeAws_json1_1InternalServiceErrorResponse(parsedOutput, context);
+            throw await de_InternalServiceErrorRes(parsedOutput, context);
         case "InvalidRequestException":
         case "com.amazonaws.datapipeline#InvalidRequestException":
-            throw await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context);
+            throw await de_InvalidRequestExceptionRes(parsedOutput, context);
         case "PipelineDeletedException":
         case "com.amazonaws.datapipeline#PipelineDeletedException":
-            throw await deserializeAws_json1_1PipelineDeletedExceptionResponse(parsedOutput, context);
+            throw await de_PipelineDeletedExceptionRes(parsedOutput, context);
         case "PipelineNotFoundException":
         case "com.amazonaws.datapipeline#PipelineNotFoundException":
-            throw await deserializeAws_json1_1PipelineNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_PipelineNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -743,20 +743,20 @@ const deserializeAws_json1_1RemoveTagsCommandError = async (output, context) =>
             });
     }
 };
-export const deserializeAws_json1_1ReportTaskProgressCommand = async (output, context) => {
+export const de_ReportTaskProgressCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1ReportTaskProgressCommandError(output, context);
+        return de_ReportTaskProgressCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1ReportTaskProgressOutput(data, context);
+    contents = de_ReportTaskProgressOutput(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1ReportTaskProgressCommandError = async (output, context) => {
+const de_ReportTaskProgressCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -765,19 +765,19 @@ const deserializeAws_json1_1ReportTaskProgressCommandError = async (output, cont
     switch (errorCode) {
         case "InternalServiceError":
         case "com.amazonaws.datapipeline#InternalServiceError":
-            throw await deserializeAws_json1_1InternalServiceErrorResponse(parsedOutput, context);
+            throw await de_InternalServiceErrorRes(parsedOutput, context);
         case "InvalidRequestException":
         case "com.amazonaws.datapipeline#InvalidRequestException":
-            throw await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context);
+            throw await de_InvalidRequestExceptionRes(parsedOutput, context);
         case "PipelineDeletedException":
         case "com.amazonaws.datapipeline#PipelineDeletedException":
-            throw await deserializeAws_json1_1PipelineDeletedExceptionResponse(parsedOutput, context);
+            throw await de_PipelineDeletedExceptionRes(parsedOutput, context);
         case "PipelineNotFoundException":
         case "com.amazonaws.datapipeline#PipelineNotFoundException":
-            throw await deserializeAws_json1_1PipelineNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_PipelineNotFoundExceptionRes(parsedOutput, context);
         case "TaskNotFoundException":
         case "com.amazonaws.datapipeline#TaskNotFoundException":
-            throw await deserializeAws_json1_1TaskNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_TaskNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -788,20 +788,20 @@ const deserializeAws_json1_1ReportTaskProgressCommandError = async (output, cont
             });
     }
 };
-export const deserializeAws_json1_1ReportTaskRunnerHeartbeatCommand = async (output, context) => {
+export const de_ReportTaskRunnerHeartbeatCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1ReportTaskRunnerHeartbeatCommandError(output, context);
+        return de_ReportTaskRunnerHeartbeatCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1ReportTaskRunnerHeartbeatOutput(data, context);
+    contents = de_ReportTaskRunnerHeartbeatOutput(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1ReportTaskRunnerHeartbeatCommandError = async (output, context) => {
+const de_ReportTaskRunnerHeartbeatCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -810,10 +810,10 @@ const deserializeAws_json1_1ReportTaskRunnerHeartbeatCommandError = async (outpu
     switch (errorCode) {
         case "InternalServiceError":
         case "com.amazonaws.datapipeline#InternalServiceError":
-            throw await deserializeAws_json1_1InternalServiceErrorResponse(parsedOutput, context);
+            throw await de_InternalServiceErrorRes(parsedOutput, context);
         case "InvalidRequestException":
         case "com.amazonaws.datapipeline#InvalidRequestException":
-            throw await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context);
+            throw await de_InvalidRequestExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -824,9 +824,9 @@ const deserializeAws_json1_1ReportTaskRunnerHeartbeatCommandError = async (outpu
             });
     }
 };
-export const deserializeAws_json1_1SetStatusCommand = async (output, context) => {
+export const de_SetStatusCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1SetStatusCommandError(output, context);
+        return de_SetStatusCommandError(output, context);
     }
     await collectBody(output.body, context);
     const response = {
@@ -834,7 +834,7 @@ export const deserializeAws_json1_1SetStatusCommand = async (output, context) =>
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1SetStatusCommandError = async (output, context) => {
+const de_SetStatusCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -843,16 +843,16 @@ const deserializeAws_json1_1SetStatusCommandError = async (output, context) => {
     switch (errorCode) {
         case "InternalServiceError":
         case "com.amazonaws.datapipeline#InternalServiceError":
-            throw await deserializeAws_json1_1InternalServiceErrorResponse(parsedOutput, context);
+            throw await de_InternalServiceErrorRes(parsedOutput, context);
         case "InvalidRequestException":
         case "com.amazonaws.datapipeline#InvalidRequestException":
-            throw await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context);
+            throw await de_InvalidRequestExceptionRes(parsedOutput, context);
         case "PipelineDeletedException":
         case "com.amazonaws.datapipeline#PipelineDeletedException":
-            throw await deserializeAws_json1_1PipelineDeletedExceptionResponse(parsedOutput, context);
+            throw await de_PipelineDeletedExceptionRes(parsedOutput, context);
         case "PipelineNotFoundException":
         case "com.amazonaws.datapipeline#PipelineNotFoundException":
-            throw await deserializeAws_json1_1PipelineNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_PipelineNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -863,20 +863,20 @@ const deserializeAws_json1_1SetStatusCommandError = async (output, context) => {
             });
     }
 };
-export const deserializeAws_json1_1SetTaskStatusCommand = async (output, context) => {
+export const de_SetTaskStatusCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1SetTaskStatusCommandError(output, context);
+        return de_SetTaskStatusCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1SetTaskStatusOutput(data, context);
+    contents = de_SetTaskStatusOutput(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1SetTaskStatusCommandError = async (output, context) => {
+const de_SetTaskStatusCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -885,19 +885,19 @@ const deserializeAws_json1_1SetTaskStatusCommandError = async (output, context)
     switch (errorCode) {
         case "InternalServiceError":
         case "com.amazonaws.datapipeline#InternalServiceError":
-            throw await deserializeAws_json1_1InternalServiceErrorResponse(parsedOutput, context);
+            throw await de_InternalServiceErrorRes(parsedOutput, context);
         case "InvalidRequestException":
         case "com.amazonaws.datapipeline#InvalidRequestException":
-            throw await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context);
+            throw await de_InvalidRequestExceptionRes(parsedOutput, context);
         case "PipelineDeletedException":
         case "com.amazonaws.datapipeline#PipelineDeletedException":
-            throw await deserializeAws_json1_1PipelineDeletedExceptionResponse(parsedOutput, context);
+            throw await de_PipelineDeletedExceptionRes(parsedOutput, context);
         case "PipelineNotFoundException":
         case "com.amazonaws.datapipeline#PipelineNotFoundException":
-            throw await deserializeAws_json1_1PipelineNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_PipelineNotFoundExceptionRes(parsedOutput, context);
         case "TaskNotFoundException":
         case "com.amazonaws.datapipeline#TaskNotFoundException":
-            throw await deserializeAws_json1_1TaskNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_TaskNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -908,20 +908,20 @@ const deserializeAws_json1_1SetTaskStatusCommandError = async (output, context)
             });
     }
 };
-export const deserializeAws_json1_1ValidatePipelineDefinitionCommand = async (output, context) => {
+export const de_ValidatePipelineDefinitionCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1ValidatePipelineDefinitionCommandError(output, context);
+        return de_ValidatePipelineDefinitionCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1ValidatePipelineDefinitionOutput(data, context);
+    contents = de_ValidatePipelineDefinitionOutput(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1ValidatePipelineDefinitionCommandError = async (output, context) => {
+const de_ValidatePipelineDefinitionCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -930,16 +930,16 @@ const deserializeAws_json1_1ValidatePipelineDefinitionCommandError = async (outp
     switch (errorCode) {
         case "InternalServiceError":
         case "com.amazonaws.datapipeline#InternalServiceError":
-            throw await deserializeAws_json1_1InternalServiceErrorResponse(parsedOutput, context);
+            throw await de_InternalServiceErrorRes(parsedOutput, context);
         case "InvalidRequestException":
         case "com.amazonaws.datapipeline#InvalidRequestException":
-            throw await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context);
+            throw await de_InvalidRequestExceptionRes(parsedOutput, context);
         case "PipelineDeletedException":
         case "com.amazonaws.datapipeline#PipelineDeletedException":
-            throw await deserializeAws_json1_1PipelineDeletedExceptionResponse(parsedOutput, context);
+            throw await de_PipelineDeletedExceptionRes(parsedOutput, context);
         case "PipelineNotFoundException":
         case "com.amazonaws.datapipeline#PipelineNotFoundException":
-            throw await deserializeAws_json1_1PipelineNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_PipelineNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -950,281 +950,271 @@ const deserializeAws_json1_1ValidatePipelineDefinitionCommandError = async (outp
             });
     }
 };
-const deserializeAws_json1_1InternalServiceErrorResponse = async (parsedOutput, context) => {
+const de_InternalServiceErrorRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_1InternalServiceError(body, context);
+    const deserialized = de_InternalServiceError(body, context);
     const exception = new InternalServiceError({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_json1_1InvalidRequestExceptionResponse = async (parsedOutput, context) => {
+const de_InvalidRequestExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_1InvalidRequestException(body, context);
+    const deserialized = de_InvalidRequestException(body, context);
     const exception = new InvalidRequestException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_json1_1PipelineDeletedExceptionResponse = async (parsedOutput, context) => {
+const de_PipelineDeletedExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_1PipelineDeletedException(body, context);
+    const deserialized = de_PipelineDeletedException(body, context);
     const exception = new PipelineDeletedException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_json1_1PipelineNotFoundExceptionResponse = async (parsedOutput, context) => {
+const de_PipelineNotFoundExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_1PipelineNotFoundException(body, context);
+    const deserialized = de_PipelineNotFoundException(body, context);
     const exception = new PipelineNotFoundException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_json1_1TaskNotFoundExceptionResponse = async (parsedOutput, context) => {
+const de_TaskNotFoundExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_1TaskNotFoundException(body, context);
+    const deserialized = de_TaskNotFoundException(body, context);
     const exception = new TaskNotFoundException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const serializeAws_json1_1ActivatePipelineInput = (input, context) => {
+const se_ActivatePipelineInput = (input, context) => {
     return {
-        ...(input.parameterValues != null && {
-            parameterValues: serializeAws_json1_1ParameterValueList(input.parameterValues, context),
-        }),
+        ...(input.parameterValues != null && { parameterValues: se_ParameterValueList(input.parameterValues, context) }),
         ...(input.pipelineId != null && { pipelineId: input.pipelineId }),
         ...(input.startTimestamp != null && { startTimestamp: Math.round(input.startTimestamp.getTime() / 1000) }),
     };
 };
-const serializeAws_json1_1AddTagsInput = (input, context) => {
+const se_AddTagsInput = (input, context) => {
     return {
         ...(input.pipelineId != null && { pipelineId: input.pipelineId }),
-        ...(input.tags != null && { tags: serializeAws_json1_1tagList(input.tags, context) }),
+        ...(input.tags != null && { tags: se_tagList(input.tags, context) }),
     };
 };
-const serializeAws_json1_1CreatePipelineInput = (input, context) => {
+const se_CreatePipelineInput = (input, context) => {
     return {
         ...(input.description != null && { description: input.description }),
         ...(input.name != null && { name: input.name }),
-        ...(input.tags != null && { tags: serializeAws_json1_1tagList(input.tags, context) }),
+        ...(input.tags != null && { tags: se_tagList(input.tags, context) }),
         ...(input.uniqueId != null && { uniqueId: input.uniqueId }),
     };
 };
-const serializeAws_json1_1DeactivatePipelineInput = (input, context) => {
+const se_DeactivatePipelineInput = (input, context) => {
     return {
         ...(input.cancelActive != null && { cancelActive: input.cancelActive }),
         ...(input.pipelineId != null && { pipelineId: input.pipelineId }),
     };
 };
-const serializeAws_json1_1DeletePipelineInput = (input, context) => {
+const se_DeletePipelineInput = (input, context) => {
     return {
         ...(input.pipelineId != null && { pipelineId: input.pipelineId }),
     };
 };
-const serializeAws_json1_1DescribeObjectsInput = (input, context) => {
+const se_DescribeObjectsInput = (input, context) => {
     return {
         ...(input.evaluateExpressions != null && { evaluateExpressions: input.evaluateExpressions }),
         ...(input.marker != null && { marker: input.marker }),
-        ...(input.objectIds != null && { objectIds: serializeAws_json1_1idList(input.objectIds, context) }),
+        ...(input.objectIds != null && { objectIds: se_idList(input.objectIds, context) }),
         ...(input.pipelineId != null && { pipelineId: input.pipelineId }),
     };
 };
-const serializeAws_json1_1DescribePipelinesInput = (input, context) => {
+const se_DescribePipelinesInput = (input, context) => {
     return {
-        ...(input.pipelineIds != null && { pipelineIds: serializeAws_json1_1idList(input.pipelineIds, context) }),
+        ...(input.pipelineIds != null && { pipelineIds: se_idList(input.pipelineIds, context) }),
     };
 };
-const serializeAws_json1_1EvaluateExpressionInput = (input, context) => {
+const se_EvaluateExpressionInput = (input, context) => {
     return {
         ...(input.expression != null && { expression: input.expression }),
         ...(input.objectId != null && { objectId: input.objectId }),
         ...(input.pipelineId != null && { pipelineId: input.pipelineId }),
     };
 };
-const serializeAws_json1_1Field = (input, context) => {
+const se_Field = (input, context) => {
     return {
         ...(input.key != null && { key: input.key }),
         ...(input.refValue != null && { refValue: input.refValue }),
         ...(input.stringValue != null && { stringValue: input.stringValue }),
     };
 };
-const serializeAws_json1_1fieldList = (input, context) => {
+const se_fieldList = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
-        return serializeAws_json1_1Field(entry, context);
+        return se_Field(entry, context);
     });
 };
-const serializeAws_json1_1GetPipelineDefinitionInput = (input, context) => {
+const se_GetPipelineDefinitionInput = (input, context) => {
     return {
         ...(input.pipelineId != null && { pipelineId: input.pipelineId }),
         ...(input.version != null && { version: input.version }),
     };
 };
-const serializeAws_json1_1idList = (input, context) => {
+const se_idList = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
         return entry;
     });
 };
-const serializeAws_json1_1InstanceIdentity = (input, context) => {
+const se_InstanceIdentity = (input, context) => {
     return {
         ...(input.document != null && { document: input.document }),
         ...(input.signature != null && { signature: input.signature }),
     };
 };
-const serializeAws_json1_1ListPipelinesInput = (input, context) => {
+const se_ListPipelinesInput = (input, context) => {
     return {
         ...(input.marker != null && { marker: input.marker }),
     };
 };
-const serializeAws_json1_1Operator = (input, context) => {
+const se_Operator = (input, context) => {
     return {
         ...(input.type != null && { type: input.type }),
-        ...(input.values != null && { values: serializeAws_json1_1stringList(input.values, context) }),
+        ...(input.values != null && { values: se_stringList(input.values, context) }),
     };
 };
-const serializeAws_json1_1ParameterAttribute = (input, context) => {
+const se_ParameterAttribute = (input, context) => {
     return {
         ...(input.key != null && { key: input.key }),
         ...(input.stringValue != null && { stringValue: input.stringValue }),
     };
 };
-const serializeAws_json1_1ParameterAttributeList = (input, context) => {
+const se_ParameterAttributeList = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
-        return serializeAws_json1_1ParameterAttribute(entry, context);
+        return se_ParameterAttribute(entry, context);
     });
 };
-const serializeAws_json1_1ParameterObject = (input, context) => {
+const se_ParameterObject = (input, context) => {
     return {
-        ...(input.attributes != null && {
-            attributes: serializeAws_json1_1ParameterAttributeList(input.attributes, context),
-        }),
+        ...(input.attributes != null && { attributes: se_ParameterAttributeList(input.attributes, context) }),
         ...(input.id != null && { id: input.id }),
     };
 };
-const serializeAws_json1_1ParameterObjectList = (input, context) => {
+const se_ParameterObjectList = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
-        return serializeAws_json1_1ParameterObject(entry, context);
+        return se_ParameterObject(entry, context);
     });
 };
-const serializeAws_json1_1ParameterValue = (input, context) => {
+const se_ParameterValue = (input, context) => {
     return {
         ...(input.id != null && { id: input.id }),
         ...(input.stringValue != null && { stringValue: input.stringValue }),
     };
 };
-const serializeAws_json1_1ParameterValueList = (input, context) => {
+const se_ParameterValueList = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
-        return serializeAws_json1_1ParameterValue(entry, context);
+        return se_ParameterValue(entry, context);
     });
 };
-const serializeAws_json1_1PipelineObject = (input, context) => {
+const se_PipelineObject = (input, context) => {
     return {
-        ...(input.fields != null && { fields: serializeAws_json1_1fieldList(input.fields, context) }),
+        ...(input.fields != null && { fields: se_fieldList(input.fields, context) }),
         ...(input.id != null && { id: input.id }),
         ...(input.name != null && { name: input.name }),
     };
 };
-const serializeAws_json1_1PipelineObjectList = (input, context) => {
+const se_PipelineObjectList = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
-        return serializeAws_json1_1PipelineObject(entry, context);
+        return se_PipelineObject(entry, context);
     });
 };
-const serializeAws_json1_1PollForTaskInput = (input, context) => {
+const se_PollForTaskInput = (input, context) => {
     return {
         ...(input.hostname != null && { hostname: input.hostname }),
-        ...(input.instanceIdentity != null && {
-            instanceIdentity: serializeAws_json1_1InstanceIdentity(input.instanceIdentity, context),
-        }),
+        ...(input.instanceIdentity != null && { instanceIdentity: se_InstanceIdentity(input.instanceIdentity, context) }),
         ...(input.workerGroup != null && { workerGroup: input.workerGroup }),
     };
 };
-const serializeAws_json1_1PutPipelineDefinitionInput = (input, context) => {
+const se_PutPipelineDefinitionInput = (input, context) => {
     return {
         ...(input.parameterObjects != null && {
-            parameterObjects: serializeAws_json1_1ParameterObjectList(input.parameterObjects, context),
-        }),
-        ...(input.parameterValues != null && {
-            parameterValues: serializeAws_json1_1ParameterValueList(input.parameterValues, context),
+            parameterObjects: se_ParameterObjectList(input.parameterObjects, context),
         }),
+        ...(input.parameterValues != null && { parameterValues: se_ParameterValueList(input.parameterValues, context) }),
         ...(input.pipelineId != null && { pipelineId: input.pipelineId }),
-        ...(input.pipelineObjects != null && {
-            pipelineObjects: serializeAws_json1_1PipelineObjectList(input.pipelineObjects, context),
-        }),
+        ...(input.pipelineObjects != null && { pipelineObjects: se_PipelineObjectList(input.pipelineObjects, context) }),
     };
 };
-const serializeAws_json1_1Query = (input, context) => {
+const se_Query = (input, context) => {
     return {
-        ...(input.selectors != null && { selectors: serializeAws_json1_1SelectorList(input.selectors, context) }),
+        ...(input.selectors != null && { selectors: se_SelectorList(input.selectors, context) }),
     };
 };
-const serializeAws_json1_1QueryObjectsInput = (input, context) => {
+const se_QueryObjectsInput = (input, context) => {
     return {
         ...(input.limit != null && { limit: input.limit }),
         ...(input.marker != null && { marker: input.marker }),
         ...(input.pipelineId != null && { pipelineId: input.pipelineId }),
-        ...(input.query != null && { query: serializeAws_json1_1Query(input.query, context) }),
+        ...(input.query != null && { query: se_Query(input.query, context) }),
         ...(input.sphere != null && { sphere: input.sphere }),
     };
 };
-const serializeAws_json1_1RemoveTagsInput = (input, context) => {
+const se_RemoveTagsInput = (input, context) => {
     return {
         ...(input.pipelineId != null && { pipelineId: input.pipelineId }),
-        ...(input.tagKeys != null && { tagKeys: serializeAws_json1_1stringList(input.tagKeys, context) }),
+        ...(input.tagKeys != null && { tagKeys: se_stringList(input.tagKeys, context) }),
     };
 };
-const serializeAws_json1_1ReportTaskProgressInput = (input, context) => {
+const se_ReportTaskProgressInput = (input, context) => {
     return {
-        ...(input.fields != null && { fields: serializeAws_json1_1fieldList(input.fields, context) }),
+        ...(input.fields != null && { fields: se_fieldList(input.fields, context) }),
         ...(input.taskId != null && { taskId: input.taskId }),
     };
 };
-const serializeAws_json1_1ReportTaskRunnerHeartbeatInput = (input, context) => {
+const se_ReportTaskRunnerHeartbeatInput = (input, context) => {
     return {
         ...(input.hostname != null && { hostname: input.hostname }),
         ...(input.taskrunnerId != null && { taskrunnerId: input.taskrunnerId }),
         ...(input.workerGroup != null && { workerGroup: input.workerGroup }),
     };
 };
-const serializeAws_json1_1Selector = (input, context) => {
+const se_Selector = (input, context) => {
     return {
         ...(input.fieldName != null && { fieldName: input.fieldName }),
-        ...(input.operator != null && { operator: serializeAws_json1_1Operator(input.operator, context) }),
+        ...(input.operator != null && { operator: se_Operator(input.operator, context) }),
     };
 };
-const serializeAws_json1_1SelectorList = (input, context) => {
+const se_SelectorList = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
-        return serializeAws_json1_1Selector(entry, context);
+        return se_Selector(entry, context);
     });
 };
-const serializeAws_json1_1SetStatusInput = (input, context) => {
+const se_SetStatusInput = (input, context) => {
     return {
-        ...(input.objectIds != null && { objectIds: serializeAws_json1_1idList(input.objectIds, context) }),
+        ...(input.objectIds != null && { objectIds: se_idList(input.objectIds, context) }),
         ...(input.pipelineId != null && { pipelineId: input.pipelineId }),
         ...(input.status != null && { status: input.status }),
     };
 };
-const serializeAws_json1_1SetTaskStatusInput = (input, context) => {
+const se_SetTaskStatusInput = (input, context) => {
     return {
         ...(input.errorId != null && { errorId: input.errorId }),
         ...(input.errorMessage != null && { errorMessage: input.errorMessage }),
@@ -1233,107 +1223,95 @@ const serializeAws_json1_1SetTaskStatusInput = (input, context) => {
         ...(input.taskStatus != null && { taskStatus: input.taskStatus }),
     };
 };
-const serializeAws_json1_1stringList = (input, context) => {
+const se_stringList = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
         return entry;
     });
 };
-const serializeAws_json1_1Tag = (input, context) => {
+const se_Tag = (input, context) => {
     return {
         ...(input.key != null && { key: input.key }),
         ...(input.value != null && { value: input.value }),
     };
 };
-const serializeAws_json1_1tagList = (input, context) => {
+const se_tagList = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
-        return serializeAws_json1_1Tag(entry, context);
+        return se_Tag(entry, context);
     });
 };
-const serializeAws_json1_1ValidatePipelineDefinitionInput = (input, context) => {
+const se_ValidatePipelineDefinitionInput = (input, context) => {
     return {
         ...(input.parameterObjects != null && {
-            parameterObjects: serializeAws_json1_1ParameterObjectList(input.parameterObjects, context),
-        }),
-        ...(input.parameterValues != null && {
-            parameterValues: serializeAws_json1_1ParameterValueList(input.parameterValues, context),
+            parameterObjects: se_ParameterObjectList(input.parameterObjects, context),
         }),
+        ...(input.parameterValues != null && { parameterValues: se_ParameterValueList(input.parameterValues, context) }),
         ...(input.pipelineId != null && { pipelineId: input.pipelineId }),
-        ...(input.pipelineObjects != null && {
-            pipelineObjects: serializeAws_json1_1PipelineObjectList(input.pipelineObjects, context),
-        }),
+        ...(input.pipelineObjects != null && { pipelineObjects: se_PipelineObjectList(input.pipelineObjects, context) }),
     };
 };
-const deserializeAws_json1_1ActivatePipelineOutput = (output, context) => {
+const de_ActivatePipelineOutput = (output, context) => {
     return {};
 };
-const deserializeAws_json1_1AddTagsOutput = (output, context) => {
+const de_AddTagsOutput = (output, context) => {
     return {};
 };
-const deserializeAws_json1_1CreatePipelineOutput = (output, context) => {
+const de_CreatePipelineOutput = (output, context) => {
     return {
         pipelineId: __expectString(output.pipelineId),
     };
 };
-const deserializeAws_json1_1DeactivatePipelineOutput = (output, context) => {
+const de_DeactivatePipelineOutput = (output, context) => {
     return {};
 };
-const deserializeAws_json1_1DescribeObjectsOutput = (output, context) => {
+const de_DescribeObjectsOutput = (output, context) => {
     return {
         hasMoreResults: __expectBoolean(output.hasMoreResults),
         marker: __expectString(output.marker),
-        pipelineObjects: output.pipelineObjects != null
-            ? deserializeAws_json1_1PipelineObjectList(output.pipelineObjects, context)
-            : undefined,
+        pipelineObjects: output.pipelineObjects != null ? de_PipelineObjectList(output.pipelineObjects, context) : undefined,
     };
 };
-const deserializeAws_json1_1DescribePipelinesOutput = (output, context) => {
+const de_DescribePipelinesOutput = (output, context) => {
     return {
         pipelineDescriptionList: output.pipelineDescriptionList != null
-            ? deserializeAws_json1_1PipelineDescriptionList(output.pipelineDescriptionList, context)
+            ? de_PipelineDescriptionList(output.pipelineDescriptionList, context)
             : undefined,
     };
 };
-const deserializeAws_json1_1EvaluateExpressionOutput = (output, context) => {
+const de_EvaluateExpressionOutput = (output, context) => {
     return {
         evaluatedExpression: __expectString(output.evaluatedExpression),
     };
 };
-const deserializeAws_json1_1Field = (output, context) => {
+const de_Field = (output, context) => {
     return {
         key: __expectString(output.key),
         refValue: __expectString(output.refValue),
         stringValue: __expectString(output.stringValue),
     };
 };
-const deserializeAws_json1_1fieldList = (output, context) => {
+const de_fieldList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_json1_1Field(entry, context);
+        return de_Field(entry, context);
     });
     return retVal;
 };
-const deserializeAws_json1_1GetPipelineDefinitionOutput = (output, context) => {
+const de_GetPipelineDefinitionOutput = (output, context) => {
     return {
-        parameterObjects: output.parameterObjects != null
-            ? deserializeAws_json1_1ParameterObjectList(output.parameterObjects, context)
-            : undefined,
-        parameterValues: output.parameterValues != null
-            ? deserializeAws_json1_1ParameterValueList(output.parameterValues, context)
-            : undefined,
-        pipelineObjects: output.pipelineObjects != null
-            ? deserializeAws_json1_1PipelineObjectList(output.pipelineObjects, context)
-            : undefined,
+        parameterObjects: output.parameterObjects != null ? de_ParameterObjectList(output.parameterObjects, context) : undefined,
+        parameterValues: output.parameterValues != null ? de_ParameterValueList(output.parameterValues, context) : undefined,
+        pipelineObjects: output.pipelineObjects != null ? de_PipelineObjectList(output.pipelineObjects, context) : undefined,
     };
 };
-const deserializeAws_json1_1idList = (output, context) => {
+const de_idList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
@@ -1344,246 +1322,238 @@ const deserializeAws_json1_1idList = (output, context) => {
     });
     return retVal;
 };
-const deserializeAws_json1_1InternalServiceError = (output, context) => {
+const de_InternalServiceError = (output, context) => {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_1InvalidRequestException = (output, context) => {
+const de_InvalidRequestException = (output, context) => {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_1ListPipelinesOutput = (output, context) => {
+const de_ListPipelinesOutput = (output, context) => {
     return {
         hasMoreResults: __expectBoolean(output.hasMoreResults),
         marker: __expectString(output.marker),
-        pipelineIdList: output.pipelineIdList != null ? deserializeAws_json1_1pipelineList(output.pipelineIdList, context) : undefined,
+        pipelineIdList: output.pipelineIdList != null ? de_pipelineList(output.pipelineIdList, context) : undefined,
     };
 };
-const deserializeAws_json1_1ParameterAttribute = (output, context) => {
+const de_ParameterAttribute = (output, context) => {
     return {
         key: __expectString(output.key),
         stringValue: __expectString(output.stringValue),
     };
 };
-const deserializeAws_json1_1ParameterAttributeList = (output, context) => {
+const de_ParameterAttributeList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_json1_1ParameterAttribute(entry, context);
+        return de_ParameterAttribute(entry, context);
     });
     return retVal;
 };
-const deserializeAws_json1_1ParameterObject = (output, context) => {
+const de_ParameterObject = (output, context) => {
     return {
-        attributes: output.attributes != null ? deserializeAws_json1_1ParameterAttributeList(output.attributes, context) : undefined,
+        attributes: output.attributes != null ? de_ParameterAttributeList(output.attributes, context) : undefined,
         id: __expectString(output.id),
     };
 };
-const deserializeAws_json1_1ParameterObjectList = (output, context) => {
+const de_ParameterObjectList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_json1_1ParameterObject(entry, context);
+        return de_ParameterObject(entry, context);
     });
     return retVal;
 };
-const deserializeAws_json1_1ParameterValue = (output, context) => {
+const de_ParameterValue = (output, context) => {
     return {
         id: __expectString(output.id),
         stringValue: __expectString(output.stringValue),
     };
 };
-const deserializeAws_json1_1ParameterValueList = (output, context) => {
+const de_ParameterValueList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_json1_1ParameterValue(entry, context);
+        return de_ParameterValue(entry, context);
     });
     return retVal;
 };
-const deserializeAws_json1_1PipelineDeletedException = (output, context) => {
+const de_PipelineDeletedException = (output, context) => {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_1PipelineDescription = (output, context) => {
+const de_PipelineDescription = (output, context) => {
     return {
         description: __expectString(output.description),
-        fields: output.fields != null ? deserializeAws_json1_1fieldList(output.fields, context) : undefined,
+        fields: output.fields != null ? de_fieldList(output.fields, context) : undefined,
         name: __expectString(output.name),
         pipelineId: __expectString(output.pipelineId),
-        tags: output.tags != null ? deserializeAws_json1_1tagList(output.tags, context) : undefined,
+        tags: output.tags != null ? de_tagList(output.tags, context) : undefined,
     };
 };
-const deserializeAws_json1_1PipelineDescriptionList = (output, context) => {
+const de_PipelineDescriptionList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_json1_1PipelineDescription(entry, context);
+        return de_PipelineDescription(entry, context);
     });
     return retVal;
 };
-const deserializeAws_json1_1PipelineIdName = (output, context) => {
+const de_PipelineIdName = (output, context) => {
     return {
         id: __expectString(output.id),
         name: __expectString(output.name),
     };
 };
-const deserializeAws_json1_1pipelineList = (output, context) => {
+const de_pipelineList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_json1_1PipelineIdName(entry, context);
+        return de_PipelineIdName(entry, context);
     });
     return retVal;
 };
-const deserializeAws_json1_1PipelineNotFoundException = (output, context) => {
+const de_PipelineNotFoundException = (output, context) => {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_1PipelineObject = (output, context) => {
+const de_PipelineObject = (output, context) => {
     return {
-        fields: output.fields != null ? deserializeAws_json1_1fieldList(output.fields, context) : undefined,
+        fields: output.fields != null ? de_fieldList(output.fields, context) : undefined,
         id: __expectString(output.id),
         name: __expectString(output.name),
     };
 };
-const deserializeAws_json1_1PipelineObjectList = (output, context) => {
+const de_PipelineObjectList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_json1_1PipelineObject(entry, context);
+        return de_PipelineObject(entry, context);
     });
     return retVal;
 };
-const deserializeAws_json1_1PipelineObjectMap = (output, context) => {
+const de_PipelineObjectMap = (output, context) => {
     return Object.entries(output).reduce((acc, [key, value]) => {
         if (value === null) {
             return acc;
         }
-        acc[key] = deserializeAws_json1_1PipelineObject(value, context);
+        acc[key] = de_PipelineObject(value, context);
         return acc;
     }, {});
 };
-const deserializeAws_json1_1PollForTaskOutput = (output, context) => {
+const de_PollForTaskOutput = (output, context) => {
     return {
-        taskObject: output.taskObject != null ? deserializeAws_json1_1TaskObject(output.taskObject, context) : undefined,
+        taskObject: output.taskObject != null ? de_TaskObject(output.taskObject, context) : undefined,
     };
 };
-const deserializeAws_json1_1PutPipelineDefinitionOutput = (output, context) => {
+const de_PutPipelineDefinitionOutput = (output, context) => {
     return {
         errored: __expectBoolean(output.errored),
-        validationErrors: output.validationErrors != null
-            ? deserializeAws_json1_1ValidationErrors(output.validationErrors, context)
-            : undefined,
-        validationWarnings: output.validationWarnings != null
-            ? deserializeAws_json1_1ValidationWarnings(output.validationWarnings, context)
-            : undefined,
+        validationErrors: output.validationErrors != null ? de_ValidationErrors(output.validationErrors, context) : undefined,
+        validationWarnings: output.validationWarnings != null ? de_ValidationWarnings(output.validationWarnings, context) : undefined,
     };
 };
-const deserializeAws_json1_1QueryObjectsOutput = (output, context) => {
+const de_QueryObjectsOutput = (output, context) => {
     return {
         hasMoreResults: __expectBoolean(output.hasMoreResults),
-        ids: output.ids != null ? deserializeAws_json1_1idList(output.ids, context) : undefined,
+        ids: output.ids != null ? de_idList(output.ids, context) : undefined,
         marker: __expectString(output.marker),
     };
 };
-const deserializeAws_json1_1RemoveTagsOutput = (output, context) => {
+const de_RemoveTagsOutput = (output, context) => {
     return {};
 };
-const deserializeAws_json1_1ReportTaskProgressOutput = (output, context) => {
+const de_ReportTaskProgressOutput = (output, context) => {
     return {
         canceled: __expectBoolean(output.canceled),
     };
 };
-const deserializeAws_json1_1ReportTaskRunnerHeartbeatOutput = (output, context) => {
+const de_ReportTaskRunnerHeartbeatOutput = (output, context) => {
     return {
         terminate: __expectBoolean(output.terminate),
     };
 };
-const deserializeAws_json1_1SetTaskStatusOutput = (output, context) => {
+const de_SetTaskStatusOutput = (output, context) => {
     return {};
 };
-const deserializeAws_json1_1Tag = (output, context) => {
+const de_Tag = (output, context) => {
     return {
         key: __expectString(output.key),
         value: __expectString(output.value),
     };
 };
-const deserializeAws_json1_1tagList = (output, context) => {
+const de_tagList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_json1_1Tag(entry, context);
+        return de_Tag(entry, context);
     });
     return retVal;
 };
-const deserializeAws_json1_1TaskNotFoundException = (output, context) => {
+const de_TaskNotFoundException = (output, context) => {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_1TaskObject = (output, context) => {
+const de_TaskObject = (output, context) => {
     return {
         attemptId: __expectString(output.attemptId),
-        objects: output.objects != null ? deserializeAws_json1_1PipelineObjectMap(output.objects, context) : undefined,
+        objects: output.objects != null ? de_PipelineObjectMap(output.objects, context) : undefined,
         pipelineId: __expectString(output.pipelineId),
         taskId: __expectString(output.taskId),
     };
 };
-const deserializeAws_json1_1ValidatePipelineDefinitionOutput = (output, context) => {
+const de_ValidatePipelineDefinitionOutput = (output, context) => {
     return {
         errored: __expectBoolean(output.errored),
-        validationErrors: output.validationErrors != null
-            ? deserializeAws_json1_1ValidationErrors(output.validationErrors, context)
-            : undefined,
-        validationWarnings: output.validationWarnings != null
-            ? deserializeAws_json1_1ValidationWarnings(output.validationWarnings, context)
-            : undefined,
+        validationErrors: output.validationErrors != null ? de_ValidationErrors(output.validationErrors, context) : undefined,
+        validationWarnings: output.validationWarnings != null ? de_ValidationWarnings(output.validationWarnings, context) : undefined,
     };
 };
-const deserializeAws_json1_1ValidationError = (output, context) => {
+const de_ValidationError = (output, context) => {
     return {
-        errors: output.errors != null ? deserializeAws_json1_1validationMessages(output.errors, context) : undefined,
+        errors: output.errors != null ? de_validationMessages(output.errors, context) : undefined,
         id: __expectString(output.id),
     };
 };
-const deserializeAws_json1_1ValidationErrors = (output, context) => {
+const de_ValidationErrors = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_json1_1ValidationError(entry, context);
+        return de_ValidationError(entry, context);
     });
     return retVal;
 };
-const deserializeAws_json1_1validationMessages = (output, context) => {
+const de_validationMessages = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
@@ -1594,20 +1564,20 @@ const deserializeAws_json1_1validationMessages = (output, context) => {
     });
     return retVal;
 };
-const deserializeAws_json1_1ValidationWarning = (output, context) => {
+const de_ValidationWarning = (output, context) => {
     return {
         id: __expectString(output.id),
-        warnings: output.warnings != null ? deserializeAws_json1_1validationMessages(output.warnings, context) : undefined,
+        warnings: output.warnings != null ? de_validationMessages(output.warnings, context) : undefined,
     };
 };
-const deserializeAws_json1_1ValidationWarnings = (output, context) => {
+const de_ValidationWarnings = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_json1_1ValidationWarning(entry, context);
+        return de_ValidationWarning(entry, context);
     });
     return retVal;
 };