@aws-sdk/client-mgn 3.216.0 → 3.218.0

package/dist-es/protocols/Aws_restJson1.js

@@ -2,6 +2,92 @@ import { HttpRequest as __HttpRequest } from "@aws-sdk/protocol-http";
 import { decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectInt32 as __expectInt32, expectLong as __expectLong, expectNonNull as __expectNonNull, expectObject as __expectObject, expectString as __expectString, map as __map, resolvedPath as __resolvedPath, strictParseLong as __strictParseLong, throwDefaultError, } from "@aws-sdk/smithy-client";
 import { MgnServiceException as __BaseException } from "../models/MgnServiceException";
 import { AccessDeniedException, ConflictException, InternalServerException, ResourceNotFoundException, ServiceQuotaExceededException, ThrottlingException, UninitializedAccountException, ValidationException, } from "../models/models_0";
+export const serializeAws_restJson1ArchiveApplicationCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/ArchiveApplication";
+    let body;
+    body = JSON.stringify({
+        ...(input.applicationID != null && { applicationID: input.applicationID }),
+    });
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const serializeAws_restJson1ArchiveWaveCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/ArchiveWave";
+    let body;
+    body = JSON.stringify({
+        ...(input.waveID != null && { waveID: input.waveID }),
+    });
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const serializeAws_restJson1AssociateApplicationsCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/AssociateApplications";
+    let body;
+    body = JSON.stringify({
+        ...(input.applicationIDs != null && {
+            applicationIDs: serializeAws_restJson1ApplicationIDs(input.applicationIDs, context),
+        }),
+        ...(input.waveID != null && { waveID: input.waveID }),
+    });
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const serializeAws_restJson1AssociateSourceServersCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/AssociateSourceServers";
+    let body;
+    body = JSON.stringify({
+        ...(input.applicationID != null && { applicationID: input.applicationID }),
+        ...(input.sourceServerIDs != null && {
+            sourceServerIDs: serializeAws_restJson1AssociateSourceServersRequestSourceServerIDs(input.sourceServerIDs, context),
+        }),
+    });
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
 export const serializeAws_restJson1ChangeServerLifeCycleStateCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
@@ -25,6 +111,28 @@ export const serializeAws_restJson1ChangeServerLifeCycleStateCommand = async (in
         body,
     });
 };
+export const serializeAws_restJson1CreateApplicationCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/CreateApplication";
+    let body;
+    body = JSON.stringify({
+        ...(input.description != null && { description: input.description }),
+        ...(input.name != null && { name: input.name }),
+        ...(input.tags != null && { tags: serializeAws_restJson1TagsMap(input.tags, context) }),
+    });
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
 export const serializeAws_restJson1CreateLaunchConfigurationTemplateCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
@@ -33,10 +141,28 @@ export const serializeAws_restJson1CreateLaunchConfigurationTemplateCommand = as
     const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/CreateLaunchConfigurationTemplate";
     let body;
     body = JSON.stringify({
+        ...(input.associatePublicIpAddress != null && { associatePublicIpAddress: input.associatePublicIpAddress }),
+        ...(input.bootMode != null && { bootMode: input.bootMode }),
+        ...(input.copyPrivateIp != null && { copyPrivateIp: input.copyPrivateIp }),
+        ...(input.copyTags != null && { copyTags: input.copyTags }),
+        ...(input.enableMapAutoTagging != null && { enableMapAutoTagging: input.enableMapAutoTagging }),
+        ...(input.largeVolumeConf != null && {
+            largeVolumeConf: serializeAws_restJson1LaunchTemplateDiskConf(input.largeVolumeConf, context),
+        }),
+        ...(input.launchDisposition != null && { launchDisposition: input.launchDisposition }),
+        ...(input.licensing != null && { licensing: serializeAws_restJson1Licensing(input.licensing, context) }),
+        ...(input.mapAutoTaggingMpeID != null && { mapAutoTaggingMpeID: input.mapAutoTaggingMpeID }),
         ...(input.postLaunchActions != null && {
             postLaunchActions: serializeAws_restJson1PostLaunchActions(input.postLaunchActions, context),
         }),
+        ...(input.smallVolumeConf != null && {
+            smallVolumeConf: serializeAws_restJson1LaunchTemplateDiskConf(input.smallVolumeConf, context),
+        }),
+        ...(input.smallVolumeMaxSize != null && { smallVolumeMaxSize: input.smallVolumeMaxSize }),
         ...(input.tags != null && { tags: serializeAws_restJson1TagsMap(input.tags, context) }),
+        ...(input.targetInstanceTypeRightSizingMethod != null && {
+            targetInstanceTypeRightSizingMethod: input.targetInstanceTypeRightSizingMethod,
+        }),
     });
     return new __HttpRequest({
         protocol,
@@ -92,6 +218,48 @@ export const serializeAws_restJson1CreateReplicationConfigurationTemplateCommand
         body,
     });
 };
+export const serializeAws_restJson1CreateWaveCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/CreateWave";
+    let body;
+    body = JSON.stringify({
+        ...(input.description != null && { description: input.description }),
+        ...(input.name != null && { name: input.name }),
+        ...(input.tags != null && { tags: serializeAws_restJson1TagsMap(input.tags, context) }),
+    });
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const serializeAws_restJson1DeleteApplicationCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/DeleteApplication";
+    let body;
+    body = JSON.stringify({
+        ...(input.applicationID != null && { applicationID: input.applicationID }),
+    });
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
 export const serializeAws_restJson1DeleteJobCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
@@ -196,6 +364,26 @@ export const serializeAws_restJson1DeleteVcenterClientCommand = async (input, co
         body,
     });
 };
+export const serializeAws_restJson1DeleteWaveCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/DeleteWave";
+    let body;
+    body = JSON.stringify({
+        ...(input.waveID != null && { waveID: input.waveID }),
+    });
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
 export const serializeAws_restJson1DescribeJobLogItemsCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
@@ -333,15 +521,18 @@ export const serializeAws_restJson1DescribeVcenterClientsCommand = async (input,
         body,
     });
 };
-export const serializeAws_restJson1DisconnectFromServiceCommand = async (input, context) => {
+export const serializeAws_restJson1DisassociateApplicationsCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
     };
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/DisconnectFromService";
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/DisassociateApplications";
     let body;
     body = JSON.stringify({
-        ...(input.sourceServerID != null && { sourceServerID: input.sourceServerID }),
+        ...(input.applicationIDs != null && {
+            applicationIDs: serializeAws_restJson1ApplicationIDs(input.applicationIDs, context),
+        }),
+        ...(input.waveID != null && { waveID: input.waveID }),
     });
     return new __HttpRequest({
         protocol,
@@ -353,15 +544,18 @@ export const serializeAws_restJson1DisconnectFromServiceCommand = async (input,
         body,
     });
 };
-export const serializeAws_restJson1FinalizeCutoverCommand = async (input, context) => {
+export const serializeAws_restJson1DisassociateSourceServersCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
     };
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/FinalizeCutover";
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/DisassociateSourceServers";
     let body;
     body = JSON.stringify({
-        ...(input.sourceServerID != null && { sourceServerID: input.sourceServerID }),
+        ...(input.applicationID != null && { applicationID: input.applicationID }),
+        ...(input.sourceServerIDs != null && {
+            sourceServerIDs: serializeAws_restJson1DisassociateSourceServersRequestSourceServerIDs(input.sourceServerIDs, context),
+        }),
     });
     return new __HttpRequest({
         protocol,
@@ -373,12 +567,12 @@ export const serializeAws_restJson1FinalizeCutoverCommand = async (input, contex
         body,
     });
 };
-export const serializeAws_restJson1GetLaunchConfigurationCommand = async (input, context) => {
+export const serializeAws_restJson1DisconnectFromServiceCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
     };
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/GetLaunchConfiguration";
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/DisconnectFromService";
     let body;
     body = JSON.stringify({
         ...(input.sourceServerID != null && { sourceServerID: input.sourceServerID }),
@@ -393,12 +587,12 @@ export const serializeAws_restJson1GetLaunchConfigurationCommand = async (input,
         body,
     });
 };
-export const serializeAws_restJson1GetReplicationConfigurationCommand = async (input, context) => {
+export const serializeAws_restJson1FinalizeCutoverCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
     };
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/GetReplicationConfiguration";
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/FinalizeCutover";
     let body;
     body = JSON.stringify({
         ...(input.sourceServerID != null && { sourceServerID: input.sourceServerID }),
@@ -413,14 +607,16 @@ export const serializeAws_restJson1GetReplicationConfigurationCommand = async (i
         body,
     });
 };
-export const serializeAws_restJson1InitializeServiceCommand = async (input, context) => {
+export const serializeAws_restJson1GetLaunchConfigurationCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
     };
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/InitializeService";
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/GetLaunchConfiguration";
     let body;
-    body = "";
+    body = JSON.stringify({
+        ...(input.sourceServerID != null && { sourceServerID: input.sourceServerID }),
+    });
     return new __HttpRequest({
         protocol,
         hostname,
@@ -431,32 +627,34 @@ export const serializeAws_restJson1InitializeServiceCommand = async (input, cont
         body,
     });
 };
-export const serializeAws_restJson1ListTagsForResourceCommand = async (input, context) => {
+export const serializeAws_restJson1GetReplicationConfigurationCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
-    const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{resourceArn}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "resourceArn", () => input.resourceArn, "{resourceArn}", false);
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/GetReplicationConfiguration";
     let body;
+    body = JSON.stringify({
+        ...(input.sourceServerID != null && { sourceServerID: input.sourceServerID }),
+    });
     return new __HttpRequest({
         protocol,
         hostname,
         port,
-        method: "GET",
+        method: "POST",
         headers,
         path: resolvedPath,
         body,
     });
 };
-export const serializeAws_restJson1MarkAsArchivedCommand = async (input, context) => {
+export const serializeAws_restJson1InitializeServiceCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
     };
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/MarkAsArchived";
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/InitializeService";
     let body;
-    body = JSON.stringify({
-        ...(input.sourceServerID != null && { sourceServerID: input.sourceServerID }),
-    });
+    body = "";
     return new __HttpRequest({
         protocol,
         hostname,
@@ -467,15 +665,19 @@ export const serializeAws_restJson1MarkAsArchivedCommand = async (input, context
         body,
     });
 };
-export const serializeAws_restJson1RetryDataReplicationCommand = async (input, context) => {
+export const serializeAws_restJson1ListApplicationsCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
     };
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/RetryDataReplication";
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/ListApplications";
     let body;
     body = JSON.stringify({
-        ...(input.sourceServerID != null && { sourceServerID: input.sourceServerID }),
+        ...(input.filters != null && {
+            filters: serializeAws_restJson1ListApplicationsRequestFilters(input.filters, context),
+        }),
+        ...(input.maxResults != null && { maxResults: input.maxResults }),
+        ...(input.nextToken != null && { nextToken: input.nextToken }),
     });
     return new __HttpRequest({
         protocol,
@@ -487,18 +689,20 @@ export const serializeAws_restJson1RetryDataReplicationCommand = async (input, c
         body,
     });
 };
-export const serializeAws_restJson1StartCutoverCommand = async (input, context) => {
+export const serializeAws_restJson1ListSourceServerActionsCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
     };
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/StartCutover";
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/ListSourceServerActions";
     let body;
     body = JSON.stringify({
-        ...(input.sourceServerIDs != null && {
-            sourceServerIDs: serializeAws_restJson1StartCutoverRequestSourceServerIDs(input.sourceServerIDs, context),
+        ...(input.filters != null && {
+            filters: serializeAws_restJson1SourceServerActionsRequestFilters(input.filters, context),
         }),
-        ...(input.tags != null && { tags: serializeAws_restJson1TagsMap(input.tags, context) }),
+        ...(input.maxResults != null && { maxResults: input.maxResults }),
+        ...(input.nextToken != null && { nextToken: input.nextToken }),
+        ...(input.sourceServerID != null && { sourceServerID: input.sourceServerID }),
     });
     return new __HttpRequest({
         protocol,
@@ -510,38 +714,38 @@ export const serializeAws_restJson1StartCutoverCommand = async (input, context)
         body,
     });
 };
-export const serializeAws_restJson1StartReplicationCommand = async (input, context) => {
+export const serializeAws_restJson1ListTagsForResourceCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
-    const headers = {
-        "content-type": "application/json",
-    };
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/StartReplication";
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{resourceArn}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "resourceArn", () => input.resourceArn, "{resourceArn}", false);
     let body;
-    body = JSON.stringify({
-        ...(input.sourceServerID != null && { sourceServerID: input.sourceServerID }),
-    });
     return new __HttpRequest({
         protocol,
         hostname,
         port,
-        method: "POST",
+        method: "GET",
         headers,
         path: resolvedPath,
         body,
     });
 };
-export const serializeAws_restJson1StartTestCommand = async (input, context) => {
+export const serializeAws_restJson1ListTemplateActionsCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
     };
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/StartTest";
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/ListTemplateActions";
     let body;
     body = JSON.stringify({
-        ...(input.sourceServerIDs != null && {
-            sourceServerIDs: serializeAws_restJson1StartTestRequestSourceServerIDs(input.sourceServerIDs, context),
+        ...(input.filters != null && {
+            filters: serializeAws_restJson1TemplateActionsRequestFilters(input.filters, context),
         }),
-        ...(input.tags != null && { tags: serializeAws_restJson1TagsMap(input.tags, context) }),
+        ...(input.launchConfigurationTemplateID != null && {
+            launchConfigurationTemplateID: input.launchConfigurationTemplateID,
+        }),
+        ...(input.maxResults != null && { maxResults: input.maxResults }),
+        ...(input.nextToken != null && { nextToken: input.nextToken }),
     });
     return new __HttpRequest({
         protocol,
@@ -553,16 +757,17 @@ export const serializeAws_restJson1StartTestCommand = async (input, context) =>
         body,
     });
 };
-export const serializeAws_restJson1TagResourceCommand = async (input, context) => {
+export const serializeAws_restJson1ListWavesCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{resourceArn}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "resourceArn", () => input.resourceArn, "{resourceArn}", false);
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/ListWaves";
     let body;
     body = JSON.stringify({
-        ...(input.tags != null && { tags: serializeAws_restJson1TagsMap(input.tags, context) }),
+        ...(input.filters != null && { filters: serializeAws_restJson1ListWavesRequestFilters(input.filters, context) }),
+        ...(input.maxResults != null && { maxResults: input.maxResults }),
+        ...(input.nextToken != null && { nextToken: input.nextToken }),
     });
     return new __HttpRequest({
         protocol,
@@ -574,18 +779,15 @@ export const serializeAws_restJson1TagResourceCommand = async (input, context) =
         body,
     });
 };
-export const serializeAws_restJson1TerminateTargetInstancesCommand = async (input, context) => {
+export const serializeAws_restJson1MarkAsArchivedCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
     };
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/TerminateTargetInstances";
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/MarkAsArchived";
     let body;
     body = JSON.stringify({
-        ...(input.sourceServerIDs != null && {
-            sourceServerIDs: serializeAws_restJson1TerminateTargetInstancesRequestSourceServerIDs(input.sourceServerIDs, context),
-        }),
-        ...(input.tags != null && { tags: serializeAws_restJson1TagsMap(input.tags, context) }),
+        ...(input.sourceServerID != null && { sourceServerID: input.sourceServerID }),
     });
     return new __HttpRequest({
         protocol,
@@ -597,47 +799,60 @@ export const serializeAws_restJson1TerminateTargetInstancesCommand = async (inpu
         body,
     });
 };
-export const serializeAws_restJson1UntagResourceCommand = async (input, context) => {
+export const serializeAws_restJson1PutSourceServerActionCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
-    const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{resourceArn}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "resourceArn", () => input.resourceArn, "{resourceArn}", false);
-    const query = map({
-        tagKeys: [() => input.tagKeys !== void 0, () => (input.tagKeys || []).map((_entry) => _entry)],
-    });
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/PutSourceServerAction";
     let body;
+    body = JSON.stringify({
+        ...(input.actionID != null && { actionID: input.actionID }),
+        ...(input.actionName != null && { actionName: input.actionName }),
+        ...(input.active != null && { active: input.active }),
+        ...(input.documentIdentifier != null && { documentIdentifier: input.documentIdentifier }),
+        ...(input.documentVersion != null && { documentVersion: input.documentVersion }),
+        ...(input.mustSucceedForCutover != null && { mustSucceedForCutover: input.mustSucceedForCutover }),
+        ...(input.order != null && { order: input.order }),
+        ...(input.parameters != null && {
+            parameters: serializeAws_restJson1SsmDocumentParameters(input.parameters, context),
+        }),
+        ...(input.sourceServerID != null && { sourceServerID: input.sourceServerID }),
+        ...(input.timeoutSeconds != null && { timeoutSeconds: input.timeoutSeconds }),
+    });
     return new __HttpRequest({
         protocol,
         hostname,
         port,
-        method: "DELETE",
+        method: "POST",
         headers,
         path: resolvedPath,
-        query,
         body,
     });
 };
-export const serializeAws_restJson1UpdateLaunchConfigurationCommand = async (input, context) => {
+export const serializeAws_restJson1PutTemplateActionCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
     };
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/UpdateLaunchConfiguration";
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/PutTemplateAction";
     let body;
     body = JSON.stringify({
-        ...(input.bootMode != null && { bootMode: input.bootMode }),
-        ...(input.copyPrivateIp != null && { copyPrivateIp: input.copyPrivateIp }),
-        ...(input.copyTags != null && { copyTags: input.copyTags }),
-        ...(input.launchDisposition != null && { launchDisposition: input.launchDisposition }),
-        ...(input.licensing != null && { licensing: serializeAws_restJson1Licensing(input.licensing, context) }),
-        ...(input.name != null && { name: input.name }),
-        ...(input.postLaunchActions != null && {
-            postLaunchActions: serializeAws_restJson1PostLaunchActions(input.postLaunchActions, context),
+        ...(input.actionID != null && { actionID: input.actionID }),
+        ...(input.actionName != null && { actionName: input.actionName }),
+        ...(input.active != null && { active: input.active }),
+        ...(input.documentIdentifier != null && { documentIdentifier: input.documentIdentifier }),
+        ...(input.documentVersion != null && { documentVersion: input.documentVersion }),
+        ...(input.launchConfigurationTemplateID != null && {
+            launchConfigurationTemplateID: input.launchConfigurationTemplateID,
         }),
-        ...(input.sourceServerID != null && { sourceServerID: input.sourceServerID }),
-        ...(input.targetInstanceTypeRightSizingMethod != null && {
-            targetInstanceTypeRightSizingMethod: input.targetInstanceTypeRightSizingMethod,
+        ...(input.mustSucceedForCutover != null && { mustSucceedForCutover: input.mustSucceedForCutover }),
+        ...(input.operatingSystem != null && { operatingSystem: input.operatingSystem }),
+        ...(input.order != null && { order: input.order }),
+        ...(input.parameters != null && {
+            parameters: serializeAws_restJson1SsmDocumentParameters(input.parameters, context),
         }),
+        ...(input.timeoutSeconds != null && { timeoutSeconds: input.timeoutSeconds }),
     });
     return new __HttpRequest({
         protocol,
@@ -649,20 +864,39 @@ export const serializeAws_restJson1UpdateLaunchConfigurationCommand = async (inp
         body,
     });
 };
-export const serializeAws_restJson1UpdateLaunchConfigurationTemplateCommand = async (input, context) => {
+export const serializeAws_restJson1RemoveSourceServerActionCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
     };
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/UpdateLaunchConfigurationTemplate";
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/RemoveSourceServerAction";
+    let body;
+    body = JSON.stringify({
+        ...(input.actionID != null && { actionID: input.actionID }),
+        ...(input.sourceServerID != null && { sourceServerID: input.sourceServerID }),
+    });
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const serializeAws_restJson1RemoveTemplateActionCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/RemoveTemplateAction";
     let body;
     body = JSON.stringify({
+        ...(input.actionID != null && { actionID: input.actionID }),
         ...(input.launchConfigurationTemplateID != null && {
             launchConfigurationTemplateID: input.launchConfigurationTemplateID,
         }),
-        ...(input.postLaunchActions != null && {
-            postLaunchActions: serializeAws_restJson1PostLaunchActions(input.postLaunchActions, context),
-        }),
     });
     return new __HttpRequest({
         protocol,
@@ -674,43 +908,15 @@ export const serializeAws_restJson1UpdateLaunchConfigurationTemplateCommand = as
         body,
     });
 };
-export const serializeAws_restJson1UpdateReplicationConfigurationCommand = async (input, context) => {
+export const serializeAws_restJson1RetryDataReplicationCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
     };
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/UpdateReplicationConfiguration";
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/RetryDataReplication";
     let body;
     body = JSON.stringify({
-        ...(input.associateDefaultSecurityGroup != null && {
-            associateDefaultSecurityGroup: input.associateDefaultSecurityGroup,
-        }),
-        ...(input.bandwidthThrottling != null && { bandwidthThrottling: input.bandwidthThrottling }),
-        ...(input.createPublicIP != null && { createPublicIP: input.createPublicIP }),
-        ...(input.dataPlaneRouting != null && { dataPlaneRouting: input.dataPlaneRouting }),
-        ...(input.defaultLargeStagingDiskType != null && {
-            defaultLargeStagingDiskType: input.defaultLargeStagingDiskType,
-        }),
-        ...(input.ebsEncryption != null && { ebsEncryption: input.ebsEncryption }),
-        ...(input.ebsEncryptionKeyArn != null && { ebsEncryptionKeyArn: input.ebsEncryptionKeyArn }),
-        ...(input.name != null && { name: input.name }),
-        ...(input.replicatedDisks != null && {
-            replicatedDisks: serializeAws_restJson1ReplicationConfigurationReplicatedDisks(input.replicatedDisks, context),
-        }),
-        ...(input.replicationServerInstanceType != null && {
-            replicationServerInstanceType: input.replicationServerInstanceType,
-        }),
-        ...(input.replicationServersSecurityGroupsIDs != null && {
-            replicationServersSecurityGroupsIDs: serializeAws_restJson1ReplicationServersSecurityGroupsIDs(input.replicationServersSecurityGroupsIDs, context),
-        }),
         ...(input.sourceServerID != null && { sourceServerID: input.sourceServerID }),
-        ...(input.stagingAreaSubnetId != null && { stagingAreaSubnetId: input.stagingAreaSubnetId }),
-        ...(input.stagingAreaTags != null && {
-            stagingAreaTags: serializeAws_restJson1TagsMap(input.stagingAreaTags, context),
-        }),
-        ...(input.useDedicatedReplicationServer != null && {
-            useDedicatedReplicationServer: input.useDedicatedReplicationServer,
-        }),
     });
     return new __HttpRequest({
         protocol,
@@ -722,42 +928,18 @@ export const serializeAws_restJson1UpdateReplicationConfigurationCommand = async
         body,
     });
 };
-export const serializeAws_restJson1UpdateReplicationConfigurationTemplateCommand = async (input, context) => {
+export const serializeAws_restJson1StartCutoverCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
     };
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/UpdateReplicationConfigurationTemplate";
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/StartCutover";
     let body;
     body = JSON.stringify({
-        ...(input.arn != null && { arn: input.arn }),
-        ...(input.associateDefaultSecurityGroup != null && {
-            associateDefaultSecurityGroup: input.associateDefaultSecurityGroup,
-        }),
-        ...(input.bandwidthThrottling != null && { bandwidthThrottling: input.bandwidthThrottling }),
-        ...(input.createPublicIP != null && { createPublicIP: input.createPublicIP }),
-        ...(input.dataPlaneRouting != null && { dataPlaneRouting: input.dataPlaneRouting }),
-        ...(input.defaultLargeStagingDiskType != null && {
-            defaultLargeStagingDiskType: input.defaultLargeStagingDiskType,
-        }),
-        ...(input.ebsEncryption != null && { ebsEncryption: input.ebsEncryption }),
-        ...(input.ebsEncryptionKeyArn != null && { ebsEncryptionKeyArn: input.ebsEncryptionKeyArn }),
-        ...(input.replicationConfigurationTemplateID != null && {
-            replicationConfigurationTemplateID: input.replicationConfigurationTemplateID,
-        }),
-        ...(input.replicationServerInstanceType != null && {
-            replicationServerInstanceType: input.replicationServerInstanceType,
-        }),
-        ...(input.replicationServersSecurityGroupsIDs != null && {
-            replicationServersSecurityGroupsIDs: serializeAws_restJson1ReplicationServersSecurityGroupsIDs(input.replicationServersSecurityGroupsIDs, context),
-        }),
-        ...(input.stagingAreaSubnetId != null && { stagingAreaSubnetId: input.stagingAreaSubnetId }),
-        ...(input.stagingAreaTags != null && {
-            stagingAreaTags: serializeAws_restJson1TagsMap(input.stagingAreaTags, context),
-        }),
-        ...(input.useDedicatedReplicationServer != null && {
-            useDedicatedReplicationServer: input.useDedicatedReplicationServer,
+        ...(input.sourceServerIDs != null && {
+            sourceServerIDs: serializeAws_restJson1StartCutoverRequestSourceServerIDs(input.sourceServerIDs, context),
         }),
+        ...(input.tags != null && { tags: serializeAws_restJson1TagsMap(input.tags, context) }),
     });
     return new __HttpRequest({
         protocol,
@@ -769,15 +951,14 @@ export const serializeAws_restJson1UpdateReplicationConfigurationTemplateCommand
         body,
     });
 };
-export const serializeAws_restJson1UpdateSourceServerReplicationTypeCommand = async (input, context) => {
+export const serializeAws_restJson1StartReplicationCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
     };
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/UpdateSourceServerReplicationType";
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/StartReplication";
     let body;
     body = JSON.stringify({
-        ...(input.replicationType != null && { replicationType: input.replicationType }),
         ...(input.sourceServerID != null && { sourceServerID: input.sourceServerID }),
     });
     return new __HttpRequest({
@@ -790,107 +971,1392 @@ export const serializeAws_restJson1UpdateSourceServerReplicationTypeCommand = as
         body,
     });
 };
-export const deserializeAws_restJson1ChangeServerLifeCycleStateCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1ChangeServerLifeCycleStateCommandError(output, context);
-    }
-    const contents = map({
-        $metadata: deserializeMetadata(output),
+export const serializeAws_restJson1StartTestCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/StartTest";
+    let body;
+    body = JSON.stringify({
+        ...(input.sourceServerIDs != null && {
+            sourceServerIDs: serializeAws_restJson1StartTestRequestSourceServerIDs(input.sourceServerIDs, context),
+        }),
+        ...(input.tags != null && { tags: serializeAws_restJson1TagsMap(input.tags, context) }),
+    });
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
     });
-    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
-    if (data.arn != null) {
-        contents.arn = __expectString(data.arn);
-    }
-    if (data.dataReplicationInfo != null) {
-        contents.dataReplicationInfo = deserializeAws_restJson1DataReplicationInfo(data.dataReplicationInfo, context);
-    }
-    if (data.isArchived != null) {
-        contents.isArchived = __expectBoolean(data.isArchived);
-    }
-    if (data.launchedInstance != null) {
-        contents.launchedInstance = deserializeAws_restJson1LaunchedInstance(data.launchedInstance, context);
-    }
-    if (data.lifeCycle != null) {
-        contents.lifeCycle = deserializeAws_restJson1LifeCycle(data.lifeCycle, context);
-    }
-    if (data.replicationType != null) {
-        contents.replicationType = __expectString(data.replicationType);
-    }
-    if (data.sourceProperties != null) {
-        contents.sourceProperties = deserializeAws_restJson1SourceProperties(data.sourceProperties, context);
-    }
-    if (data.sourceServerID != null) {
-        contents.sourceServerID = __expectString(data.sourceServerID);
-    }
-    if (data.tags != null) {
-        contents.tags = deserializeAws_restJson1TagsMap(data.tags, context);
-    }
-    if (data.vcenterClientID != null) {
-        contents.vcenterClientID = __expectString(data.vcenterClientID);
-    }
-    return contents;
 };
-const deserializeAws_restJson1ChangeServerLifeCycleStateCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
+export const serializeAws_restJson1TagResourceCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
     };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ConflictException":
-        case "com.amazonaws.mgn#ConflictException":
-            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.mgn#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
-        case "UninitializedAccountException":
-        case "com.amazonaws.mgn#UninitializedAccountException":
-            throw await deserializeAws_restJson1UninitializedAccountExceptionResponse(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.mgn#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            throwDefaultError({
-                output,
-                parsedBody,
-                exceptionCtor: __BaseException,
-                errorCode,
-            });
-    }
-};
-export const deserializeAws_restJson1CreateLaunchConfigurationTemplateCommand = async (output, context) => {
-    if (output.statusCode !== 201 && output.statusCode >= 300) {
-        return deserializeAws_restJson1CreateLaunchConfigurationTemplateCommandError(output, context);
-    }
-    const contents = map({
-        $metadata: deserializeMetadata(output),
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{resourceArn}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "resourceArn", () => input.resourceArn, "{resourceArn}", false);
+    let body;
+    body = JSON.stringify({
+        ...(input.tags != null && { tags: serializeAws_restJson1TagsMap(input.tags, context) }),
     });
-    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
-    if (data.arn != null) {
-        contents.arn = __expectString(data.arn);
-    }
-    if (data.launchConfigurationTemplateID != null) {
-        contents.launchConfigurationTemplateID = __expectString(data.launchConfigurationTemplateID);
-    }
-    if (data.postLaunchActions != null) {
-        contents.postLaunchActions = deserializeAws_restJson1PostLaunchActions(data.postLaunchActions, context);
-    }
-    if (data.tags != null) {
-        contents.tags = deserializeAws_restJson1TagsMap(data.tags, context);
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const serializeAws_restJson1TerminateTargetInstancesCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/TerminateTargetInstances";
+    let body;
+    body = JSON.stringify({
+        ...(input.sourceServerIDs != null && {
+            sourceServerIDs: serializeAws_restJson1TerminateTargetInstancesRequestSourceServerIDs(input.sourceServerIDs, context),
+        }),
+        ...(input.tags != null && { tags: serializeAws_restJson1TagsMap(input.tags, context) }),
+    });
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const serializeAws_restJson1UnarchiveApplicationCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/UnarchiveApplication";
+    let body;
+    body = JSON.stringify({
+        ...(input.applicationID != null && { applicationID: input.applicationID }),
+    });
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const serializeAws_restJson1UnarchiveWaveCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/UnarchiveWave";
+    let body;
+    body = JSON.stringify({
+        ...(input.waveID != null && { waveID: input.waveID }),
+    });
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const serializeAws_restJson1UntagResourceCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{resourceArn}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "resourceArn", () => input.resourceArn, "{resourceArn}", false);
+    const query = map({
+        tagKeys: [
+            __expectNonNull(input.tagKeys, `tagKeys`) != null,
+            () => (input.tagKeys || []).map((_entry) => _entry),
+        ],
+    });
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "DELETE",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
+export const serializeAws_restJson1UpdateApplicationCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/UpdateApplication";
+    let body;
+    body = JSON.stringify({
+        ...(input.applicationID != null && { applicationID: input.applicationID }),
+        ...(input.description != null && { description: input.description }),
+        ...(input.name != null && { name: input.name }),
+    });
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const serializeAws_restJson1UpdateLaunchConfigurationCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/UpdateLaunchConfiguration";
+    let body;
+    body = JSON.stringify({
+        ...(input.bootMode != null && { bootMode: input.bootMode }),
+        ...(input.copyPrivateIp != null && { copyPrivateIp: input.copyPrivateIp }),
+        ...(input.copyTags != null && { copyTags: input.copyTags }),
+        ...(input.enableMapAutoTagging != null && { enableMapAutoTagging: input.enableMapAutoTagging }),
+        ...(input.launchDisposition != null && { launchDisposition: input.launchDisposition }),
+        ...(input.licensing != null && { licensing: serializeAws_restJson1Licensing(input.licensing, context) }),
+        ...(input.mapAutoTaggingMpeID != null && { mapAutoTaggingMpeID: input.mapAutoTaggingMpeID }),
+        ...(input.name != null && { name: input.name }),
+        ...(input.postLaunchActions != null && {
+            postLaunchActions: serializeAws_restJson1PostLaunchActions(input.postLaunchActions, context),
+        }),
+        ...(input.sourceServerID != null && { sourceServerID: input.sourceServerID }),
+        ...(input.targetInstanceTypeRightSizingMethod != null && {
+            targetInstanceTypeRightSizingMethod: input.targetInstanceTypeRightSizingMethod,
+        }),
+    });
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const serializeAws_restJson1UpdateLaunchConfigurationTemplateCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/UpdateLaunchConfigurationTemplate";
+    let body;
+    body = JSON.stringify({
+        ...(input.associatePublicIpAddress != null && { associatePublicIpAddress: input.associatePublicIpAddress }),
+        ...(input.bootMode != null && { bootMode: input.bootMode }),
+        ...(input.copyPrivateIp != null && { copyPrivateIp: input.copyPrivateIp }),
+        ...(input.copyTags != null && { copyTags: input.copyTags }),
+        ...(input.enableMapAutoTagging != null && { enableMapAutoTagging: input.enableMapAutoTagging }),
+        ...(input.largeVolumeConf != null && {
+            largeVolumeConf: serializeAws_restJson1LaunchTemplateDiskConf(input.largeVolumeConf, context),
+        }),
+        ...(input.launchConfigurationTemplateID != null && {
+            launchConfigurationTemplateID: input.launchConfigurationTemplateID,
+        }),
+        ...(input.launchDisposition != null && { launchDisposition: input.launchDisposition }),
+        ...(input.licensing != null && { licensing: serializeAws_restJson1Licensing(input.licensing, context) }),
+        ...(input.mapAutoTaggingMpeID != null && { mapAutoTaggingMpeID: input.mapAutoTaggingMpeID }),
+        ...(input.postLaunchActions != null && {
+            postLaunchActions: serializeAws_restJson1PostLaunchActions(input.postLaunchActions, context),
+        }),
+        ...(input.smallVolumeConf != null && {
+            smallVolumeConf: serializeAws_restJson1LaunchTemplateDiskConf(input.smallVolumeConf, context),
+        }),
+        ...(input.smallVolumeMaxSize != null && { smallVolumeMaxSize: input.smallVolumeMaxSize }),
+        ...(input.targetInstanceTypeRightSizingMethod != null && {
+            targetInstanceTypeRightSizingMethod: input.targetInstanceTypeRightSizingMethod,
+        }),
+    });
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const serializeAws_restJson1UpdateReplicationConfigurationCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/UpdateReplicationConfiguration";
+    let body;
+    body = JSON.stringify({
+        ...(input.associateDefaultSecurityGroup != null && {
+            associateDefaultSecurityGroup: input.associateDefaultSecurityGroup,
+        }),
+        ...(input.bandwidthThrottling != null && { bandwidthThrottling: input.bandwidthThrottling }),
+        ...(input.createPublicIP != null && { createPublicIP: input.createPublicIP }),
+        ...(input.dataPlaneRouting != null && { dataPlaneRouting: input.dataPlaneRouting }),
+        ...(input.defaultLargeStagingDiskType != null && {
+            defaultLargeStagingDiskType: input.defaultLargeStagingDiskType,
+        }),
+        ...(input.ebsEncryption != null && { ebsEncryption: input.ebsEncryption }),
+        ...(input.ebsEncryptionKeyArn != null && { ebsEncryptionKeyArn: input.ebsEncryptionKeyArn }),
+        ...(input.name != null && { name: input.name }),
+        ...(input.replicatedDisks != null && {
+            replicatedDisks: serializeAws_restJson1ReplicationConfigurationReplicatedDisks(input.replicatedDisks, context),
+        }),
+        ...(input.replicationServerInstanceType != null && {
+            replicationServerInstanceType: input.replicationServerInstanceType,
+        }),
+        ...(input.replicationServersSecurityGroupsIDs != null && {
+            replicationServersSecurityGroupsIDs: serializeAws_restJson1ReplicationServersSecurityGroupsIDs(input.replicationServersSecurityGroupsIDs, context),
+        }),
+        ...(input.sourceServerID != null && { sourceServerID: input.sourceServerID }),
+        ...(input.stagingAreaSubnetId != null && { stagingAreaSubnetId: input.stagingAreaSubnetId }),
+        ...(input.stagingAreaTags != null && {
+            stagingAreaTags: serializeAws_restJson1TagsMap(input.stagingAreaTags, context),
+        }),
+        ...(input.useDedicatedReplicationServer != null && {
+            useDedicatedReplicationServer: input.useDedicatedReplicationServer,
+        }),
+    });
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const serializeAws_restJson1UpdateReplicationConfigurationTemplateCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/UpdateReplicationConfigurationTemplate";
+    let body;
+    body = JSON.stringify({
+        ...(input.arn != null && { arn: input.arn }),
+        ...(input.associateDefaultSecurityGroup != null && {
+            associateDefaultSecurityGroup: input.associateDefaultSecurityGroup,
+        }),
+        ...(input.bandwidthThrottling != null && { bandwidthThrottling: input.bandwidthThrottling }),
+        ...(input.createPublicIP != null && { createPublicIP: input.createPublicIP }),
+        ...(input.dataPlaneRouting != null && { dataPlaneRouting: input.dataPlaneRouting }),
+        ...(input.defaultLargeStagingDiskType != null && {
+            defaultLargeStagingDiskType: input.defaultLargeStagingDiskType,
+        }),
+        ...(input.ebsEncryption != null && { ebsEncryption: input.ebsEncryption }),
+        ...(input.ebsEncryptionKeyArn != null && { ebsEncryptionKeyArn: input.ebsEncryptionKeyArn }),
+        ...(input.replicationConfigurationTemplateID != null && {
+            replicationConfigurationTemplateID: input.replicationConfigurationTemplateID,
+        }),
+        ...(input.replicationServerInstanceType != null && {
+            replicationServerInstanceType: input.replicationServerInstanceType,
+        }),
+        ...(input.replicationServersSecurityGroupsIDs != null && {
+            replicationServersSecurityGroupsIDs: serializeAws_restJson1ReplicationServersSecurityGroupsIDs(input.replicationServersSecurityGroupsIDs, context),
+        }),
+        ...(input.stagingAreaSubnetId != null && { stagingAreaSubnetId: input.stagingAreaSubnetId }),
+        ...(input.stagingAreaTags != null && {
+            stagingAreaTags: serializeAws_restJson1TagsMap(input.stagingAreaTags, context),
+        }),
+        ...(input.useDedicatedReplicationServer != null && {
+            useDedicatedReplicationServer: input.useDedicatedReplicationServer,
+        }),
+    });
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const serializeAws_restJson1UpdateSourceServerReplicationTypeCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/UpdateSourceServerReplicationType";
+    let body;
+    body = JSON.stringify({
+        ...(input.replicationType != null && { replicationType: input.replicationType }),
+        ...(input.sourceServerID != null && { sourceServerID: input.sourceServerID }),
+    });
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const serializeAws_restJson1UpdateWaveCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/UpdateWave";
+    let body;
+    body = JSON.stringify({
+        ...(input.description != null && { description: input.description }),
+        ...(input.name != null && { name: input.name }),
+        ...(input.waveID != null && { waveID: input.waveID }),
+    });
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const deserializeAws_restJson1ArchiveApplicationCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1ArchiveApplicationCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.applicationAggregatedStatus != null) {
+        contents.applicationAggregatedStatus = deserializeAws_restJson1ApplicationAggregatedStatus(data.applicationAggregatedStatus, context);
+    }
+    if (data.applicationID != null) {
+        contents.applicationID = __expectString(data.applicationID);
+    }
+    if (data.arn != null) {
+        contents.arn = __expectString(data.arn);
+    }
+    if (data.creationDateTime != null) {
+        contents.creationDateTime = __expectString(data.creationDateTime);
+    }
+    if (data.description != null) {
+        contents.description = __expectString(data.description);
+    }
+    if (data.isArchived != null) {
+        contents.isArchived = __expectBoolean(data.isArchived);
+    }
+    if (data.lastModifiedDateTime != null) {
+        contents.lastModifiedDateTime = __expectString(data.lastModifiedDateTime);
+    }
+    if (data.name != null) {
+        contents.name = __expectString(data.name);
+    }
+    if (data.tags != null) {
+        contents.tags = deserializeAws_restJson1TagsMap(data.tags, context);
+    }
+    if (data.waveID != null) {
+        contents.waveID = __expectString(data.waveID);
+    }
+    return contents;
+};
+const deserializeAws_restJson1ArchiveApplicationCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "ConflictException":
+        case "com.amazonaws.mgn#ConflictException":
+            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.mgn#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ServiceQuotaExceededException":
+        case "com.amazonaws.mgn#ServiceQuotaExceededException":
+            throw await deserializeAws_restJson1ServiceQuotaExceededExceptionResponse(parsedOutput, context);
+        case "UninitializedAccountException":
+        case "com.amazonaws.mgn#UninitializedAccountException":
+            throw await deserializeAws_restJson1UninitializedAccountExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1ArchiveWaveCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1ArchiveWaveCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.arn != null) {
+        contents.arn = __expectString(data.arn);
+    }
+    if (data.creationDateTime != null) {
+        contents.creationDateTime = __expectString(data.creationDateTime);
+    }
+    if (data.description != null) {
+        contents.description = __expectString(data.description);
+    }
+    if (data.isArchived != null) {
+        contents.isArchived = __expectBoolean(data.isArchived);
+    }
+    if (data.lastModifiedDateTime != null) {
+        contents.lastModifiedDateTime = __expectString(data.lastModifiedDateTime);
+    }
+    if (data.name != null) {
+        contents.name = __expectString(data.name);
+    }
+    if (data.tags != null) {
+        contents.tags = deserializeAws_restJson1TagsMap(data.tags, context);
+    }
+    if (data.waveAggregatedStatus != null) {
+        contents.waveAggregatedStatus = deserializeAws_restJson1WaveAggregatedStatus(data.waveAggregatedStatus, context);
+    }
+    if (data.waveID != null) {
+        contents.waveID = __expectString(data.waveID);
+    }
+    return contents;
+};
+const deserializeAws_restJson1ArchiveWaveCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "ConflictException":
+        case "com.amazonaws.mgn#ConflictException":
+            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.mgn#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ServiceQuotaExceededException":
+        case "com.amazonaws.mgn#ServiceQuotaExceededException":
+            throw await deserializeAws_restJson1ServiceQuotaExceededExceptionResponse(parsedOutput, context);
+        case "UninitializedAccountException":
+        case "com.amazonaws.mgn#UninitializedAccountException":
+            throw await deserializeAws_restJson1UninitializedAccountExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1AssociateApplicationsCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1AssociateApplicationsCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
+const deserializeAws_restJson1AssociateApplicationsCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "ConflictException":
+        case "com.amazonaws.mgn#ConflictException":
+            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.mgn#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ServiceQuotaExceededException":
+        case "com.amazonaws.mgn#ServiceQuotaExceededException":
+            throw await deserializeAws_restJson1ServiceQuotaExceededExceptionResponse(parsedOutput, context);
+        case "UninitializedAccountException":
+        case "com.amazonaws.mgn#UninitializedAccountException":
+            throw await deserializeAws_restJson1UninitializedAccountExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1AssociateSourceServersCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1AssociateSourceServersCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
+const deserializeAws_restJson1AssociateSourceServersCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "ConflictException":
+        case "com.amazonaws.mgn#ConflictException":
+            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.mgn#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ServiceQuotaExceededException":
+        case "com.amazonaws.mgn#ServiceQuotaExceededException":
+            throw await deserializeAws_restJson1ServiceQuotaExceededExceptionResponse(parsedOutput, context);
+        case "UninitializedAccountException":
+        case "com.amazonaws.mgn#UninitializedAccountException":
+            throw await deserializeAws_restJson1UninitializedAccountExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1ChangeServerLifeCycleStateCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1ChangeServerLifeCycleStateCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.applicationID != null) {
+        contents.applicationID = __expectString(data.applicationID);
+    }
+    if (data.arn != null) {
+        contents.arn = __expectString(data.arn);
+    }
+    if (data.dataReplicationInfo != null) {
+        contents.dataReplicationInfo = deserializeAws_restJson1DataReplicationInfo(data.dataReplicationInfo, context);
+    }
+    if (data.isArchived != null) {
+        contents.isArchived = __expectBoolean(data.isArchived);
+    }
+    if (data.launchedInstance != null) {
+        contents.launchedInstance = deserializeAws_restJson1LaunchedInstance(data.launchedInstance, context);
+    }
+    if (data.lifeCycle != null) {
+        contents.lifeCycle = deserializeAws_restJson1LifeCycle(data.lifeCycle, context);
+    }
+    if (data.replicationType != null) {
+        contents.replicationType = __expectString(data.replicationType);
+    }
+    if (data.sourceProperties != null) {
+        contents.sourceProperties = deserializeAws_restJson1SourceProperties(data.sourceProperties, context);
+    }
+    if (data.sourceServerID != null) {
+        contents.sourceServerID = __expectString(data.sourceServerID);
+    }
+    if (data.tags != null) {
+        contents.tags = deserializeAws_restJson1TagsMap(data.tags, context);
+    }
+    if (data.vcenterClientID != null) {
+        contents.vcenterClientID = __expectString(data.vcenterClientID);
+    }
+    return contents;
+};
+const deserializeAws_restJson1ChangeServerLifeCycleStateCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "ConflictException":
+        case "com.amazonaws.mgn#ConflictException":
+            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.mgn#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "UninitializedAccountException":
+        case "com.amazonaws.mgn#UninitializedAccountException":
+            throw await deserializeAws_restJson1UninitializedAccountExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.mgn#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1CreateApplicationCommand = async (output, context) => {
+    if (output.statusCode !== 201 && output.statusCode >= 300) {
+        return deserializeAws_restJson1CreateApplicationCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.applicationAggregatedStatus != null) {
+        contents.applicationAggregatedStatus = deserializeAws_restJson1ApplicationAggregatedStatus(data.applicationAggregatedStatus, context);
+    }
+    if (data.applicationID != null) {
+        contents.applicationID = __expectString(data.applicationID);
+    }
+    if (data.arn != null) {
+        contents.arn = __expectString(data.arn);
+    }
+    if (data.creationDateTime != null) {
+        contents.creationDateTime = __expectString(data.creationDateTime);
+    }
+    if (data.description != null) {
+        contents.description = __expectString(data.description);
+    }
+    if (data.isArchived != null) {
+        contents.isArchived = __expectBoolean(data.isArchived);
+    }
+    if (data.lastModifiedDateTime != null) {
+        contents.lastModifiedDateTime = __expectString(data.lastModifiedDateTime);
+    }
+    if (data.name != null) {
+        contents.name = __expectString(data.name);
+    }
+    if (data.tags != null) {
+        contents.tags = deserializeAws_restJson1TagsMap(data.tags, context);
+    }
+    if (data.waveID != null) {
+        contents.waveID = __expectString(data.waveID);
+    }
+    return contents;
+};
+const deserializeAws_restJson1CreateApplicationCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "ConflictException":
+        case "com.amazonaws.mgn#ConflictException":
+            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+        case "ServiceQuotaExceededException":
+        case "com.amazonaws.mgn#ServiceQuotaExceededException":
+            throw await deserializeAws_restJson1ServiceQuotaExceededExceptionResponse(parsedOutput, context);
+        case "UninitializedAccountException":
+        case "com.amazonaws.mgn#UninitializedAccountException":
+            throw await deserializeAws_restJson1UninitializedAccountExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1CreateLaunchConfigurationTemplateCommand = async (output, context) => {
+    if (output.statusCode !== 201 && output.statusCode >= 300) {
+        return deserializeAws_restJson1CreateLaunchConfigurationTemplateCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.arn != null) {
+        contents.arn = __expectString(data.arn);
+    }
+    if (data.associatePublicIpAddress != null) {
+        contents.associatePublicIpAddress = __expectBoolean(data.associatePublicIpAddress);
+    }
+    if (data.bootMode != null) {
+        contents.bootMode = __expectString(data.bootMode);
+    }
+    if (data.copyPrivateIp != null) {
+        contents.copyPrivateIp = __expectBoolean(data.copyPrivateIp);
+    }
+    if (data.copyTags != null) {
+        contents.copyTags = __expectBoolean(data.copyTags);
+    }
+    if (data.ec2LaunchTemplateID != null) {
+        contents.ec2LaunchTemplateID = __expectString(data.ec2LaunchTemplateID);
+    }
+    if (data.enableMapAutoTagging != null) {
+        contents.enableMapAutoTagging = __expectBoolean(data.enableMapAutoTagging);
+    }
+    if (data.largeVolumeConf != null) {
+        contents.largeVolumeConf = deserializeAws_restJson1LaunchTemplateDiskConf(data.largeVolumeConf, context);
+    }
+    if (data.launchConfigurationTemplateID != null) {
+        contents.launchConfigurationTemplateID = __expectString(data.launchConfigurationTemplateID);
+    }
+    if (data.launchDisposition != null) {
+        contents.launchDisposition = __expectString(data.launchDisposition);
+    }
+    if (data.licensing != null) {
+        contents.licensing = deserializeAws_restJson1Licensing(data.licensing, context);
+    }
+    if (data.mapAutoTaggingMpeID != null) {
+        contents.mapAutoTaggingMpeID = __expectString(data.mapAutoTaggingMpeID);
+    }
+    if (data.postLaunchActions != null) {
+        contents.postLaunchActions = deserializeAws_restJson1PostLaunchActions(data.postLaunchActions, context);
+    }
+    if (data.smallVolumeConf != null) {
+        contents.smallVolumeConf = deserializeAws_restJson1LaunchTemplateDiskConf(data.smallVolumeConf, context);
+    }
+    if (data.smallVolumeMaxSize != null) {
+        contents.smallVolumeMaxSize = __expectLong(data.smallVolumeMaxSize);
+    }
+    if (data.tags != null) {
+        contents.tags = deserializeAws_restJson1TagsMap(data.tags, context);
+    }
+    if (data.targetInstanceTypeRightSizingMethod != null) {
+        contents.targetInstanceTypeRightSizingMethod = __expectString(data.targetInstanceTypeRightSizingMethod);
+    }
+    return contents;
+};
+const deserializeAws_restJson1CreateLaunchConfigurationTemplateCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.mgn#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "UninitializedAccountException":
+        case "com.amazonaws.mgn#UninitializedAccountException":
+            throw await deserializeAws_restJson1UninitializedAccountExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.mgn#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1CreateReplicationConfigurationTemplateCommand = async (output, context) => {
+    if (output.statusCode !== 201 && output.statusCode >= 300) {
+        return deserializeAws_restJson1CreateReplicationConfigurationTemplateCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.arn != null) {
+        contents.arn = __expectString(data.arn);
+    }
+    if (data.associateDefaultSecurityGroup != null) {
+        contents.associateDefaultSecurityGroup = __expectBoolean(data.associateDefaultSecurityGroup);
+    }
+    if (data.bandwidthThrottling != null) {
+        contents.bandwidthThrottling = __expectLong(data.bandwidthThrottling);
+    }
+    if (data.createPublicIP != null) {
+        contents.createPublicIP = __expectBoolean(data.createPublicIP);
+    }
+    if (data.dataPlaneRouting != null) {
+        contents.dataPlaneRouting = __expectString(data.dataPlaneRouting);
+    }
+    if (data.defaultLargeStagingDiskType != null) {
+        contents.defaultLargeStagingDiskType = __expectString(data.defaultLargeStagingDiskType);
+    }
+    if (data.ebsEncryption != null) {
+        contents.ebsEncryption = __expectString(data.ebsEncryption);
+    }
+    if (data.ebsEncryptionKeyArn != null) {
+        contents.ebsEncryptionKeyArn = __expectString(data.ebsEncryptionKeyArn);
+    }
+    if (data.replicationConfigurationTemplateID != null) {
+        contents.replicationConfigurationTemplateID = __expectString(data.replicationConfigurationTemplateID);
+    }
+    if (data.replicationServerInstanceType != null) {
+        contents.replicationServerInstanceType = __expectString(data.replicationServerInstanceType);
+    }
+    if (data.replicationServersSecurityGroupsIDs != null) {
+        contents.replicationServersSecurityGroupsIDs = deserializeAws_restJson1ReplicationServersSecurityGroupsIDs(data.replicationServersSecurityGroupsIDs, context);
+    }
+    if (data.stagingAreaSubnetId != null) {
+        contents.stagingAreaSubnetId = __expectString(data.stagingAreaSubnetId);
+    }
+    if (data.stagingAreaTags != null) {
+        contents.stagingAreaTags = deserializeAws_restJson1TagsMap(data.stagingAreaTags, context);
+    }
+    if (data.tags != null) {
+        contents.tags = deserializeAws_restJson1TagsMap(data.tags, context);
+    }
+    if (data.useDedicatedReplicationServer != null) {
+        contents.useDedicatedReplicationServer = __expectBoolean(data.useDedicatedReplicationServer);
+    }
+    return contents;
+};
+const deserializeAws_restJson1CreateReplicationConfigurationTemplateCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.mgn#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "UninitializedAccountException":
+        case "com.amazonaws.mgn#UninitializedAccountException":
+            throw await deserializeAws_restJson1UninitializedAccountExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.mgn#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1CreateWaveCommand = async (output, context) => {
+    if (output.statusCode !== 201 && output.statusCode >= 300) {
+        return deserializeAws_restJson1CreateWaveCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.arn != null) {
+        contents.arn = __expectString(data.arn);
+    }
+    if (data.creationDateTime != null) {
+        contents.creationDateTime = __expectString(data.creationDateTime);
+    }
+    if (data.description != null) {
+        contents.description = __expectString(data.description);
+    }
+    if (data.isArchived != null) {
+        contents.isArchived = __expectBoolean(data.isArchived);
+    }
+    if (data.lastModifiedDateTime != null) {
+        contents.lastModifiedDateTime = __expectString(data.lastModifiedDateTime);
+    }
+    if (data.name != null) {
+        contents.name = __expectString(data.name);
+    }
+    if (data.tags != null) {
+        contents.tags = deserializeAws_restJson1TagsMap(data.tags, context);
+    }
+    if (data.waveAggregatedStatus != null) {
+        contents.waveAggregatedStatus = deserializeAws_restJson1WaveAggregatedStatus(data.waveAggregatedStatus, context);
+    }
+    if (data.waveID != null) {
+        contents.waveID = __expectString(data.waveID);
+    }
+    return contents;
+};
+const deserializeAws_restJson1CreateWaveCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "ConflictException":
+        case "com.amazonaws.mgn#ConflictException":
+            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+        case "ServiceQuotaExceededException":
+        case "com.amazonaws.mgn#ServiceQuotaExceededException":
+            throw await deserializeAws_restJson1ServiceQuotaExceededExceptionResponse(parsedOutput, context);
+        case "UninitializedAccountException":
+        case "com.amazonaws.mgn#UninitializedAccountException":
+            throw await deserializeAws_restJson1UninitializedAccountExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1DeleteApplicationCommand = async (output, context) => {
+    if (output.statusCode !== 204 && output.statusCode >= 300) {
+        return deserializeAws_restJson1DeleteApplicationCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
+const deserializeAws_restJson1DeleteApplicationCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "ConflictException":
+        case "com.amazonaws.mgn#ConflictException":
+            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.mgn#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "UninitializedAccountException":
+        case "com.amazonaws.mgn#UninitializedAccountException":
+            throw await deserializeAws_restJson1UninitializedAccountExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1DeleteJobCommand = async (output, context) => {
+    if (output.statusCode !== 204 && output.statusCode >= 300) {
+        return deserializeAws_restJson1DeleteJobCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
+const deserializeAws_restJson1DeleteJobCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "ConflictException":
+        case "com.amazonaws.mgn#ConflictException":
+            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.mgn#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "UninitializedAccountException":
+        case "com.amazonaws.mgn#UninitializedAccountException":
+            throw await deserializeAws_restJson1UninitializedAccountExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1DeleteLaunchConfigurationTemplateCommand = async (output, context) => {
+    if (output.statusCode !== 204 && output.statusCode >= 300) {
+        return deserializeAws_restJson1DeleteLaunchConfigurationTemplateCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
+const deserializeAws_restJson1DeleteLaunchConfigurationTemplateCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "ConflictException":
+        case "com.amazonaws.mgn#ConflictException":
+            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.mgn#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "UninitializedAccountException":
+        case "com.amazonaws.mgn#UninitializedAccountException":
+            throw await deserializeAws_restJson1UninitializedAccountExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1DeleteReplicationConfigurationTemplateCommand = async (output, context) => {
+    if (output.statusCode !== 204 && output.statusCode >= 300) {
+        return deserializeAws_restJson1DeleteReplicationConfigurationTemplateCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
+const deserializeAws_restJson1DeleteReplicationConfigurationTemplateCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "ConflictException":
+        case "com.amazonaws.mgn#ConflictException":
+            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.mgn#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "UninitializedAccountException":
+        case "com.amazonaws.mgn#UninitializedAccountException":
+            throw await deserializeAws_restJson1UninitializedAccountExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1DeleteSourceServerCommand = async (output, context) => {
+    if (output.statusCode !== 204 && output.statusCode >= 300) {
+        return deserializeAws_restJson1DeleteSourceServerCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
+const deserializeAws_restJson1DeleteSourceServerCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "ConflictException":
+        case "com.amazonaws.mgn#ConflictException":
+            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.mgn#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "UninitializedAccountException":
+        case "com.amazonaws.mgn#UninitializedAccountException":
+            throw await deserializeAws_restJson1UninitializedAccountExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1DeleteVcenterClientCommand = async (output, context) => {
+    if (output.statusCode !== 204 && output.statusCode >= 300) {
+        return deserializeAws_restJson1DeleteVcenterClientCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
+const deserializeAws_restJson1DeleteVcenterClientCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "ResourceNotFoundException":
+        case "com.amazonaws.mgn#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "UninitializedAccountException":
+        case "com.amazonaws.mgn#UninitializedAccountException":
+            throw await deserializeAws_restJson1UninitializedAccountExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.mgn#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1DeleteWaveCommand = async (output, context) => {
+    if (output.statusCode !== 204 && output.statusCode >= 300) {
+        return deserializeAws_restJson1DeleteWaveCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
+const deserializeAws_restJson1DeleteWaveCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "ConflictException":
+        case "com.amazonaws.mgn#ConflictException":
+            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.mgn#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "UninitializedAccountException":
+        case "com.amazonaws.mgn#UninitializedAccountException":
+            throw await deserializeAws_restJson1UninitializedAccountExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1DescribeJobLogItemsCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1DescribeJobLogItemsCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.items != null) {
+        contents.items = deserializeAws_restJson1JobLogs(data.items, context);
+    }
+    if (data.nextToken != null) {
+        contents.nextToken = __expectString(data.nextToken);
+    }
+    return contents;
+};
+const deserializeAws_restJson1DescribeJobLogItemsCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "UninitializedAccountException":
+        case "com.amazonaws.mgn#UninitializedAccountException":
+            throw await deserializeAws_restJson1UninitializedAccountExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.mgn#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1DescribeJobsCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1DescribeJobsCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.items != null) {
+        contents.items = deserializeAws_restJson1JobsList(data.items, context);
+    }
+    if (data.nextToken != null) {
+        contents.nextToken = __expectString(data.nextToken);
+    }
+    return contents;
+};
+const deserializeAws_restJson1DescribeJobsCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "UninitializedAccountException":
+        case "com.amazonaws.mgn#UninitializedAccountException":
+            throw await deserializeAws_restJson1UninitializedAccountExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.mgn#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1DescribeLaunchConfigurationTemplatesCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1DescribeLaunchConfigurationTemplatesCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.items != null) {
+        contents.items = deserializeAws_restJson1LaunchConfigurationTemplates(data.items, context);
+    }
+    if (data.nextToken != null) {
+        contents.nextToken = __expectString(data.nextToken);
+    }
+    return contents;
+};
+const deserializeAws_restJson1DescribeLaunchConfigurationTemplatesCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "ResourceNotFoundException":
+        case "com.amazonaws.mgn#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "UninitializedAccountException":
+        case "com.amazonaws.mgn#UninitializedAccountException":
+            throw await deserializeAws_restJson1UninitializedAccountExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.mgn#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1DescribeReplicationConfigurationTemplatesCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1DescribeReplicationConfigurationTemplatesCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.items != null) {
+        contents.items = deserializeAws_restJson1ReplicationConfigurationTemplates(data.items, context);
+    }
+    if (data.nextToken != null) {
+        contents.nextToken = __expectString(data.nextToken);
+    }
+    return contents;
+};
+const deserializeAws_restJson1DescribeReplicationConfigurationTemplatesCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "ResourceNotFoundException":
+        case "com.amazonaws.mgn#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "UninitializedAccountException":
+        case "com.amazonaws.mgn#UninitializedAccountException":
+            throw await deserializeAws_restJson1UninitializedAccountExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.mgn#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1DescribeSourceServersCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1DescribeSourceServersCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.items != null) {
+        contents.items = deserializeAws_restJson1SourceServersList(data.items, context);
+    }
+    if (data.nextToken != null) {
+        contents.nextToken = __expectString(data.nextToken);
     }
     return contents;
 };
-const deserializeAws_restJson1CreateLaunchConfigurationTemplateCommandError = async (output, context) => {
+const deserializeAws_restJson1DescribeSourceServersCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
     };
     const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
     switch (errorCode) {
-        case "AccessDeniedException":
-        case "com.amazonaws.mgn#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
         case "UninitializedAccountException":
         case "com.amazonaws.mgn#UninitializedAccountException":
             throw await deserializeAws_restJson1UninitializedAccountExceptionResponse(parsedOutput, context);
@@ -907,71 +2373,32 @@ const deserializeAws_restJson1CreateLaunchConfigurationTemplateCommandError = as
             });
     }
 };
-export const deserializeAws_restJson1CreateReplicationConfigurationTemplateCommand = async (output, context) => {
-    if (output.statusCode !== 201 && output.statusCode >= 300) {
-        return deserializeAws_restJson1CreateReplicationConfigurationTemplateCommandError(output, context);
+export const deserializeAws_restJson1DescribeVcenterClientsCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1DescribeVcenterClientsCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
-    if (data.arn != null) {
-        contents.arn = __expectString(data.arn);
-    }
-    if (data.associateDefaultSecurityGroup != null) {
-        contents.associateDefaultSecurityGroup = __expectBoolean(data.associateDefaultSecurityGroup);
-    }
-    if (data.bandwidthThrottling != null) {
-        contents.bandwidthThrottling = __expectLong(data.bandwidthThrottling);
-    }
-    if (data.createPublicIP != null) {
-        contents.createPublicIP = __expectBoolean(data.createPublicIP);
-    }
-    if (data.dataPlaneRouting != null) {
-        contents.dataPlaneRouting = __expectString(data.dataPlaneRouting);
-    }
-    if (data.defaultLargeStagingDiskType != null) {
-        contents.defaultLargeStagingDiskType = __expectString(data.defaultLargeStagingDiskType);
-    }
-    if (data.ebsEncryption != null) {
-        contents.ebsEncryption = __expectString(data.ebsEncryption);
-    }
-    if (data.ebsEncryptionKeyArn != null) {
-        contents.ebsEncryptionKeyArn = __expectString(data.ebsEncryptionKeyArn);
-    }
-    if (data.replicationConfigurationTemplateID != null) {
-        contents.replicationConfigurationTemplateID = __expectString(data.replicationConfigurationTemplateID);
-    }
-    if (data.replicationServerInstanceType != null) {
-        contents.replicationServerInstanceType = __expectString(data.replicationServerInstanceType);
-    }
-    if (data.replicationServersSecurityGroupsIDs != null) {
-        contents.replicationServersSecurityGroupsIDs = deserializeAws_restJson1ReplicationServersSecurityGroupsIDs(data.replicationServersSecurityGroupsIDs, context);
-    }
-    if (data.stagingAreaSubnetId != null) {
-        contents.stagingAreaSubnetId = __expectString(data.stagingAreaSubnetId);
-    }
-    if (data.stagingAreaTags != null) {
-        contents.stagingAreaTags = deserializeAws_restJson1TagsMap(data.stagingAreaTags, context);
-    }
-    if (data.tags != null) {
-        contents.tags = deserializeAws_restJson1TagsMap(data.tags, context);
+    if (data.items != null) {
+        contents.items = deserializeAws_restJson1VcenterClientList(data.items, context);
     }
-    if (data.useDedicatedReplicationServer != null) {
-        contents.useDedicatedReplicationServer = __expectBoolean(data.useDedicatedReplicationServer);
+    if (data.nextToken != null) {
+        contents.nextToken = __expectString(data.nextToken);
     }
     return contents;
 };
-const deserializeAws_restJson1CreateReplicationConfigurationTemplateCommandError = async (output, context) => {
+const deserializeAws_restJson1DescribeVcenterClientsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
     };
     const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
     switch (errorCode) {
-        case "AccessDeniedException":
-        case "com.amazonaws.mgn#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.mgn#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
         case "UninitializedAccountException":
         case "com.amazonaws.mgn#UninitializedAccountException":
             throw await deserializeAws_restJson1UninitializedAccountExceptionResponse(parsedOutput, context);
@@ -988,9 +2415,9 @@ const deserializeAws_restJson1CreateReplicationConfigurationTemplateCommandError
             });
     }
 };
-export const deserializeAws_restJson1DeleteJobCommand = async (output, context) => {
-    if (output.statusCode !== 204 && output.statusCode >= 300) {
-        return deserializeAws_restJson1DeleteJobCommandError(output, context);
+export const deserializeAws_restJson1DisassociateApplicationsCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1DisassociateApplicationsCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -998,7 +2425,7 @@ export const deserializeAws_restJson1DeleteJobCommand = async (output, context)
     await collectBody(output.body, context);
     return contents;
 };
-const deserializeAws_restJson1DeleteJobCommandError = async (output, context) => {
+const deserializeAws_restJson1DisassociateApplicationsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1024,9 +2451,9 @@ const deserializeAws_restJson1DeleteJobCommandError = async (output, context) =>
             });
     }
 };
-export const deserializeAws_restJson1DeleteLaunchConfigurationTemplateCommand = async (output, context) => {
-    if (output.statusCode !== 204 && output.statusCode >= 300) {
-        return deserializeAws_restJson1DeleteLaunchConfigurationTemplateCommandError(output, context);
+export const deserializeAws_restJson1DisassociateSourceServersCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1DisassociateSourceServersCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1034,7 +2461,7 @@ export const deserializeAws_restJson1DeleteLaunchConfigurationTemplateCommand =
     await collectBody(output.body, context);
     return contents;
 };
-const deserializeAws_restJson1DeleteLaunchConfigurationTemplateCommandError = async (output, context) => {
+const deserializeAws_restJson1DisassociateSourceServersCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1060,17 +2487,50 @@ const deserializeAws_restJson1DeleteLaunchConfigurationTemplateCommandError = as
             });
     }
 };
-export const deserializeAws_restJson1DeleteReplicationConfigurationTemplateCommand = async (output, context) => {
-    if (output.statusCode !== 204 && output.statusCode >= 300) {
-        return deserializeAws_restJson1DeleteReplicationConfigurationTemplateCommandError(output, context);
+export const deserializeAws_restJson1DisconnectFromServiceCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1DisconnectFromServiceCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
-    await collectBody(output.body, context);
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.applicationID != null) {
+        contents.applicationID = __expectString(data.applicationID);
+    }
+    if (data.arn != null) {
+        contents.arn = __expectString(data.arn);
+    }
+    if (data.dataReplicationInfo != null) {
+        contents.dataReplicationInfo = deserializeAws_restJson1DataReplicationInfo(data.dataReplicationInfo, context);
+    }
+    if (data.isArchived != null) {
+        contents.isArchived = __expectBoolean(data.isArchived);
+    }
+    if (data.launchedInstance != null) {
+        contents.launchedInstance = deserializeAws_restJson1LaunchedInstance(data.launchedInstance, context);
+    }
+    if (data.lifeCycle != null) {
+        contents.lifeCycle = deserializeAws_restJson1LifeCycle(data.lifeCycle, context);
+    }
+    if (data.replicationType != null) {
+        contents.replicationType = __expectString(data.replicationType);
+    }
+    if (data.sourceProperties != null) {
+        contents.sourceProperties = deserializeAws_restJson1SourceProperties(data.sourceProperties, context);
+    }
+    if (data.sourceServerID != null) {
+        contents.sourceServerID = __expectString(data.sourceServerID);
+    }
+    if (data.tags != null) {
+        contents.tags = deserializeAws_restJson1TagsMap(data.tags, context);
+    }
+    if (data.vcenterClientID != null) {
+        contents.vcenterClientID = __expectString(data.vcenterClientID);
+    }
     return contents;
 };
-const deserializeAws_restJson1DeleteReplicationConfigurationTemplateCommandError = async (output, context) => {
+const deserializeAws_restJson1DisconnectFromServiceCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1096,17 +2556,50 @@ const deserializeAws_restJson1DeleteReplicationConfigurationTemplateCommandError
             });
     }
 };
-export const deserializeAws_restJson1DeleteSourceServerCommand = async (output, context) => {
-    if (output.statusCode !== 204 && output.statusCode >= 300) {
-        return deserializeAws_restJson1DeleteSourceServerCommandError(output, context);
+export const deserializeAws_restJson1FinalizeCutoverCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1FinalizeCutoverCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
-    await collectBody(output.body, context);
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.applicationID != null) {
+        contents.applicationID = __expectString(data.applicationID);
+    }
+    if (data.arn != null) {
+        contents.arn = __expectString(data.arn);
+    }
+    if (data.dataReplicationInfo != null) {
+        contents.dataReplicationInfo = deserializeAws_restJson1DataReplicationInfo(data.dataReplicationInfo, context);
+    }
+    if (data.isArchived != null) {
+        contents.isArchived = __expectBoolean(data.isArchived);
+    }
+    if (data.launchedInstance != null) {
+        contents.launchedInstance = deserializeAws_restJson1LaunchedInstance(data.launchedInstance, context);
+    }
+    if (data.lifeCycle != null) {
+        contents.lifeCycle = deserializeAws_restJson1LifeCycle(data.lifeCycle, context);
+    }
+    if (data.replicationType != null) {
+        contents.replicationType = __expectString(data.replicationType);
+    }
+    if (data.sourceProperties != null) {
+        contents.sourceProperties = deserializeAws_restJson1SourceProperties(data.sourceProperties, context);
+    }
+    if (data.sourceServerID != null) {
+        contents.sourceServerID = __expectString(data.sourceServerID);
+    }
+    if (data.tags != null) {
+        contents.tags = deserializeAws_restJson1TagsMap(data.tags, context);
+    }
+    if (data.vcenterClientID != null) {
+        contents.vcenterClientID = __expectString(data.vcenterClientID);
+    }
     return contents;
 };
-const deserializeAws_restJson1DeleteSourceServerCommandError = async (output, context) => {
+const deserializeAws_restJson1FinalizeCutoverCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1122,6 +2615,9 @@ const deserializeAws_restJson1DeleteSourceServerCommandError = async (output, co
         case "UninitializedAccountException":
         case "com.amazonaws.mgn#UninitializedAccountException":
             throw await deserializeAws_restJson1UninitializedAccountExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.mgn#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1132,17 +2628,53 @@ const deserializeAws_restJson1DeleteSourceServerCommandError = async (output, co
             });
     }
 };
-export const deserializeAws_restJson1DeleteVcenterClientCommand = async (output, context) => {
-    if (output.statusCode !== 204 && output.statusCode >= 300) {
-        return deserializeAws_restJson1DeleteVcenterClientCommandError(output, context);
+export const deserializeAws_restJson1GetLaunchConfigurationCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1GetLaunchConfigurationCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
-    await collectBody(output.body, context);
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.bootMode != null) {
+        contents.bootMode = __expectString(data.bootMode);
+    }
+    if (data.copyPrivateIp != null) {
+        contents.copyPrivateIp = __expectBoolean(data.copyPrivateIp);
+    }
+    if (data.copyTags != null) {
+        contents.copyTags = __expectBoolean(data.copyTags);
+    }
+    if (data.ec2LaunchTemplateID != null) {
+        contents.ec2LaunchTemplateID = __expectString(data.ec2LaunchTemplateID);
+    }
+    if (data.enableMapAutoTagging != null) {
+        contents.enableMapAutoTagging = __expectBoolean(data.enableMapAutoTagging);
+    }
+    if (data.launchDisposition != null) {
+        contents.launchDisposition = __expectString(data.launchDisposition);
+    }
+    if (data.licensing != null) {
+        contents.licensing = deserializeAws_restJson1Licensing(data.licensing, context);
+    }
+    if (data.mapAutoTaggingMpeID != null) {
+        contents.mapAutoTaggingMpeID = __expectString(data.mapAutoTaggingMpeID);
+    }
+    if (data.name != null) {
+        contents.name = __expectString(data.name);
+    }
+    if (data.postLaunchActions != null) {
+        contents.postLaunchActions = deserializeAws_restJson1PostLaunchActions(data.postLaunchActions, context);
+    }
+    if (data.sourceServerID != null) {
+        contents.sourceServerID = __expectString(data.sourceServerID);
+    }
+    if (data.targetInstanceTypeRightSizingMethod != null) {
+        contents.targetInstanceTypeRightSizingMethod = __expectString(data.targetInstanceTypeRightSizingMethod);
+    }
     return contents;
 };
-const deserializeAws_restJson1DeleteVcenterClientCommandError = async (output, context) => {
+const deserializeAws_restJson1GetLaunchConfigurationCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1155,9 +2687,6 @@ const deserializeAws_restJson1DeleteVcenterClientCommandError = async (output, c
         case "UninitializedAccountException":
         case "com.amazonaws.mgn#UninitializedAccountException":
             throw await deserializeAws_restJson1UninitializedAccountExceptionResponse(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.mgn#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1168,35 +2697,74 @@ const deserializeAws_restJson1DeleteVcenterClientCommandError = async (output, c
             });
     }
 };
-export const deserializeAws_restJson1DescribeJobLogItemsCommand = async (output, context) => {
+export const deserializeAws_restJson1GetReplicationConfigurationCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1DescribeJobLogItemsCommandError(output, context);
+        return deserializeAws_restJson1GetReplicationConfigurationCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.associateDefaultSecurityGroup != null) {
+        contents.associateDefaultSecurityGroup = __expectBoolean(data.associateDefaultSecurityGroup);
+    }
+    if (data.bandwidthThrottling != null) {
+        contents.bandwidthThrottling = __expectLong(data.bandwidthThrottling);
+    }
+    if (data.createPublicIP != null) {
+        contents.createPublicIP = __expectBoolean(data.createPublicIP);
+    }
+    if (data.dataPlaneRouting != null) {
+        contents.dataPlaneRouting = __expectString(data.dataPlaneRouting);
+    }
+    if (data.defaultLargeStagingDiskType != null) {
+        contents.defaultLargeStagingDiskType = __expectString(data.defaultLargeStagingDiskType);
+    }
+    if (data.ebsEncryption != null) {
+        contents.ebsEncryption = __expectString(data.ebsEncryption);
+    }
+    if (data.ebsEncryptionKeyArn != null) {
+        contents.ebsEncryptionKeyArn = __expectString(data.ebsEncryptionKeyArn);
+    }
+    if (data.name != null) {
+        contents.name = __expectString(data.name);
+    }
+    if (data.replicatedDisks != null) {
+        contents.replicatedDisks = deserializeAws_restJson1ReplicationConfigurationReplicatedDisks(data.replicatedDisks, context);
+    }
+    if (data.replicationServerInstanceType != null) {
+        contents.replicationServerInstanceType = __expectString(data.replicationServerInstanceType);
+    }
+    if (data.replicationServersSecurityGroupsIDs != null) {
+        contents.replicationServersSecurityGroupsIDs = deserializeAws_restJson1ReplicationServersSecurityGroupsIDs(data.replicationServersSecurityGroupsIDs, context);
+    }
+    if (data.sourceServerID != null) {
+        contents.sourceServerID = __expectString(data.sourceServerID);
+    }
+    if (data.stagingAreaSubnetId != null) {
+        contents.stagingAreaSubnetId = __expectString(data.stagingAreaSubnetId);
     }
-    const contents = map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
-    if (data.items != null) {
-        contents.items = deserializeAws_restJson1JobLogs(data.items, context);
+    if (data.stagingAreaTags != null) {
+        contents.stagingAreaTags = deserializeAws_restJson1TagsMap(data.stagingAreaTags, context);
     }
-    if (data.nextToken != null) {
-        contents.nextToken = __expectString(data.nextToken);
+    if (data.useDedicatedReplicationServer != null) {
+        contents.useDedicatedReplicationServer = __expectBoolean(data.useDedicatedReplicationServer);
     }
     return contents;
 };
-const deserializeAws_restJson1DescribeJobLogItemsCommandError = async (output, context) => {
+const deserializeAws_restJson1GetReplicationConfigurationCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
     };
     const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
     switch (errorCode) {
+        case "ResourceNotFoundException":
+        case "com.amazonaws.mgn#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
         case "UninitializedAccountException":
         case "com.amazonaws.mgn#UninitializedAccountException":
             throw await deserializeAws_restJson1UninitializedAccountExceptionResponse(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.mgn#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1207,32 +2775,26 @@ const deserializeAws_restJson1DescribeJobLogItemsCommandError = async (output, c
             });
     }
 };
-export const deserializeAws_restJson1DescribeJobsCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1DescribeJobsCommandError(output, context);
+export const deserializeAws_restJson1InitializeServiceCommand = async (output, context) => {
+    if (output.statusCode !== 204 && output.statusCode >= 300) {
+        return deserializeAws_restJson1InitializeServiceCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
-    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
-    if (data.items != null) {
-        contents.items = deserializeAws_restJson1JobsList(data.items, context);
-    }
-    if (data.nextToken != null) {
-        contents.nextToken = __expectString(data.nextToken);
-    }
+    await collectBody(output.body, context);
     return contents;
 };
-const deserializeAws_restJson1DescribeJobsCommandError = async (output, context) => {
+const deserializeAws_restJson1InitializeServiceCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
     };
     const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
     switch (errorCode) {
-        case "UninitializedAccountException":
-        case "com.amazonaws.mgn#UninitializedAccountException":
-            throw await deserializeAws_restJson1UninitializedAccountExceptionResponse(parsedOutput, context);
+        case "AccessDeniedException":
+        case "com.amazonaws.mgn#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.mgn#ValidationException":
             throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
@@ -1246,38 +2808,32 @@ const deserializeAws_restJson1DescribeJobsCommandError = async (output, context)
             });
     }
 };
-export const deserializeAws_restJson1DescribeLaunchConfigurationTemplatesCommand = async (output, context) => {
+export const deserializeAws_restJson1ListApplicationsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1DescribeLaunchConfigurationTemplatesCommandError(output, context);
+        return deserializeAws_restJson1ListApplicationsCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.items != null) {
-        contents.items = deserializeAws_restJson1LaunchConfigurationTemplates(data.items, context);
+        contents.items = deserializeAws_restJson1ApplicationsList(data.items, context);
     }
     if (data.nextToken != null) {
         contents.nextToken = __expectString(data.nextToken);
     }
     return contents;
 };
-const deserializeAws_restJson1DescribeLaunchConfigurationTemplatesCommandError = async (output, context) => {
+const deserializeAws_restJson1ListApplicationsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
     };
     const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
     switch (errorCode) {
-        case "ResourceNotFoundException":
-        case "com.amazonaws.mgn#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
         case "UninitializedAccountException":
         case "com.amazonaws.mgn#UninitializedAccountException":
             throw await deserializeAws_restJson1UninitializedAccountExceptionResponse(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.mgn#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1288,23 +2844,23 @@ const deserializeAws_restJson1DescribeLaunchConfigurationTemplatesCommandError =
             });
     }
 };
-export const deserializeAws_restJson1DescribeReplicationConfigurationTemplatesCommand = async (output, context) => {
+export const deserializeAws_restJson1ListSourceServerActionsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1DescribeReplicationConfigurationTemplatesCommandError(output, context);
+        return deserializeAws_restJson1ListSourceServerActionsCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.items != null) {
-        contents.items = deserializeAws_restJson1ReplicationConfigurationTemplates(data.items, context);
+        contents.items = deserializeAws_restJson1SourceServerActionDocuments(data.items, context);
     }
     if (data.nextToken != null) {
         contents.nextToken = __expectString(data.nextToken);
     }
     return contents;
 };
-const deserializeAws_restJson1DescribeReplicationConfigurationTemplatesCommandError = async (output, context) => {
+const deserializeAws_restJson1ListSourceServerActionsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1317,9 +2873,6 @@ const deserializeAws_restJson1DescribeReplicationConfigurationTemplatesCommandEr
         case "UninitializedAccountException":
         case "com.amazonaws.mgn#UninitializedAccountException":
             throw await deserializeAws_restJson1UninitializedAccountExceptionResponse(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.mgn#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1330,32 +2883,38 @@ const deserializeAws_restJson1DescribeReplicationConfigurationTemplatesCommandEr
             });
     }
 };
-export const deserializeAws_restJson1DescribeSourceServersCommand = async (output, context) => {
+export const deserializeAws_restJson1ListTagsForResourceCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1DescribeSourceServersCommandError(output, context);
+        return deserializeAws_restJson1ListTagsForResourceCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
-    if (data.items != null) {
-        contents.items = deserializeAws_restJson1SourceServersList(data.items, context);
-    }
-    if (data.nextToken != null) {
-        contents.nextToken = __expectString(data.nextToken);
+    if (data.tags != null) {
+        contents.tags = deserializeAws_restJson1TagsMap(data.tags, context);
     }
     return contents;
 };
-const deserializeAws_restJson1DescribeSourceServersCommandError = async (output, context) => {
+const deserializeAws_restJson1ListTagsForResourceCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
     };
     const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
     switch (errorCode) {
-        case "UninitializedAccountException":
-        case "com.amazonaws.mgn#UninitializedAccountException":
-            throw await deserializeAws_restJson1UninitializedAccountExceptionResponse(parsedOutput, context);
+        case "AccessDeniedException":
+        case "com.amazonaws.mgn#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.mgn#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.mgn#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.mgn#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.mgn#ValidationException":
             throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
@@ -1369,23 +2928,23 @@ const deserializeAws_restJson1DescribeSourceServersCommandError = async (output,
             });
     }
 };
-export const deserializeAws_restJson1DescribeVcenterClientsCommand = async (output, context) => {
+export const deserializeAws_restJson1ListTemplateActionsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1DescribeVcenterClientsCommandError(output, context);
+        return deserializeAws_restJson1ListTemplateActionsCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.items != null) {
-        contents.items = deserializeAws_restJson1VcenterClientList(data.items, context);
+        contents.items = deserializeAws_restJson1TemplateActionDocuments(data.items, context);
     }
     if (data.nextToken != null) {
         contents.nextToken = __expectString(data.nextToken);
     }
     return contents;
 };
-const deserializeAws_restJson1DescribeVcenterClientsCommandError = async (output, context) => {
+const deserializeAws_restJson1ListTemplateActionsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1398,9 +2957,6 @@ const deserializeAws_restJson1DescribeVcenterClientsCommandError = async (output
         case "UninitializedAccountException":
         case "com.amazonaws.mgn#UninitializedAccountException":
             throw await deserializeAws_restJson1UninitializedAccountExceptionResponse(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.mgn#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1411,59 +2967,29 @@ const deserializeAws_restJson1DescribeVcenterClientsCommandError = async (output
             });
     }
 };
-export const deserializeAws_restJson1DisconnectFromServiceCommand = async (output, context) => {
+export const deserializeAws_restJson1ListWavesCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1DisconnectFromServiceCommandError(output, context);
+        return deserializeAws_restJson1ListWavesCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
-    if (data.arn != null) {
-        contents.arn = __expectString(data.arn);
-    }
-    if (data.dataReplicationInfo != null) {
-        contents.dataReplicationInfo = deserializeAws_restJson1DataReplicationInfo(data.dataReplicationInfo, context);
-    }
-    if (data.isArchived != null) {
-        contents.isArchived = __expectBoolean(data.isArchived);
-    }
-    if (data.launchedInstance != null) {
-        contents.launchedInstance = deserializeAws_restJson1LaunchedInstance(data.launchedInstance, context);
-    }
-    if (data.lifeCycle != null) {
-        contents.lifeCycle = deserializeAws_restJson1LifeCycle(data.lifeCycle, context);
-    }
-    if (data.replicationType != null) {
-        contents.replicationType = __expectString(data.replicationType);
-    }
-    if (data.sourceProperties != null) {
-        contents.sourceProperties = deserializeAws_restJson1SourceProperties(data.sourceProperties, context);
-    }
-    if (data.sourceServerID != null) {
-        contents.sourceServerID = __expectString(data.sourceServerID);
-    }
-    if (data.tags != null) {
-        contents.tags = deserializeAws_restJson1TagsMap(data.tags, context);
+    if (data.items != null) {
+        contents.items = deserializeAws_restJson1WavesList(data.items, context);
     }
-    if (data.vcenterClientID != null) {
-        contents.vcenterClientID = __expectString(data.vcenterClientID);
+    if (data.nextToken != null) {
+        contents.nextToken = __expectString(data.nextToken);
     }
     return contents;
 };
-const deserializeAws_restJson1DisconnectFromServiceCommandError = async (output, context) => {
+const deserializeAws_restJson1ListWavesCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
     };
     const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
     switch (errorCode) {
-        case "ConflictException":
-        case "com.amazonaws.mgn#ConflictException":
-            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.mgn#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
         case "UninitializedAccountException":
         case "com.amazonaws.mgn#UninitializedAccountException":
             throw await deserializeAws_restJson1UninitializedAccountExceptionResponse(parsedOutput, context);
@@ -1477,14 +3003,17 @@ const deserializeAws_restJson1DisconnectFromServiceCommandError = async (output,
             });
     }
 };
-export const deserializeAws_restJson1FinalizeCutoverCommand = async (output, context) => {
+export const deserializeAws_restJson1MarkAsArchivedCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1FinalizeCutoverCommandError(output, context);
+        return deserializeAws_restJson1MarkAsArchivedCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.applicationID != null) {
+        contents.applicationID = __expectString(data.applicationID);
+    }
     if (data.arn != null) {
         contents.arn = __expectString(data.arn);
     }
@@ -1517,7 +3046,7 @@ export const deserializeAws_restJson1FinalizeCutoverCommand = async (output, con
     }
     return contents;
 };
-const deserializeAws_restJson1FinalizeCutoverCommandError = async (output, context) => {
+const deserializeAws_restJson1MarkAsArchivedCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1531,72 +3060,6 @@ const deserializeAws_restJson1FinalizeCutoverCommandError = async (output, conte
         case "com.amazonaws.mgn#ResourceNotFoundException":
             throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
         case "UninitializedAccountException":
-        case "com.amazonaws.mgn#UninitializedAccountException":
-            throw await deserializeAws_restJson1UninitializedAccountExceptionResponse(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.mgn#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            throwDefaultError({
-                output,
-                parsedBody,
-                exceptionCtor: __BaseException,
-                errorCode,
-            });
-    }
-};
-export const deserializeAws_restJson1GetLaunchConfigurationCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1GetLaunchConfigurationCommandError(output, context);
-    }
-    const contents = map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
-    if (data.bootMode != null) {
-        contents.bootMode = __expectString(data.bootMode);
-    }
-    if (data.copyPrivateIp != null) {
-        contents.copyPrivateIp = __expectBoolean(data.copyPrivateIp);
-    }
-    if (data.copyTags != null) {
-        contents.copyTags = __expectBoolean(data.copyTags);
-    }
-    if (data.ec2LaunchTemplateID != null) {
-        contents.ec2LaunchTemplateID = __expectString(data.ec2LaunchTemplateID);
-    }
-    if (data.launchDisposition != null) {
-        contents.launchDisposition = __expectString(data.launchDisposition);
-    }
-    if (data.licensing != null) {
-        contents.licensing = deserializeAws_restJson1Licensing(data.licensing, context);
-    }
-    if (data.name != null) {
-        contents.name = __expectString(data.name);
-    }
-    if (data.postLaunchActions != null) {
-        contents.postLaunchActions = deserializeAws_restJson1PostLaunchActions(data.postLaunchActions, context);
-    }
-    if (data.sourceServerID != null) {
-        contents.sourceServerID = __expectString(data.sourceServerID);
-    }
-    if (data.targetInstanceTypeRightSizingMethod != null) {
-        contents.targetInstanceTypeRightSizingMethod = __expectString(data.targetInstanceTypeRightSizingMethod);
-    }
-    return contents;
-};
-const deserializeAws_restJson1GetLaunchConfigurationCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ResourceNotFoundException":
-        case "com.amazonaws.mgn#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
-        case "UninitializedAccountException":
         case "com.amazonaws.mgn#UninitializedAccountException":
             throw await deserializeAws_restJson1UninitializedAccountExceptionResponse(parsedOutput, context);
         default:
@@ -1609,74 +3072,62 @@ const deserializeAws_restJson1GetLaunchConfigurationCommandError = async (output
             });
     }
 };
-export const deserializeAws_restJson1GetReplicationConfigurationCommand = async (output, context) => {
+export const deserializeAws_restJson1PutSourceServerActionCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1GetReplicationConfigurationCommandError(output, context);
+        return deserializeAws_restJson1PutSourceServerActionCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
-    if (data.associateDefaultSecurityGroup != null) {
-        contents.associateDefaultSecurityGroup = __expectBoolean(data.associateDefaultSecurityGroup);
-    }
-    if (data.bandwidthThrottling != null) {
-        contents.bandwidthThrottling = __expectLong(data.bandwidthThrottling);
-    }
-    if (data.createPublicIP != null) {
-        contents.createPublicIP = __expectBoolean(data.createPublicIP);
-    }
-    if (data.dataPlaneRouting != null) {
-        contents.dataPlaneRouting = __expectString(data.dataPlaneRouting);
-    }
-    if (data.defaultLargeStagingDiskType != null) {
-        contents.defaultLargeStagingDiskType = __expectString(data.defaultLargeStagingDiskType);
-    }
-    if (data.ebsEncryption != null) {
-        contents.ebsEncryption = __expectString(data.ebsEncryption);
-    }
-    if (data.ebsEncryptionKeyArn != null) {
-        contents.ebsEncryptionKeyArn = __expectString(data.ebsEncryptionKeyArn);
+    if (data.actionID != null) {
+        contents.actionID = __expectString(data.actionID);
     }
-    if (data.name != null) {
-        contents.name = __expectString(data.name);
+    if (data.actionName != null) {
+        contents.actionName = __expectString(data.actionName);
     }
-    if (data.replicatedDisks != null) {
-        contents.replicatedDisks = deserializeAws_restJson1ReplicationConfigurationReplicatedDisks(data.replicatedDisks, context);
+    if (data.active != null) {
+        contents.active = __expectBoolean(data.active);
     }
-    if (data.replicationServerInstanceType != null) {
-        contents.replicationServerInstanceType = __expectString(data.replicationServerInstanceType);
+    if (data.documentIdentifier != null) {
+        contents.documentIdentifier = __expectString(data.documentIdentifier);
     }
-    if (data.replicationServersSecurityGroupsIDs != null) {
-        contents.replicationServersSecurityGroupsIDs = deserializeAws_restJson1ReplicationServersSecurityGroupsIDs(data.replicationServersSecurityGroupsIDs, context);
+    if (data.documentVersion != null) {
+        contents.documentVersion = __expectString(data.documentVersion);
     }
-    if (data.sourceServerID != null) {
-        contents.sourceServerID = __expectString(data.sourceServerID);
+    if (data.mustSucceedForCutover != null) {
+        contents.mustSucceedForCutover = __expectBoolean(data.mustSucceedForCutover);
     }
-    if (data.stagingAreaSubnetId != null) {
-        contents.stagingAreaSubnetId = __expectString(data.stagingAreaSubnetId);
+    if (data.order != null) {
+        contents.order = __expectInt32(data.order);
     }
-    if (data.stagingAreaTags != null) {
-        contents.stagingAreaTags = deserializeAws_restJson1TagsMap(data.stagingAreaTags, context);
+    if (data.parameters != null) {
+        contents.parameters = deserializeAws_restJson1SsmDocumentParameters(data.parameters, context);
     }
-    if (data.useDedicatedReplicationServer != null) {
-        contents.useDedicatedReplicationServer = __expectBoolean(data.useDedicatedReplicationServer);
+    if (data.timeoutSeconds != null) {
+        contents.timeoutSeconds = __expectInt32(data.timeoutSeconds);
     }
     return contents;
 };
-const deserializeAws_restJson1GetReplicationConfigurationCommandError = async (output, context) => {
+const deserializeAws_restJson1PutSourceServerActionCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
     };
     const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
     switch (errorCode) {
+        case "ConflictException":
+        case "com.amazonaws.mgn#ConflictException":
+            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.mgn#ResourceNotFoundException":
             throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
         case "UninitializedAccountException":
         case "com.amazonaws.mgn#UninitializedAccountException":
             throw await deserializeAws_restJson1UninitializedAccountExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.mgn#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1686,27 +3137,63 @@ const deserializeAws_restJson1GetReplicationConfigurationCommandError = async (o
                 errorCode,
             });
     }
-};
-export const deserializeAws_restJson1InitializeServiceCommand = async (output, context) => {
-    if (output.statusCode !== 204 && output.statusCode >= 300) {
-        return deserializeAws_restJson1InitializeServiceCommandError(output, context);
+};
+export const deserializeAws_restJson1PutTemplateActionCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1PutTemplateActionCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
-    await collectBody(output.body, context);
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.actionID != null) {
+        contents.actionID = __expectString(data.actionID);
+    }
+    if (data.actionName != null) {
+        contents.actionName = __expectString(data.actionName);
+    }
+    if (data.active != null) {
+        contents.active = __expectBoolean(data.active);
+    }
+    if (data.documentIdentifier != null) {
+        contents.documentIdentifier = __expectString(data.documentIdentifier);
+    }
+    if (data.documentVersion != null) {
+        contents.documentVersion = __expectString(data.documentVersion);
+    }
+    if (data.mustSucceedForCutover != null) {
+        contents.mustSucceedForCutover = __expectBoolean(data.mustSucceedForCutover);
+    }
+    if (data.operatingSystem != null) {
+        contents.operatingSystem = __expectString(data.operatingSystem);
+    }
+    if (data.order != null) {
+        contents.order = __expectInt32(data.order);
+    }
+    if (data.parameters != null) {
+        contents.parameters = deserializeAws_restJson1SsmDocumentParameters(data.parameters, context);
+    }
+    if (data.timeoutSeconds != null) {
+        contents.timeoutSeconds = __expectInt32(data.timeoutSeconds);
+    }
     return contents;
 };
-const deserializeAws_restJson1InitializeServiceCommandError = async (output, context) => {
+const deserializeAws_restJson1PutTemplateActionCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
     };
     const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
     switch (errorCode) {
-        case "AccessDeniedException":
-        case "com.amazonaws.mgn#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.mgn#ConflictException":
+            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.mgn#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "UninitializedAccountException":
+        case "com.amazonaws.mgn#UninitializedAccountException":
+            throw await deserializeAws_restJson1UninitializedAccountExceptionResponse(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.mgn#ValidationException":
             throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
@@ -1720,38 +3207,29 @@ const deserializeAws_restJson1InitializeServiceCommandError = async (output, con
             });
     }
 };
-export const deserializeAws_restJson1ListTagsForResourceCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1ListTagsForResourceCommandError(output, context);
+export const deserializeAws_restJson1RemoveSourceServerActionCommand = async (output, context) => {
+    if (output.statusCode !== 204 && output.statusCode >= 300) {
+        return deserializeAws_restJson1RemoveSourceServerActionCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
-    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
-    if (data.tags != null) {
-        contents.tags = deserializeAws_restJson1TagsMap(data.tags, context);
-    }
+    await collectBody(output.body, context);
     return contents;
 };
-const deserializeAws_restJson1ListTagsForResourceCommandError = async (output, context) => {
+const deserializeAws_restJson1RemoveSourceServerActionCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
     };
     const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
     switch (errorCode) {
-        case "AccessDeniedException":
-        case "com.amazonaws.mgn#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
-        case "InternalServerException":
-        case "com.amazonaws.mgn#InternalServerException":
-            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.mgn#ResourceNotFoundException":
             throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.mgn#ThrottlingException":
-            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "UninitializedAccountException":
+        case "com.amazonaws.mgn#UninitializedAccountException":
+            throw await deserializeAws_restJson1UninitializedAccountExceptionResponse(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.mgn#ValidationException":
             throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
@@ -1765,62 +3243,32 @@ const deserializeAws_restJson1ListTagsForResourceCommandError = async (output, c
             });
     }
 };
-export const deserializeAws_restJson1MarkAsArchivedCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1MarkAsArchivedCommandError(output, context);
+export const deserializeAws_restJson1RemoveTemplateActionCommand = async (output, context) => {
+    if (output.statusCode !== 204 && output.statusCode >= 300) {
+        return deserializeAws_restJson1RemoveTemplateActionCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
-    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
-    if (data.arn != null) {
-        contents.arn = __expectString(data.arn);
-    }
-    if (data.dataReplicationInfo != null) {
-        contents.dataReplicationInfo = deserializeAws_restJson1DataReplicationInfo(data.dataReplicationInfo, context);
-    }
-    if (data.isArchived != null) {
-        contents.isArchived = __expectBoolean(data.isArchived);
-    }
-    if (data.launchedInstance != null) {
-        contents.launchedInstance = deserializeAws_restJson1LaunchedInstance(data.launchedInstance, context);
-    }
-    if (data.lifeCycle != null) {
-        contents.lifeCycle = deserializeAws_restJson1LifeCycle(data.lifeCycle, context);
-    }
-    if (data.replicationType != null) {
-        contents.replicationType = __expectString(data.replicationType);
-    }
-    if (data.sourceProperties != null) {
-        contents.sourceProperties = deserializeAws_restJson1SourceProperties(data.sourceProperties, context);
-    }
-    if (data.sourceServerID != null) {
-        contents.sourceServerID = __expectString(data.sourceServerID);
-    }
-    if (data.tags != null) {
-        contents.tags = deserializeAws_restJson1TagsMap(data.tags, context);
-    }
-    if (data.vcenterClientID != null) {
-        contents.vcenterClientID = __expectString(data.vcenterClientID);
-    }
+    await collectBody(output.body, context);
     return contents;
 };
-const deserializeAws_restJson1MarkAsArchivedCommandError = async (output, context) => {
+const deserializeAws_restJson1RemoveTemplateActionCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
     };
     const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
     switch (errorCode) {
-        case "ConflictException":
-        case "com.amazonaws.mgn#ConflictException":
-            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.mgn#ResourceNotFoundException":
             throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
         case "UninitializedAccountException":
         case "com.amazonaws.mgn#UninitializedAccountException":
             throw await deserializeAws_restJson1UninitializedAccountExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.mgn#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1839,6 +3287,9 @@ export const deserializeAws_restJson1RetryDataReplicationCommand = async (output
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.applicationID != null) {
+        contents.applicationID = __expectString(data.applicationID);
+    }
     if (data.arn != null) {
         contents.arn = __expectString(data.arn);
     }
@@ -1944,6 +3395,9 @@ export const deserializeAws_restJson1StartReplicationCommand = async (output, co
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.applicationID != null) {
+        contents.applicationID = __expectString(data.applicationID);
+    }
     if (data.arn != null) {
         contents.arn = __expectString(data.arn);
     }
@@ -2127,39 +3581,234 @@ const deserializeAws_restJson1TerminateTargetInstancesCommandError = async (outp
                 errorCode,
             });
     }
-};
-export const deserializeAws_restJson1UntagResourceCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1UntagResourceCommandError(output, context);
+};
+export const deserializeAws_restJson1UnarchiveApplicationCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1UnarchiveApplicationCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.applicationAggregatedStatus != null) {
+        contents.applicationAggregatedStatus = deserializeAws_restJson1ApplicationAggregatedStatus(data.applicationAggregatedStatus, context);
+    }
+    if (data.applicationID != null) {
+        contents.applicationID = __expectString(data.applicationID);
+    }
+    if (data.arn != null) {
+        contents.arn = __expectString(data.arn);
+    }
+    if (data.creationDateTime != null) {
+        contents.creationDateTime = __expectString(data.creationDateTime);
+    }
+    if (data.description != null) {
+        contents.description = __expectString(data.description);
+    }
+    if (data.isArchived != null) {
+        contents.isArchived = __expectBoolean(data.isArchived);
+    }
+    if (data.lastModifiedDateTime != null) {
+        contents.lastModifiedDateTime = __expectString(data.lastModifiedDateTime);
+    }
+    if (data.name != null) {
+        contents.name = __expectString(data.name);
+    }
+    if (data.tags != null) {
+        contents.tags = deserializeAws_restJson1TagsMap(data.tags, context);
+    }
+    if (data.waveID != null) {
+        contents.waveID = __expectString(data.waveID);
+    }
+    return contents;
+};
+const deserializeAws_restJson1UnarchiveApplicationCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "ResourceNotFoundException":
+        case "com.amazonaws.mgn#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ServiceQuotaExceededException":
+        case "com.amazonaws.mgn#ServiceQuotaExceededException":
+            throw await deserializeAws_restJson1ServiceQuotaExceededExceptionResponse(parsedOutput, context);
+        case "UninitializedAccountException":
+        case "com.amazonaws.mgn#UninitializedAccountException":
+            throw await deserializeAws_restJson1UninitializedAccountExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1UnarchiveWaveCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1UnarchiveWaveCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.arn != null) {
+        contents.arn = __expectString(data.arn);
+    }
+    if (data.creationDateTime != null) {
+        contents.creationDateTime = __expectString(data.creationDateTime);
+    }
+    if (data.description != null) {
+        contents.description = __expectString(data.description);
+    }
+    if (data.isArchived != null) {
+        contents.isArchived = __expectBoolean(data.isArchived);
+    }
+    if (data.lastModifiedDateTime != null) {
+        contents.lastModifiedDateTime = __expectString(data.lastModifiedDateTime);
+    }
+    if (data.name != null) {
+        contents.name = __expectString(data.name);
+    }
+    if (data.tags != null) {
+        contents.tags = deserializeAws_restJson1TagsMap(data.tags, context);
+    }
+    if (data.waveAggregatedStatus != null) {
+        contents.waveAggregatedStatus = deserializeAws_restJson1WaveAggregatedStatus(data.waveAggregatedStatus, context);
+    }
+    if (data.waveID != null) {
+        contents.waveID = __expectString(data.waveID);
+    }
+    return contents;
+};
+const deserializeAws_restJson1UnarchiveWaveCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "ResourceNotFoundException":
+        case "com.amazonaws.mgn#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ServiceQuotaExceededException":
+        case "com.amazonaws.mgn#ServiceQuotaExceededException":
+            throw await deserializeAws_restJson1ServiceQuotaExceededExceptionResponse(parsedOutput, context);
+        case "UninitializedAccountException":
+        case "com.amazonaws.mgn#UninitializedAccountException":
+            throw await deserializeAws_restJson1UninitializedAccountExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1UntagResourceCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1UntagResourceCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
+const deserializeAws_restJson1UntagResourceCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.mgn#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.mgn#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.mgn#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.mgn#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.mgn#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1UpdateApplicationCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1UpdateApplicationCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.applicationAggregatedStatus != null) {
+        contents.applicationAggregatedStatus = deserializeAws_restJson1ApplicationAggregatedStatus(data.applicationAggregatedStatus, context);
+    }
+    if (data.applicationID != null) {
+        contents.applicationID = __expectString(data.applicationID);
+    }
+    if (data.arn != null) {
+        contents.arn = __expectString(data.arn);
+    }
+    if (data.creationDateTime != null) {
+        contents.creationDateTime = __expectString(data.creationDateTime);
+    }
+    if (data.description != null) {
+        contents.description = __expectString(data.description);
+    }
+    if (data.isArchived != null) {
+        contents.isArchived = __expectBoolean(data.isArchived);
+    }
+    if (data.lastModifiedDateTime != null) {
+        contents.lastModifiedDateTime = __expectString(data.lastModifiedDateTime);
+    }
+    if (data.name != null) {
+        contents.name = __expectString(data.name);
+    }
+    if (data.tags != null) {
+        contents.tags = deserializeAws_restJson1TagsMap(data.tags, context);
+    }
+    if (data.waveID != null) {
+        contents.waveID = __expectString(data.waveID);
     }
-    const contents = map({
-        $metadata: deserializeMetadata(output),
-    });
-    await collectBody(output.body, context);
     return contents;
 };
-const deserializeAws_restJson1UntagResourceCommandError = async (output, context) => {
+const deserializeAws_restJson1UpdateApplicationCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
     };
     const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
     switch (errorCode) {
-        case "AccessDeniedException":
-        case "com.amazonaws.mgn#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
-        case "InternalServerException":
-        case "com.amazonaws.mgn#InternalServerException":
-            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.mgn#ConflictException":
+            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.mgn#ResourceNotFoundException":
             throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.mgn#ThrottlingException":
-            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.mgn#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        case "UninitializedAccountException":
+        case "com.amazonaws.mgn#UninitializedAccountException":
+            throw await deserializeAws_restJson1UninitializedAccountExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2190,12 +3839,18 @@ export const deserializeAws_restJson1UpdateLaunchConfigurationCommand = async (o
     if (data.ec2LaunchTemplateID != null) {
         contents.ec2LaunchTemplateID = __expectString(data.ec2LaunchTemplateID);
     }
+    if (data.enableMapAutoTagging != null) {
+        contents.enableMapAutoTagging = __expectBoolean(data.enableMapAutoTagging);
+    }
     if (data.launchDisposition != null) {
         contents.launchDisposition = __expectString(data.launchDisposition);
     }
     if (data.licensing != null) {
         contents.licensing = deserializeAws_restJson1Licensing(data.licensing, context);
     }
+    if (data.mapAutoTaggingMpeID != null) {
+        contents.mapAutoTaggingMpeID = __expectString(data.mapAutoTaggingMpeID);
+    }
     if (data.name != null) {
         contents.name = __expectString(data.name);
     }
@@ -2250,15 +3905,54 @@ export const deserializeAws_restJson1UpdateLaunchConfigurationTemplateCommand =
     if (data.arn != null) {
         contents.arn = __expectString(data.arn);
     }
+    if (data.associatePublicIpAddress != null) {
+        contents.associatePublicIpAddress = __expectBoolean(data.associatePublicIpAddress);
+    }
+    if (data.bootMode != null) {
+        contents.bootMode = __expectString(data.bootMode);
+    }
+    if (data.copyPrivateIp != null) {
+        contents.copyPrivateIp = __expectBoolean(data.copyPrivateIp);
+    }
+    if (data.copyTags != null) {
+        contents.copyTags = __expectBoolean(data.copyTags);
+    }
+    if (data.ec2LaunchTemplateID != null) {
+        contents.ec2LaunchTemplateID = __expectString(data.ec2LaunchTemplateID);
+    }
+    if (data.enableMapAutoTagging != null) {
+        contents.enableMapAutoTagging = __expectBoolean(data.enableMapAutoTagging);
+    }
+    if (data.largeVolumeConf != null) {
+        contents.largeVolumeConf = deserializeAws_restJson1LaunchTemplateDiskConf(data.largeVolumeConf, context);
+    }
     if (data.launchConfigurationTemplateID != null) {
         contents.launchConfigurationTemplateID = __expectString(data.launchConfigurationTemplateID);
     }
+    if (data.launchDisposition != null) {
+        contents.launchDisposition = __expectString(data.launchDisposition);
+    }
+    if (data.licensing != null) {
+        contents.licensing = deserializeAws_restJson1Licensing(data.licensing, context);
+    }
+    if (data.mapAutoTaggingMpeID != null) {
+        contents.mapAutoTaggingMpeID = __expectString(data.mapAutoTaggingMpeID);
+    }
     if (data.postLaunchActions != null) {
         contents.postLaunchActions = deserializeAws_restJson1PostLaunchActions(data.postLaunchActions, context);
     }
+    if (data.smallVolumeConf != null) {
+        contents.smallVolumeConf = deserializeAws_restJson1LaunchTemplateDiskConf(data.smallVolumeConf, context);
+    }
+    if (data.smallVolumeMaxSize != null) {
+        contents.smallVolumeMaxSize = __expectLong(data.smallVolumeMaxSize);
+    }
     if (data.tags != null) {
         contents.tags = deserializeAws_restJson1TagsMap(data.tags, context);
     }
+    if (data.targetInstanceTypeRightSizingMethod != null) {
+        contents.targetInstanceTypeRightSizingMethod = __expectString(data.targetInstanceTypeRightSizingMethod);
+    }
     return contents;
 };
 const deserializeAws_restJson1UpdateLaunchConfigurationTemplateCommandError = async (output, context) => {
@@ -2469,6 +4163,9 @@ export const deserializeAws_restJson1UpdateSourceServerReplicationTypeCommand =
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.applicationID != null) {
+        contents.applicationID = __expectString(data.applicationID);
+    }
     if (data.arn != null) {
         contents.arn = __expectString(data.arn);
     }
@@ -2530,6 +4227,69 @@ const deserializeAws_restJson1UpdateSourceServerReplicationTypeCommandError = as
             });
     }
 };
+export const deserializeAws_restJson1UpdateWaveCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1UpdateWaveCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.arn != null) {
+        contents.arn = __expectString(data.arn);
+    }
+    if (data.creationDateTime != null) {
+        contents.creationDateTime = __expectString(data.creationDateTime);
+    }
+    if (data.description != null) {
+        contents.description = __expectString(data.description);
+    }
+    if (data.isArchived != null) {
+        contents.isArchived = __expectBoolean(data.isArchived);
+    }
+    if (data.lastModifiedDateTime != null) {
+        contents.lastModifiedDateTime = __expectString(data.lastModifiedDateTime);
+    }
+    if (data.name != null) {
+        contents.name = __expectString(data.name);
+    }
+    if (data.tags != null) {
+        contents.tags = deserializeAws_restJson1TagsMap(data.tags, context);
+    }
+    if (data.waveAggregatedStatus != null) {
+        contents.waveAggregatedStatus = deserializeAws_restJson1WaveAggregatedStatus(data.waveAggregatedStatus, context);
+    }
+    if (data.waveID != null) {
+        contents.waveID = __expectString(data.waveID);
+    }
+    return contents;
+};
+const deserializeAws_restJson1UpdateWaveCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "ConflictException":
+        case "com.amazonaws.mgn#ConflictException":
+            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.mgn#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "UninitializedAccountException":
+        case "com.amazonaws.mgn#UninitializedAccountException":
+            throw await deserializeAws_restJson1UninitializedAccountExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
 const map = __map;
 const deserializeAws_restJson1AccessDeniedExceptionResponse = async (parsedOutput, context) => {
     const contents = map({});
@@ -2694,6 +4454,34 @@ const deserializeAws_restJson1ValidationExceptionResponse = async (parsedOutput,
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
+const serializeAws_restJson1ActionIDs = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return entry;
+    });
+};
+const serializeAws_restJson1ApplicationIDs = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return entry;
+    });
+};
+const serializeAws_restJson1ApplicationIDsFilter = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return entry;
+    });
+};
+const serializeAws_restJson1AssociateSourceServersRequestSourceServerIDs = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return entry;
+    });
+};
 const serializeAws_restJson1ChangeServerLifeCycleStateSourceServerLifecycle = (input, context) => {
     return {
         ...(input.state != null && { state: input.state }),
@@ -2715,8 +4503,18 @@ const serializeAws_restJson1DescribeJobsRequestFiltersJobIDs = (input, context)
         return entry;
     });
 };
+const serializeAws_restJson1DescribeSourceServersRequestApplicationIDs = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return entry;
+    });
+};
 const serializeAws_restJson1DescribeSourceServersRequestFilters = (input, context) => {
     return {
+        ...(input.applicationIDs != null && {
+            applicationIDs: serializeAws_restJson1DescribeSourceServersRequestApplicationIDs(input.applicationIDs, context),
+        }),
         ...(input.isArchived != null && { isArchived: input.isArchived }),
         ...(input.lifeCycleStates != null && {
             lifeCycleStates: serializeAws_restJson1LifeCycleStates(input.lifeCycleStates, context),
@@ -2736,6 +4534,13 @@ const serializeAws_restJson1DescribeSourceServersRequestFiltersIDs = (input, con
         return entry;
     });
 };
+const serializeAws_restJson1DisassociateSourceServersRequestSourceServerIDs = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return entry;
+    });
+};
 const serializeAws_restJson1LaunchConfigurationTemplateIDs = (input, context) => {
     return input
         .filter((e) => e != null)
@@ -2743,6 +4548,13 @@ const serializeAws_restJson1LaunchConfigurationTemplateIDs = (input, context) =>
         return entry;
     });
 };
+const serializeAws_restJson1LaunchTemplateDiskConf = (input, context) => {
+    return {
+        ...(input.iops != null && { iops: input.iops }),
+        ...(input.throughput != null && { throughput: input.throughput }),
+        ...(input.volumeType != null && { volumeType: input.volumeType }),
+    };
+};
 const serializeAws_restJson1Licensing = (input, context) => {
     return {
         ...(input.osByol != null && { osByol: input.osByol }),
@@ -2755,6 +4567,21 @@ const serializeAws_restJson1LifeCycleStates = (input, context) => {
         return entry;
     });
 };
+const serializeAws_restJson1ListApplicationsRequestFilters = (input, context) => {
+    return {
+        ...(input.applicationIDs != null && {
+            applicationIDs: serializeAws_restJson1ApplicationIDsFilter(input.applicationIDs, context),
+        }),
+        ...(input.isArchived != null && { isArchived: input.isArchived }),
+        ...(input.waveIDs != null && { waveIDs: serializeAws_restJson1WaveIDsFilter(input.waveIDs, context) }),
+    };
+};
+const serializeAws_restJson1ListWavesRequestFilters = (input, context) => {
+    return {
+        ...(input.isArchived != null && { isArchived: input.isArchived }),
+        ...(input.waveIDs != null && { waveIDs: serializeAws_restJson1WaveIDsFilter(input.waveIDs, context) }),
+    };
+};
 const serializeAws_restJson1PostLaunchActions = (input, context) => {
     return {
         ...(input.cloudWatchLogGroupName != null && { cloudWatchLogGroupName: input.cloudWatchLogGroupName }),
@@ -2803,6 +4630,11 @@ const serializeAws_restJson1ReplicationTypes = (input, context) => {
         return entry;
     });
 };
+const serializeAws_restJson1SourceServerActionsRequestFilters = (input, context) => {
+    return {
+        ...(input.actionIDs != null && { actionIDs: serializeAws_restJson1ActionIDs(input.actionIDs, context) }),
+    };
+};
 const serializeAws_restJson1SsmDocument = (input, context) => {
     return {
         ...(input.actionName != null && { actionName: input.actionName }),
@@ -2866,6 +4698,11 @@ const serializeAws_restJson1TagsMap = (input, context) => {
         return acc;
     }, {});
 };
+const serializeAws_restJson1TemplateActionsRequestFilters = (input, context) => {
+    return {
+        ...(input.actionIDs != null && { actionIDs: serializeAws_restJson1ActionIDs(input.actionIDs, context) }),
+    };
+};
 const serializeAws_restJson1TerminateTargetInstancesRequestSourceServerIDs = (input, context) => {
     return input
         .filter((e) => e != null)
@@ -2873,6 +4710,48 @@ const serializeAws_restJson1TerminateTargetInstancesRequestSourceServerIDs = (in
         return entry;
     });
 };
+const serializeAws_restJson1WaveIDsFilter = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return entry;
+    });
+};
+const deserializeAws_restJson1Application = (output, context) => {
+    return {
+        applicationAggregatedStatus: output.applicationAggregatedStatus != null
+            ? deserializeAws_restJson1ApplicationAggregatedStatus(output.applicationAggregatedStatus, context)
+            : undefined,
+        applicationID: __expectString(output.applicationID),
+        arn: __expectString(output.arn),
+        creationDateTime: __expectString(output.creationDateTime),
+        description: __expectString(output.description),
+        isArchived: __expectBoolean(output.isArchived),
+        lastModifiedDateTime: __expectString(output.lastModifiedDateTime),
+        name: __expectString(output.name),
+        tags: output.tags != null ? deserializeAws_restJson1TagsMap(output.tags, context) : undefined,
+        waveID: __expectString(output.waveID),
+    };
+};
+const deserializeAws_restJson1ApplicationAggregatedStatus = (output, context) => {
+    return {
+        healthStatus: __expectString(output.healthStatus),
+        lastUpdateDateTime: __expectString(output.lastUpdateDateTime),
+        progressStatus: __expectString(output.progressStatus),
+        totalSourceServers: __expectLong(output.totalSourceServers),
+    };
+};
+const deserializeAws_restJson1ApplicationsList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_restJson1Application(entry, context);
+    });
+    return retVal;
+};
 const deserializeAws_restJson1ConflictExceptionErrors = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
@@ -3077,11 +4956,28 @@ const deserializeAws_restJson1JobsList = (output, context) => {
 const deserializeAws_restJson1LaunchConfigurationTemplate = (output, context) => {
     return {
         arn: __expectString(output.arn),
+        associatePublicIpAddress: __expectBoolean(output.associatePublicIpAddress),
+        bootMode: __expectString(output.bootMode),
+        copyPrivateIp: __expectBoolean(output.copyPrivateIp),
+        copyTags: __expectBoolean(output.copyTags),
+        ec2LaunchTemplateID: __expectString(output.ec2LaunchTemplateID),
+        enableMapAutoTagging: __expectBoolean(output.enableMapAutoTagging),
+        largeVolumeConf: output.largeVolumeConf != null
+            ? deserializeAws_restJson1LaunchTemplateDiskConf(output.largeVolumeConf, context)
+            : undefined,
         launchConfigurationTemplateID: __expectString(output.launchConfigurationTemplateID),
+        launchDisposition: __expectString(output.launchDisposition),
+        licensing: output.licensing != null ? deserializeAws_restJson1Licensing(output.licensing, context) : undefined,
+        mapAutoTaggingMpeID: __expectString(output.mapAutoTaggingMpeID),
         postLaunchActions: output.postLaunchActions != null
             ? deserializeAws_restJson1PostLaunchActions(output.postLaunchActions, context)
             : undefined,
+        smallVolumeConf: output.smallVolumeConf != null
+            ? deserializeAws_restJson1LaunchTemplateDiskConf(output.smallVolumeConf, context)
+            : undefined,
+        smallVolumeMaxSize: __expectLong(output.smallVolumeMaxSize),
         tags: output.tags != null ? deserializeAws_restJson1TagsMap(output.tags, context) : undefined,
+        targetInstanceTypeRightSizingMethod: __expectString(output.targetInstanceTypeRightSizingMethod),
     };
 };
 const deserializeAws_restJson1LaunchConfigurationTemplates = (output, context) => {
@@ -3102,6 +4998,13 @@ const deserializeAws_restJson1LaunchedInstance = (output, context) => {
         jobID: __expectString(output.jobID),
     };
 };
+const deserializeAws_restJson1LaunchTemplateDiskConf = (output, context) => {
+    return {
+        iops: __expectLong(output.iops),
+        throughput: __expectLong(output.throughput),
+        volumeType: __expectString(output.volumeType),
+    };
+};
 const deserializeAws_restJson1Licensing = (output, context) => {
     return {
         osByol: __expectBoolean(output.osByol),
@@ -3329,6 +5232,7 @@ const deserializeAws_restJson1SourceProperties = (output, context) => {
 };
 const deserializeAws_restJson1SourceServer = (output, context) => {
     return {
+        applicationID: __expectString(output.applicationID),
         arn: __expectString(output.arn),
         dataReplicationInfo: output.dataReplicationInfo != null
             ? deserializeAws_restJson1DataReplicationInfo(output.dataReplicationInfo, context)
@@ -3347,6 +5251,30 @@ const deserializeAws_restJson1SourceServer = (output, context) => {
         vcenterClientID: __expectString(output.vcenterClientID),
     };
 };
+const deserializeAws_restJson1SourceServerActionDocument = (output, context) => {
+    return {
+        actionID: __expectString(output.actionID),
+        actionName: __expectString(output.actionName),
+        active: __expectBoolean(output.active),
+        documentIdentifier: __expectString(output.documentIdentifier),
+        documentVersion: __expectString(output.documentVersion),
+        mustSucceedForCutover: __expectBoolean(output.mustSucceedForCutover),
+        order: __expectInt32(output.order),
+        parameters: output.parameters != null ? deserializeAws_restJson1SsmDocumentParameters(output.parameters, context) : undefined,
+        timeoutSeconds: __expectInt32(output.timeoutSeconds),
+    };
+};
+const deserializeAws_restJson1SourceServerActionDocuments = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_restJson1SourceServerActionDocument(entry, context);
+    });
+    return retVal;
+};
 const deserializeAws_restJson1SourceServersList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
@@ -3413,6 +5341,31 @@ const deserializeAws_restJson1TagsMap = (output, context) => {
         return acc;
     }, {});
 };
+const deserializeAws_restJson1TemplateActionDocument = (output, context) => {
+    return {
+        actionID: __expectString(output.actionID),
+        actionName: __expectString(output.actionName),
+        active: __expectBoolean(output.active),
+        documentIdentifier: __expectString(output.documentIdentifier),
+        documentVersion: __expectString(output.documentVersion),
+        mustSucceedForCutover: __expectBoolean(output.mustSucceedForCutover),
+        operatingSystem: __expectString(output.operatingSystem),
+        order: __expectInt32(output.order),
+        parameters: output.parameters != null ? deserializeAws_restJson1SsmDocumentParameters(output.parameters, context) : undefined,
+        timeoutSeconds: __expectInt32(output.timeoutSeconds),
+    };
+};
+const deserializeAws_restJson1TemplateActionDocuments = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_restJson1TemplateActionDocument(entry, context);
+    });
+    return retVal;
+};
 const deserializeAws_restJson1ValidationExceptionField = (output, context) => {
     return {
         message: __expectString(output.message),
@@ -3453,6 +5406,41 @@ const deserializeAws_restJson1VcenterClientList = (output, context) => {
     });
     return retVal;
 };
+const deserializeAws_restJson1Wave = (output, context) => {
+    return {
+        arn: __expectString(output.arn),
+        creationDateTime: __expectString(output.creationDateTime),
+        description: __expectString(output.description),
+        isArchived: __expectBoolean(output.isArchived),
+        lastModifiedDateTime: __expectString(output.lastModifiedDateTime),
+        name: __expectString(output.name),
+        tags: output.tags != null ? deserializeAws_restJson1TagsMap(output.tags, context) : undefined,
+        waveAggregatedStatus: output.waveAggregatedStatus != null
+            ? deserializeAws_restJson1WaveAggregatedStatus(output.waveAggregatedStatus, context)
+            : undefined,
+        waveID: __expectString(output.waveID),
+    };
+};
+const deserializeAws_restJson1WaveAggregatedStatus = (output, context) => {
+    return {
+        healthStatus: __expectString(output.healthStatus),
+        lastUpdateDateTime: __expectString(output.lastUpdateDateTime),
+        progressStatus: __expectString(output.progressStatus),
+        replicationStartedDateTime: __expectString(output.replicationStartedDateTime),
+        totalApplications: __expectLong(output.totalApplications),
+    };
+};
+const deserializeAws_restJson1WavesList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_restJson1Wave(entry, context);
+    });
+    return retVal;
+};
 const deserializeMetadata = (output) => ({
     httpStatusCode: output.statusCode,
     requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],