@aws-sdk/client-eks 3.303.0 → 3.309.0

package/dist-es/protocols/Aws_restJson1.js

@@ -3,7 +3,7 @@ import { decorateServiceException as __decorateServiceException, expectBoolean a
 import { v4 as generateIdempotencyToken } from "uuid";
 import { EKSServiceException as __BaseException } from "../models/EKSServiceException";
 import { AccessDeniedException, BadRequestException, ClientException, InvalidParameterException, InvalidRequestException, NotFoundException, ResourceInUseException, ResourceLimitExceededException, ResourceNotFoundException, ResourcePropagationDelayException, ServerException, ServiceUnavailableException, UnsupportedAvailabilityZoneException, } from "../models/models_0";
-export const serializeAws_restJson1AssociateEncryptionConfigCommand = async (input, context) => {
+export const se_AssociateEncryptionConfigCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -15,7 +15,7 @@ export const serializeAws_restJson1AssociateEncryptionConfigCommand = async (inp
     body = JSON.stringify({
         clientRequestToken: input.clientRequestToken ?? generateIdempotencyToken(),
         ...(input.encryptionConfig != null && {
-            encryptionConfig: serializeAws_restJson1EncryptionConfigList(input.encryptionConfig, context),
+            encryptionConfig: se_EncryptionConfigList(input.encryptionConfig, context),
         }),
     });
     return new __HttpRequest({
@@ -28,7 +28,7 @@ export const serializeAws_restJson1AssociateEncryptionConfigCommand = async (inp
         body,
     });
 };
-export const serializeAws_restJson1AssociateIdentityProviderConfigCommand = async (input, context) => {
+export const se_AssociateIdentityProviderConfigCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -39,8 +39,8 @@ export const serializeAws_restJson1AssociateIdentityProviderConfigCommand = asyn
     let body;
     body = JSON.stringify({
         clientRequestToken: input.clientRequestToken ?? generateIdempotencyToken(),
-        ...(input.oidc != null && { oidc: serializeAws_restJson1OidcIdentityProviderConfigRequest(input.oidc, context) }),
-        ...(input.tags != null && { tags: serializeAws_restJson1TagMap(input.tags, context) }),
+        ...(input.oidc != null && { oidc: se_OidcIdentityProviderConfigRequest(input.oidc, context) }),
+        ...(input.tags != null && { tags: se_TagMap(input.tags, context) }),
     });
     return new __HttpRequest({
         protocol,
@@ -52,7 +52,7 @@ export const serializeAws_restJson1AssociateIdentityProviderConfigCommand = asyn
         body,
     });
 };
-export const serializeAws_restJson1CreateAddonCommand = async (input, context) => {
+export const se_CreateAddonCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -67,7 +67,7 @@ export const serializeAws_restJson1CreateAddonCommand = async (input, context) =
         ...(input.configurationValues != null && { configurationValues: input.configurationValues }),
         ...(input.resolveConflicts != null && { resolveConflicts: input.resolveConflicts }),
         ...(input.serviceAccountRoleArn != null && { serviceAccountRoleArn: input.serviceAccountRoleArn }),
-        ...(input.tags != null && { tags: serializeAws_restJson1TagMap(input.tags, context) }),
+        ...(input.tags != null && { tags: se_TagMap(input.tags, context) }),
     });
     return new __HttpRequest({
         protocol,
@@ -79,7 +79,7 @@ export const serializeAws_restJson1CreateAddonCommand = async (input, context) =
         body,
     });
 };
-export const serializeAws_restJson1CreateClusterCommand = async (input, context) => {
+export const se_CreateClusterCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -89,21 +89,19 @@ export const serializeAws_restJson1CreateClusterCommand = async (input, context)
     body = JSON.stringify({
         clientRequestToken: input.clientRequestToken ?? generateIdempotencyToken(),
         ...(input.encryptionConfig != null && {
-            encryptionConfig: serializeAws_restJson1EncryptionConfigList(input.encryptionConfig, context),
+            encryptionConfig: se_EncryptionConfigList(input.encryptionConfig, context),
         }),
         ...(input.kubernetesNetworkConfig != null && {
-            kubernetesNetworkConfig: serializeAws_restJson1KubernetesNetworkConfigRequest(input.kubernetesNetworkConfig, context),
+            kubernetesNetworkConfig: se_KubernetesNetworkConfigRequest(input.kubernetesNetworkConfig, context),
         }),
-        ...(input.logging != null && { logging: serializeAws_restJson1Logging(input.logging, context) }),
+        ...(input.logging != null && { logging: se_Logging(input.logging, context) }),
         ...(input.name != null && { name: input.name }),
-        ...(input.outpostConfig != null && {
-            outpostConfig: serializeAws_restJson1OutpostConfigRequest(input.outpostConfig, context),
-        }),
+        ...(input.outpostConfig != null && { outpostConfig: se_OutpostConfigRequest(input.outpostConfig, context) }),
         ...(input.resourcesVpcConfig != null && {
-            resourcesVpcConfig: serializeAws_restJson1VpcConfigRequest(input.resourcesVpcConfig, context),
+            resourcesVpcConfig: se_VpcConfigRequest(input.resourcesVpcConfig, context),
         }),
         ...(input.roleArn != null && { roleArn: input.roleArn }),
-        ...(input.tags != null && { tags: serializeAws_restJson1TagMap(input.tags, context) }),
+        ...(input.tags != null && { tags: se_TagMap(input.tags, context) }),
         ...(input.version != null && { version: input.version }),
     });
     return new __HttpRequest({
@@ -116,7 +114,7 @@ export const serializeAws_restJson1CreateClusterCommand = async (input, context)
         body,
     });
 };
-export const serializeAws_restJson1CreateFargateProfileCommand = async (input, context) => {
+export const se_CreateFargateProfileCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -128,11 +126,9 @@ export const serializeAws_restJson1CreateFargateProfileCommand = async (input, c
         clientRequestToken: input.clientRequestToken ?? generateIdempotencyToken(),
         ...(input.fargateProfileName != null && { fargateProfileName: input.fargateProfileName }),
         ...(input.podExecutionRoleArn != null && { podExecutionRoleArn: input.podExecutionRoleArn }),
-        ...(input.selectors != null && {
-            selectors: serializeAws_restJson1FargateProfileSelectors(input.selectors, context),
-        }),
-        ...(input.subnets != null && { subnets: serializeAws_restJson1StringList(input.subnets, context) }),
-        ...(input.tags != null && { tags: serializeAws_restJson1TagMap(input.tags, context) }),
+        ...(input.selectors != null && { selectors: se_FargateProfileSelectors(input.selectors, context) }),
+        ...(input.subnets != null && { subnets: se_StringList(input.subnets, context) }),
+        ...(input.tags != null && { tags: se_TagMap(input.tags, context) }),
     });
     return new __HttpRequest({
         protocol,
@@ -144,7 +140,7 @@ export const serializeAws_restJson1CreateFargateProfileCommand = async (input, c
         body,
     });
 };
-export const serializeAws_restJson1CreateNodegroupCommand = async (input, context) => {
+export const se_CreateNodegroupCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -157,28 +153,20 @@ export const serializeAws_restJson1CreateNodegroupCommand = async (input, contex
         ...(input.capacityType != null && { capacityType: input.capacityType }),
         clientRequestToken: input.clientRequestToken ?? generateIdempotencyToken(),
         ...(input.diskSize != null && { diskSize: input.diskSize }),
-        ...(input.instanceTypes != null && {
-            instanceTypes: serializeAws_restJson1StringList(input.instanceTypes, context),
-        }),
-        ...(input.labels != null && { labels: serializeAws_restJson1labelsMap(input.labels, context) }),
+        ...(input.instanceTypes != null && { instanceTypes: se_StringList(input.instanceTypes, context) }),
+        ...(input.labels != null && { labels: se_labelsMap(input.labels, context) }),
         ...(input.launchTemplate != null && {
-            launchTemplate: serializeAws_restJson1LaunchTemplateSpecification(input.launchTemplate, context),
+            launchTemplate: se_LaunchTemplateSpecification(input.launchTemplate, context),
         }),
         ...(input.nodeRole != null && { nodeRole: input.nodeRole }),
         ...(input.nodegroupName != null && { nodegroupName: input.nodegroupName }),
         ...(input.releaseVersion != null && { releaseVersion: input.releaseVersion }),
-        ...(input.remoteAccess != null && {
-            remoteAccess: serializeAws_restJson1RemoteAccessConfig(input.remoteAccess, context),
-        }),
-        ...(input.scalingConfig != null && {
-            scalingConfig: serializeAws_restJson1NodegroupScalingConfig(input.scalingConfig, context),
-        }),
-        ...(input.subnets != null && { subnets: serializeAws_restJson1StringList(input.subnets, context) }),
-        ...(input.tags != null && { tags: serializeAws_restJson1TagMap(input.tags, context) }),
-        ...(input.taints != null && { taints: serializeAws_restJson1taintsList(input.taints, context) }),
-        ...(input.updateConfig != null && {
-            updateConfig: serializeAws_restJson1NodegroupUpdateConfig(input.updateConfig, context),
-        }),
+        ...(input.remoteAccess != null && { remoteAccess: se_RemoteAccessConfig(input.remoteAccess, context) }),
+        ...(input.scalingConfig != null && { scalingConfig: se_NodegroupScalingConfig(input.scalingConfig, context) }),
+        ...(input.subnets != null && { subnets: se_StringList(input.subnets, context) }),
+        ...(input.tags != null && { tags: se_TagMap(input.tags, context) }),
+        ...(input.taints != null && { taints: se_taintsList(input.taints, context) }),
+        ...(input.updateConfig != null && { updateConfig: se_NodegroupUpdateConfig(input.updateConfig, context) }),
         ...(input.version != null && { version: input.version }),
     });
     return new __HttpRequest({
@@ -191,7 +179,7 @@ export const serializeAws_restJson1CreateNodegroupCommand = async (input, contex
         body,
     });
 };
-export const serializeAws_restJson1DeleteAddonCommand = async (input, context) => {
+export const se_DeleteAddonCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
@@ -213,7 +201,7 @@ export const serializeAws_restJson1DeleteAddonCommand = async (input, context) =
         body,
     });
 };
-export const serializeAws_restJson1DeleteClusterCommand = async (input, context) => {
+export const se_DeleteClusterCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/clusters/{name}";
@@ -229,7 +217,7 @@ export const serializeAws_restJson1DeleteClusterCommand = async (input, context)
         body,
     });
 };
-export const serializeAws_restJson1DeleteFargateProfileCommand = async (input, context) => {
+export const se_DeleteFargateProfileCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
@@ -247,7 +235,7 @@ export const serializeAws_restJson1DeleteFargateProfileCommand = async (input, c
         body,
     });
 };
-export const serializeAws_restJson1DeleteNodegroupCommand = async (input, context) => {
+export const se_DeleteNodegroupCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
@@ -265,7 +253,7 @@ export const serializeAws_restJson1DeleteNodegroupCommand = async (input, contex
         body,
     });
 };
-export const serializeAws_restJson1DeregisterClusterCommand = async (input, context) => {
+export const se_DeregisterClusterCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/cluster-registrations/{name}";
@@ -281,7 +269,7 @@ export const serializeAws_restJson1DeregisterClusterCommand = async (input, cont
         body,
     });
 };
-export const serializeAws_restJson1DescribeAddonCommand = async (input, context) => {
+export const se_DescribeAddonCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
@@ -299,7 +287,7 @@ export const serializeAws_restJson1DescribeAddonCommand = async (input, context)
         body,
     });
 };
-export const serializeAws_restJson1DescribeAddonConfigurationCommand = async (input, context) => {
+export const se_DescribeAddonConfigurationCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/addons/configuration-schemas";
@@ -319,7 +307,7 @@ export const serializeAws_restJson1DescribeAddonConfigurationCommand = async (in
         body,
     });
 };
-export const serializeAws_restJson1DescribeAddonVersionsCommand = async (input, context) => {
+export const se_DescribeAddonVersionsCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/addons/supported-versions";
@@ -344,7 +332,7 @@ export const serializeAws_restJson1DescribeAddonVersionsCommand = async (input,
         body,
     });
 };
-export const serializeAws_restJson1DescribeClusterCommand = async (input, context) => {
+export const se_DescribeClusterCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/clusters/{name}";
@@ -360,7 +348,7 @@ export const serializeAws_restJson1DescribeClusterCommand = async (input, contex
         body,
     });
 };
-export const serializeAws_restJson1DescribeFargateProfileCommand = async (input, context) => {
+export const se_DescribeFargateProfileCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
@@ -378,7 +366,7 @@ export const serializeAws_restJson1DescribeFargateProfileCommand = async (input,
         body,
     });
 };
-export const serializeAws_restJson1DescribeIdentityProviderConfigCommand = async (input, context) => {
+export const se_DescribeIdentityProviderConfigCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -389,7 +377,7 @@ export const serializeAws_restJson1DescribeIdentityProviderConfigCommand = async
     let body;
     body = JSON.stringify({
         ...(input.identityProviderConfig != null && {
-            identityProviderConfig: serializeAws_restJson1IdentityProviderConfig(input.identityProviderConfig, context),
+            identityProviderConfig: se_IdentityProviderConfig(input.identityProviderConfig, context),
         }),
     });
     return new __HttpRequest({
@@ -402,7 +390,7 @@ export const serializeAws_restJson1DescribeIdentityProviderConfigCommand = async
         body,
     });
 };
-export const serializeAws_restJson1DescribeNodegroupCommand = async (input, context) => {
+export const se_DescribeNodegroupCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
@@ -420,7 +408,7 @@ export const serializeAws_restJson1DescribeNodegroupCommand = async (input, cont
         body,
     });
 };
-export const serializeAws_restJson1DescribeUpdateCommand = async (input, context) => {
+export const se_DescribeUpdateCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/clusters/{name}/updates/{updateId}";
@@ -442,7 +430,7 @@ export const serializeAws_restJson1DescribeUpdateCommand = async (input, context
         body,
     });
 };
-export const serializeAws_restJson1DisassociateIdentityProviderConfigCommand = async (input, context) => {
+export const se_DisassociateIdentityProviderConfigCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -454,7 +442,7 @@ export const serializeAws_restJson1DisassociateIdentityProviderConfigCommand = a
     body = JSON.stringify({
         clientRequestToken: input.clientRequestToken ?? generateIdempotencyToken(),
         ...(input.identityProviderConfig != null && {
-            identityProviderConfig: serializeAws_restJson1IdentityProviderConfig(input.identityProviderConfig, context),
+            identityProviderConfig: se_IdentityProviderConfig(input.identityProviderConfig, context),
         }),
     });
     return new __HttpRequest({
@@ -467,7 +455,7 @@ export const serializeAws_restJson1DisassociateIdentityProviderConfigCommand = a
         body,
     });
 };
-export const serializeAws_restJson1ListAddonsCommand = async (input, context) => {
+export const se_ListAddonsCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/clusters/{clusterName}/addons";
@@ -488,7 +476,7 @@ export const serializeAws_restJson1ListAddonsCommand = async (input, context) =>
         body,
     });
 };
-export const serializeAws_restJson1ListClustersCommand = async (input, context) => {
+export const se_ListClustersCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/clusters";
@@ -509,7 +497,7 @@ export const serializeAws_restJson1ListClustersCommand = async (input, context)
         body,
     });
 };
-export const serializeAws_restJson1ListFargateProfilesCommand = async (input, context) => {
+export const se_ListFargateProfilesCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/clusters/{clusterName}/fargate-profiles";
@@ -530,7 +518,7 @@ export const serializeAws_restJson1ListFargateProfilesCommand = async (input, co
         body,
     });
 };
-export const serializeAws_restJson1ListIdentityProviderConfigsCommand = async (input, context) => {
+export const se_ListIdentityProviderConfigsCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
@@ -552,7 +540,7 @@ export const serializeAws_restJson1ListIdentityProviderConfigsCommand = async (i
         body,
     });
 };
-export const serializeAws_restJson1ListNodegroupsCommand = async (input, context) => {
+export const se_ListNodegroupsCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/clusters/{clusterName}/node-groups";
@@ -573,7 +561,7 @@ export const serializeAws_restJson1ListNodegroupsCommand = async (input, context
         body,
     });
 };
-export const serializeAws_restJson1ListTagsForResourceCommand = async (input, context) => {
+export const se_ListTagsForResourceCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{resourceArn}";
@@ -589,7 +577,7 @@ export const serializeAws_restJson1ListTagsForResourceCommand = async (input, co
         body,
     });
 };
-export const serializeAws_restJson1ListUpdatesCommand = async (input, context) => {
+export const se_ListUpdatesCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/clusters/{name}/updates";
@@ -612,7 +600,7 @@ export const serializeAws_restJson1ListUpdatesCommand = async (input, context) =
         body,
     });
 };
-export const serializeAws_restJson1RegisterClusterCommand = async (input, context) => {
+export const se_RegisterClusterCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -622,10 +610,10 @@ export const serializeAws_restJson1RegisterClusterCommand = async (input, contex
     body = JSON.stringify({
         clientRequestToken: input.clientRequestToken ?? generateIdempotencyToken(),
         ...(input.connectorConfig != null && {
-            connectorConfig: serializeAws_restJson1ConnectorConfigRequest(input.connectorConfig, context),
+            connectorConfig: se_ConnectorConfigRequest(input.connectorConfig, context),
         }),
         ...(input.name != null && { name: input.name }),
-        ...(input.tags != null && { tags: serializeAws_restJson1TagMap(input.tags, context) }),
+        ...(input.tags != null && { tags: se_TagMap(input.tags, context) }),
     });
     return new __HttpRequest({
         protocol,
@@ -637,7 +625,7 @@ export const serializeAws_restJson1RegisterClusterCommand = async (input, contex
         body,
     });
 };
-export const serializeAws_restJson1TagResourceCommand = async (input, context) => {
+export const se_TagResourceCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -646,7 +634,7 @@ export const serializeAws_restJson1TagResourceCommand = async (input, context) =
     resolvedPath = __resolvedPath(resolvedPath, input, "resourceArn", () => input.resourceArn, "{resourceArn}", false);
     let body;
     body = JSON.stringify({
-        ...(input.tags != null && { tags: serializeAws_restJson1TagMap(input.tags, context) }),
+        ...(input.tags != null && { tags: se_TagMap(input.tags, context) }),
     });
     return new __HttpRequest({
         protocol,
@@ -658,7 +646,7 @@ export const serializeAws_restJson1TagResourceCommand = async (input, context) =
         body,
     });
 };
-export const serializeAws_restJson1UntagResourceCommand = async (input, context) => {
+export const se_UntagResourceCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{resourceArn}";
@@ -681,7 +669,7 @@ export const serializeAws_restJson1UntagResourceCommand = async (input, context)
         body,
     });
 };
-export const serializeAws_restJson1UpdateAddonCommand = async (input, context) => {
+export const se_UpdateAddonCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -708,7 +696,7 @@ export const serializeAws_restJson1UpdateAddonCommand = async (input, context) =
         body,
     });
 };
-export const serializeAws_restJson1UpdateClusterConfigCommand = async (input, context) => {
+export const se_UpdateClusterConfigCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -718,9 +706,9 @@ export const serializeAws_restJson1UpdateClusterConfigCommand = async (input, co
     let body;
     body = JSON.stringify({
         clientRequestToken: input.clientRequestToken ?? generateIdempotencyToken(),
-        ...(input.logging != null && { logging: serializeAws_restJson1Logging(input.logging, context) }),
+        ...(input.logging != null && { logging: se_Logging(input.logging, context) }),
         ...(input.resourcesVpcConfig != null && {
-            resourcesVpcConfig: serializeAws_restJson1VpcConfigRequest(input.resourcesVpcConfig, context),
+            resourcesVpcConfig: se_VpcConfigRequest(input.resourcesVpcConfig, context),
         }),
     });
     return new __HttpRequest({
@@ -733,7 +721,7 @@ export const serializeAws_restJson1UpdateClusterConfigCommand = async (input, co
         body,
     });
 };
-export const serializeAws_restJson1UpdateClusterVersionCommand = async (input, context) => {
+export const se_UpdateClusterVersionCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -755,7 +743,7 @@ export const serializeAws_restJson1UpdateClusterVersionCommand = async (input, c
         body,
     });
 };
-export const serializeAws_restJson1UpdateNodegroupConfigCommand = async (input, context) => {
+export const se_UpdateNodegroupConfigCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -767,14 +755,10 @@ export const serializeAws_restJson1UpdateNodegroupConfigCommand = async (input,
     let body;
     body = JSON.stringify({
         clientRequestToken: input.clientRequestToken ?? generateIdempotencyToken(),
-        ...(input.labels != null && { labels: serializeAws_restJson1UpdateLabelsPayload(input.labels, context) }),
-        ...(input.scalingConfig != null && {
-            scalingConfig: serializeAws_restJson1NodegroupScalingConfig(input.scalingConfig, context),
-        }),
-        ...(input.taints != null && { taints: serializeAws_restJson1UpdateTaintsPayload(input.taints, context) }),
-        ...(input.updateConfig != null && {
-            updateConfig: serializeAws_restJson1NodegroupUpdateConfig(input.updateConfig, context),
-        }),
+        ...(input.labels != null && { labels: se_UpdateLabelsPayload(input.labels, context) }),
+        ...(input.scalingConfig != null && { scalingConfig: se_NodegroupScalingConfig(input.scalingConfig, context) }),
+        ...(input.taints != null && { taints: se_UpdateTaintsPayload(input.taints, context) }),
+        ...(input.updateConfig != null && { updateConfig: se_NodegroupUpdateConfig(input.updateConfig, context) }),
     });
     return new __HttpRequest({
         protocol,
@@ -786,7 +770,7 @@ export const serializeAws_restJson1UpdateNodegroupConfigCommand = async (input,
         body,
     });
 };
-export const serializeAws_restJson1UpdateNodegroupVersionCommand = async (input, context) => {
+export const se_UpdateNodegroupVersionCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -800,7 +784,7 @@ export const serializeAws_restJson1UpdateNodegroupVersionCommand = async (input,
         clientRequestToken: input.clientRequestToken ?? generateIdempotencyToken(),
         ...(input.force != null && { force: input.force }),
         ...(input.launchTemplate != null && {
-            launchTemplate: serializeAws_restJson1LaunchTemplateSpecification(input.launchTemplate, context),
+            launchTemplate: se_LaunchTemplateSpecification(input.launchTemplate, context),
         }),
         ...(input.releaseVersion != null && { releaseVersion: input.releaseVersion }),
         ...(input.version != null && { version: input.version }),
@@ -815,20 +799,20 @@ export const serializeAws_restJson1UpdateNodegroupVersionCommand = async (input,
         body,
     });
 };
-export const deserializeAws_restJson1AssociateEncryptionConfigCommand = async (output, context) => {
+export const de_AssociateEncryptionConfigCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1AssociateEncryptionConfigCommandError(output, context);
+        return de_AssociateEncryptionConfigCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.update != null) {
-        contents.update = deserializeAws_restJson1Update(data.update, context);
+        contents.update = de_Update(data.update, context);
     }
     return contents;
 };
-const deserializeAws_restJson1AssociateEncryptionConfigCommandError = async (output, context) => {
+const de_AssociateEncryptionConfigCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -837,22 +821,22 @@ const deserializeAws_restJson1AssociateEncryptionConfigCommandError = async (out
     switch (errorCode) {
         case "ClientException":
         case "com.amazonaws.eks#ClientException":
-            throw await deserializeAws_restJson1ClientExceptionResponse(parsedOutput, context);
+            throw await de_ClientExceptionRes(parsedOutput, context);
         case "InvalidParameterException":
         case "com.amazonaws.eks#InvalidParameterException":
-            throw await deserializeAws_restJson1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "InvalidRequestException":
         case "com.amazonaws.eks#InvalidRequestException":
-            throw await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context);
+            throw await de_InvalidRequestExceptionRes(parsedOutput, context);
         case "ResourceInUseException":
         case "com.amazonaws.eks#ResourceInUseException":
-            throw await deserializeAws_restJson1ResourceInUseExceptionResponse(parsedOutput, context);
+            throw await de_ResourceInUseExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.eks#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServerException":
         case "com.amazonaws.eks#ServerException":
-            throw await deserializeAws_restJson1ServerExceptionResponse(parsedOutput, context);
+            throw await de_ServerExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -863,23 +847,23 @@ const deserializeAws_restJson1AssociateEncryptionConfigCommandError = async (out
             });
     }
 };
-export const deserializeAws_restJson1AssociateIdentityProviderConfigCommand = async (output, context) => {
+export const de_AssociateIdentityProviderConfigCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1AssociateIdentityProviderConfigCommandError(output, context);
+        return de_AssociateIdentityProviderConfigCommandError(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_restJson1TagMap(data.tags, context);
+        contents.tags = de_TagMap(data.tags, context);
     }
     if (data.update != null) {
-        contents.update = deserializeAws_restJson1Update(data.update, context);
+        contents.update = de_Update(data.update, context);
     }
     return contents;
 };
-const deserializeAws_restJson1AssociateIdentityProviderConfigCommandError = async (output, context) => {
+const de_AssociateIdentityProviderConfigCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -888,22 +872,22 @@ const deserializeAws_restJson1AssociateIdentityProviderConfigCommandError = asyn
     switch (errorCode) {
         case "ClientException":
         case "com.amazonaws.eks#ClientException":
-            throw await deserializeAws_restJson1ClientExceptionResponse(parsedOutput, context);
+            throw await de_ClientExceptionRes(parsedOutput, context);
         case "InvalidParameterException":
         case "com.amazonaws.eks#InvalidParameterException":
-            throw await deserializeAws_restJson1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "InvalidRequestException":
         case "com.amazonaws.eks#InvalidRequestException":
-            throw await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context);
+            throw await de_InvalidRequestExceptionRes(parsedOutput, context);
         case "ResourceInUseException":
         case "com.amazonaws.eks#ResourceInUseException":
-            throw await deserializeAws_restJson1ResourceInUseExceptionResponse(parsedOutput, context);
+            throw await de_ResourceInUseExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.eks#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServerException":
         case "com.amazonaws.eks#ServerException":
-            throw await deserializeAws_restJson1ServerExceptionResponse(parsedOutput, context);
+            throw await de_ServerExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -914,20 +898,20 @@ const deserializeAws_restJson1AssociateIdentityProviderConfigCommandError = asyn
             });
     }
 };
-export const deserializeAws_restJson1CreateAddonCommand = async (output, context) => {
+export const de_CreateAddonCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1CreateAddonCommandError(output, context);
+        return de_CreateAddonCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.addon != null) {
-        contents.addon = deserializeAws_restJson1Addon(data.addon, context);
+        contents.addon = de_Addon(data.addon, context);
     }
     return contents;
 };
-const deserializeAws_restJson1CreateAddonCommandError = async (output, context) => {
+const de_CreateAddonCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -936,22 +920,22 @@ const deserializeAws_restJson1CreateAddonCommandError = async (output, context)
     switch (errorCode) {
         case "ClientException":
         case "com.amazonaws.eks#ClientException":
-            throw await deserializeAws_restJson1ClientExceptionResponse(parsedOutput, context);
+            throw await de_ClientExceptionRes(parsedOutput, context);
         case "InvalidParameterException":
         case "com.amazonaws.eks#InvalidParameterException":
-            throw await deserializeAws_restJson1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "InvalidRequestException":
         case "com.amazonaws.eks#InvalidRequestException":
-            throw await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context);
+            throw await de_InvalidRequestExceptionRes(parsedOutput, context);
         case "ResourceInUseException":
         case "com.amazonaws.eks#ResourceInUseException":
-            throw await deserializeAws_restJson1ResourceInUseExceptionResponse(parsedOutput, context);
+            throw await de_ResourceInUseExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.eks#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServerException":
         case "com.amazonaws.eks#ServerException":
-            throw await deserializeAws_restJson1ServerExceptionResponse(parsedOutput, context);
+            throw await de_ServerExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -962,20 +946,20 @@ const deserializeAws_restJson1CreateAddonCommandError = async (output, context)
             });
     }
 };
-export const deserializeAws_restJson1CreateClusterCommand = async (output, context) => {
+export const de_CreateClusterCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1CreateClusterCommandError(output, context);
+        return de_CreateClusterCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.cluster != null) {
-        contents.cluster = deserializeAws_restJson1Cluster(data.cluster, context);
+        contents.cluster = de_Cluster(data.cluster, context);
     }
     return contents;
 };
-const deserializeAws_restJson1CreateClusterCommandError = async (output, context) => {
+const de_CreateClusterCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -984,25 +968,25 @@ const deserializeAws_restJson1CreateClusterCommandError = async (output, context
     switch (errorCode) {
         case "ClientException":
         case "com.amazonaws.eks#ClientException":
-            throw await deserializeAws_restJson1ClientExceptionResponse(parsedOutput, context);
+            throw await de_ClientExceptionRes(parsedOutput, context);
         case "InvalidParameterException":
         case "com.amazonaws.eks#InvalidParameterException":
-            throw await deserializeAws_restJson1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "ResourceInUseException":
         case "com.amazonaws.eks#ResourceInUseException":
-            throw await deserializeAws_restJson1ResourceInUseExceptionResponse(parsedOutput, context);
+            throw await de_ResourceInUseExceptionRes(parsedOutput, context);
         case "ResourceLimitExceededException":
         case "com.amazonaws.eks#ResourceLimitExceededException":
-            throw await deserializeAws_restJson1ResourceLimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_ResourceLimitExceededExceptionRes(parsedOutput, context);
         case "ServerException":
         case "com.amazonaws.eks#ServerException":
-            throw await deserializeAws_restJson1ServerExceptionResponse(parsedOutput, context);
+            throw await de_ServerExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.eks#ServiceUnavailableException":
-            throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         case "UnsupportedAvailabilityZoneException":
         case "com.amazonaws.eks#UnsupportedAvailabilityZoneException":
-            throw await deserializeAws_restJson1UnsupportedAvailabilityZoneExceptionResponse(parsedOutput, context);
+            throw await de_UnsupportedAvailabilityZoneExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1013,20 +997,20 @@ const deserializeAws_restJson1CreateClusterCommandError = async (output, context
             });
     }
 };
-export const deserializeAws_restJson1CreateFargateProfileCommand = async (output, context) => {
+export const de_CreateFargateProfileCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1CreateFargateProfileCommandError(output, context);
+        return de_CreateFargateProfileCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.fargateProfile != null) {
-        contents.fargateProfile = deserializeAws_restJson1FargateProfile(data.fargateProfile, context);
+        contents.fargateProfile = de_FargateProfile(data.fargateProfile, context);
     }
     return contents;
 };
-const deserializeAws_restJson1CreateFargateProfileCommandError = async (output, context) => {
+const de_CreateFargateProfileCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1035,22 +1019,22 @@ const deserializeAws_restJson1CreateFargateProfileCommandError = async (output,
     switch (errorCode) {
         case "ClientException":
         case "com.amazonaws.eks#ClientException":
-            throw await deserializeAws_restJson1ClientExceptionResponse(parsedOutput, context);
+            throw await de_ClientExceptionRes(parsedOutput, context);
         case "InvalidParameterException":
         case "com.amazonaws.eks#InvalidParameterException":
-            throw await deserializeAws_restJson1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "InvalidRequestException":
         case "com.amazonaws.eks#InvalidRequestException":
-            throw await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context);
+            throw await de_InvalidRequestExceptionRes(parsedOutput, context);
         case "ResourceLimitExceededException":
         case "com.amazonaws.eks#ResourceLimitExceededException":
-            throw await deserializeAws_restJson1ResourceLimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_ResourceLimitExceededExceptionRes(parsedOutput, context);
         case "ServerException":
         case "com.amazonaws.eks#ServerException":
-            throw await deserializeAws_restJson1ServerExceptionResponse(parsedOutput, context);
+            throw await de_ServerExceptionRes(parsedOutput, context);
         case "UnsupportedAvailabilityZoneException":
         case "com.amazonaws.eks#UnsupportedAvailabilityZoneException":
-            throw await deserializeAws_restJson1UnsupportedAvailabilityZoneExceptionResponse(parsedOutput, context);
+            throw await de_UnsupportedAvailabilityZoneExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1061,20 +1045,20 @@ const deserializeAws_restJson1CreateFargateProfileCommandError = async (output,
             });
     }
 };
-export const deserializeAws_restJson1CreateNodegroupCommand = async (output, context) => {
+export const de_CreateNodegroupCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1CreateNodegroupCommandError(output, context);
+        return de_CreateNodegroupCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.nodegroup != null) {
-        contents.nodegroup = deserializeAws_restJson1Nodegroup(data.nodegroup, context);
+        contents.nodegroup = de_Nodegroup(data.nodegroup, context);
     }
     return contents;
 };
-const deserializeAws_restJson1CreateNodegroupCommandError = async (output, context) => {
+const de_CreateNodegroupCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1083,25 +1067,25 @@ const deserializeAws_restJson1CreateNodegroupCommandError = async (output, conte
     switch (errorCode) {
         case "ClientException":
         case "com.amazonaws.eks#ClientException":
-            throw await deserializeAws_restJson1ClientExceptionResponse(parsedOutput, context);
+            throw await de_ClientExceptionRes(parsedOutput, context);
         case "InvalidParameterException":
         case "com.amazonaws.eks#InvalidParameterException":
-            throw await deserializeAws_restJson1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "InvalidRequestException":
         case "com.amazonaws.eks#InvalidRequestException":
-            throw await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context);
+            throw await de_InvalidRequestExceptionRes(parsedOutput, context);
         case "ResourceInUseException":
         case "com.amazonaws.eks#ResourceInUseException":
-            throw await deserializeAws_restJson1ResourceInUseExceptionResponse(parsedOutput, context);
+            throw await de_ResourceInUseExceptionRes(parsedOutput, context);
         case "ResourceLimitExceededException":
         case "com.amazonaws.eks#ResourceLimitExceededException":
-            throw await deserializeAws_restJson1ResourceLimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_ResourceLimitExceededExceptionRes(parsedOutput, context);
         case "ServerException":
         case "com.amazonaws.eks#ServerException":
-            throw await deserializeAws_restJson1ServerExceptionResponse(parsedOutput, context);
+            throw await de_ServerExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.eks#ServiceUnavailableException":
-            throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1112,20 +1096,20 @@ const deserializeAws_restJson1CreateNodegroupCommandError = async (output, conte
             });
     }
 };
-export const deserializeAws_restJson1DeleteAddonCommand = async (output, context) => {
+export const de_DeleteAddonCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1DeleteAddonCommandError(output, context);
+        return de_DeleteAddonCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.addon != null) {
-        contents.addon = deserializeAws_restJson1Addon(data.addon, context);
+        contents.addon = de_Addon(data.addon, context);
     }
     return contents;
 };
-const deserializeAws_restJson1DeleteAddonCommandError = async (output, context) => {
+const de_DeleteAddonCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1134,19 +1118,19 @@ const deserializeAws_restJson1DeleteAddonCommandError = async (output, context)
     switch (errorCode) {
         case "ClientException":
         case "com.amazonaws.eks#ClientException":
-            throw await deserializeAws_restJson1ClientExceptionResponse(parsedOutput, context);
+            throw await de_ClientExceptionRes(parsedOutput, context);
         case "InvalidParameterException":
         case "com.amazonaws.eks#InvalidParameterException":
-            throw await deserializeAws_restJson1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "InvalidRequestException":
         case "com.amazonaws.eks#InvalidRequestException":
-            throw await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context);
+            throw await de_InvalidRequestExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.eks#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServerException":
         case "com.amazonaws.eks#ServerException":
-            throw await deserializeAws_restJson1ServerExceptionResponse(parsedOutput, context);
+            throw await de_ServerExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1157,20 +1141,20 @@ const deserializeAws_restJson1DeleteAddonCommandError = async (output, context)
             });
     }
 };
-export const deserializeAws_restJson1DeleteClusterCommand = async (output, context) => {
+export const de_DeleteClusterCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1DeleteClusterCommandError(output, context);
+        return de_DeleteClusterCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.cluster != null) {
-        contents.cluster = deserializeAws_restJson1Cluster(data.cluster, context);
+        contents.cluster = de_Cluster(data.cluster, context);
     }
     return contents;
 };
-const deserializeAws_restJson1DeleteClusterCommandError = async (output, context) => {
+const de_DeleteClusterCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1179,19 +1163,19 @@ const deserializeAws_restJson1DeleteClusterCommandError = async (output, context
     switch (errorCode) {
         case "ClientException":
         case "com.amazonaws.eks#ClientException":
-            throw await deserializeAws_restJson1ClientExceptionResponse(parsedOutput, context);
+            throw await de_ClientExceptionRes(parsedOutput, context);
         case "ResourceInUseException":
         case "com.amazonaws.eks#ResourceInUseException":
-            throw await deserializeAws_restJson1ResourceInUseExceptionResponse(parsedOutput, context);
+            throw await de_ResourceInUseExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.eks#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServerException":
         case "com.amazonaws.eks#ServerException":
-            throw await deserializeAws_restJson1ServerExceptionResponse(parsedOutput, context);
+            throw await de_ServerExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.eks#ServiceUnavailableException":
-            throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1202,20 +1186,20 @@ const deserializeAws_restJson1DeleteClusterCommandError = async (output, context
             });
     }
 };
-export const deserializeAws_restJson1DeleteFargateProfileCommand = async (output, context) => {
+export const de_DeleteFargateProfileCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1DeleteFargateProfileCommandError(output, context);
+        return de_DeleteFargateProfileCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.fargateProfile != null) {
-        contents.fargateProfile = deserializeAws_restJson1FargateProfile(data.fargateProfile, context);
+        contents.fargateProfile = de_FargateProfile(data.fargateProfile, context);
     }
     return contents;
 };
-const deserializeAws_restJson1DeleteFargateProfileCommandError = async (output, context) => {
+const de_DeleteFargateProfileCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1224,16 +1208,16 @@ const deserializeAws_restJson1DeleteFargateProfileCommandError = async (output,
     switch (errorCode) {
         case "ClientException":
         case "com.amazonaws.eks#ClientException":
-            throw await deserializeAws_restJson1ClientExceptionResponse(parsedOutput, context);
+            throw await de_ClientExceptionRes(parsedOutput, context);
         case "InvalidParameterException":
         case "com.amazonaws.eks#InvalidParameterException":
-            throw await deserializeAws_restJson1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.eks#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServerException":
         case "com.amazonaws.eks#ServerException":
-            throw await deserializeAws_restJson1ServerExceptionResponse(parsedOutput, context);
+            throw await de_ServerExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1244,20 +1228,20 @@ const deserializeAws_restJson1DeleteFargateProfileCommandError = async (output,
             });
     }
 };
-export const deserializeAws_restJson1DeleteNodegroupCommand = async (output, context) => {
+export const de_DeleteNodegroupCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1DeleteNodegroupCommandError(output, context);
+        return de_DeleteNodegroupCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.nodegroup != null) {
-        contents.nodegroup = deserializeAws_restJson1Nodegroup(data.nodegroup, context);
+        contents.nodegroup = de_Nodegroup(data.nodegroup, context);
     }
     return contents;
 };
-const deserializeAws_restJson1DeleteNodegroupCommandError = async (output, context) => {
+const de_DeleteNodegroupCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1266,22 +1250,22 @@ const deserializeAws_restJson1DeleteNodegroupCommandError = async (output, conte
     switch (errorCode) {
         case "ClientException":
         case "com.amazonaws.eks#ClientException":
-            throw await deserializeAws_restJson1ClientExceptionResponse(parsedOutput, context);
+            throw await de_ClientExceptionRes(parsedOutput, context);
         case "InvalidParameterException":
         case "com.amazonaws.eks#InvalidParameterException":
-            throw await deserializeAws_restJson1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "ResourceInUseException":
         case "com.amazonaws.eks#ResourceInUseException":
-            throw await deserializeAws_restJson1ResourceInUseExceptionResponse(parsedOutput, context);
+            throw await de_ResourceInUseExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.eks#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServerException":
         case "com.amazonaws.eks#ServerException":
-            throw await deserializeAws_restJson1ServerExceptionResponse(parsedOutput, context);
+            throw await de_ServerExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.eks#ServiceUnavailableException":
-            throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1292,20 +1276,20 @@ const deserializeAws_restJson1DeleteNodegroupCommandError = async (output, conte
             });
     }
 };
-export const deserializeAws_restJson1DeregisterClusterCommand = async (output, context) => {
+export const de_DeregisterClusterCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1DeregisterClusterCommandError(output, context);
+        return de_DeregisterClusterCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.cluster != null) {
-        contents.cluster = deserializeAws_restJson1Cluster(data.cluster, context);
+        contents.cluster = de_Cluster(data.cluster, context);
     }
     return contents;
 };
-const deserializeAws_restJson1DeregisterClusterCommandError = async (output, context) => {
+const de_DeregisterClusterCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1314,22 +1298,22 @@ const deserializeAws_restJson1DeregisterClusterCommandError = async (output, con
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.eks#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "ClientException":
         case "com.amazonaws.eks#ClientException":
-            throw await deserializeAws_restJson1ClientExceptionResponse(parsedOutput, context);
+            throw await de_ClientExceptionRes(parsedOutput, context);
         case "ResourceInUseException":
         case "com.amazonaws.eks#ResourceInUseException":
-            throw await deserializeAws_restJson1ResourceInUseExceptionResponse(parsedOutput, context);
+            throw await de_ResourceInUseExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.eks#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServerException":
         case "com.amazonaws.eks#ServerException":
-            throw await deserializeAws_restJson1ServerExceptionResponse(parsedOutput, context);
+            throw await de_ServerExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.eks#ServiceUnavailableException":
-            throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1340,20 +1324,20 @@ const deserializeAws_restJson1DeregisterClusterCommandError = async (output, con
             });
     }
 };
-export const deserializeAws_restJson1DescribeAddonCommand = async (output, context) => {
+export const de_DescribeAddonCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1DescribeAddonCommandError(output, context);
+        return de_DescribeAddonCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.addon != null) {
-        contents.addon = deserializeAws_restJson1Addon(data.addon, context);
+        contents.addon = de_Addon(data.addon, context);
     }
     return contents;
 };
-const deserializeAws_restJson1DescribeAddonCommandError = async (output, context) => {
+const de_DescribeAddonCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1362,19 +1346,19 @@ const deserializeAws_restJson1DescribeAddonCommandError = async (output, context
     switch (errorCode) {
         case "ClientException":
         case "com.amazonaws.eks#ClientException":
-            throw await deserializeAws_restJson1ClientExceptionResponse(parsedOutput, context);
+            throw await de_ClientExceptionRes(parsedOutput, context);
         case "InvalidParameterException":
         case "com.amazonaws.eks#InvalidParameterException":
-            throw await deserializeAws_restJson1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "InvalidRequestException":
         case "com.amazonaws.eks#InvalidRequestException":
-            throw await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context);
+            throw await de_InvalidRequestExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.eks#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServerException":
         case "com.amazonaws.eks#ServerException":
-            throw await deserializeAws_restJson1ServerExceptionResponse(parsedOutput, context);
+            throw await de_ServerExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1385,9 +1369,9 @@ const deserializeAws_restJson1DescribeAddonCommandError = async (output, context
             });
     }
 };
-export const deserializeAws_restJson1DescribeAddonConfigurationCommand = async (output, context) => {
+export const de_DescribeAddonConfigurationCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1DescribeAddonConfigurationCommandError(output, context);
+        return de_DescribeAddonConfigurationCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1404,7 +1388,7 @@ export const deserializeAws_restJson1DescribeAddonConfigurationCommand = async (
     }
     return contents;
 };
-const deserializeAws_restJson1DescribeAddonConfigurationCommandError = async (output, context) => {
+const de_DescribeAddonConfigurationCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1413,13 +1397,13 @@ const deserializeAws_restJson1DescribeAddonConfigurationCommandError = async (ou
     switch (errorCode) {
         case "InvalidParameterException":
         case "com.amazonaws.eks#InvalidParameterException":
-            throw await deserializeAws_restJson1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.eks#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServerException":
         case "com.amazonaws.eks#ServerException":
-            throw await deserializeAws_restJson1ServerExceptionResponse(parsedOutput, context);
+            throw await de_ServerExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1430,23 +1414,23 @@ const deserializeAws_restJson1DescribeAddonConfigurationCommandError = async (ou
             });
     }
 };
-export const deserializeAws_restJson1DescribeAddonVersionsCommand = async (output, context) => {
+export const de_DescribeAddonVersionsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1DescribeAddonVersionsCommandError(output, context);
+        return de_DescribeAddonVersionsCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.addons != null) {
-        contents.addons = deserializeAws_restJson1Addons(data.addons, context);
+        contents.addons = de_Addons(data.addons, context);
     }
     if (data.nextToken != null) {
         contents.nextToken = __expectString(data.nextToken);
     }
     return contents;
 };
-const deserializeAws_restJson1DescribeAddonVersionsCommandError = async (output, context) => {
+const de_DescribeAddonVersionsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1455,13 +1439,13 @@ const deserializeAws_restJson1DescribeAddonVersionsCommandError = async (output,
     switch (errorCode) {
         case "InvalidParameterException":
         case "com.amazonaws.eks#InvalidParameterException":
-            throw await deserializeAws_restJson1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.eks#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServerException":
         case "com.amazonaws.eks#ServerException":
-            throw await deserializeAws_restJson1ServerExceptionResponse(parsedOutput, context);
+            throw await de_ServerExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1472,20 +1456,20 @@ const deserializeAws_restJson1DescribeAddonVersionsCommandError = async (output,
             });
     }
 };
-export const deserializeAws_restJson1DescribeClusterCommand = async (output, context) => {
+export const de_DescribeClusterCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1DescribeClusterCommandError(output, context);
+        return de_DescribeClusterCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.cluster != null) {
-        contents.cluster = deserializeAws_restJson1Cluster(data.cluster, context);
+        contents.cluster = de_Cluster(data.cluster, context);
     }
     return contents;
 };
-const deserializeAws_restJson1DescribeClusterCommandError = async (output, context) => {
+const de_DescribeClusterCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1494,16 +1478,16 @@ const deserializeAws_restJson1DescribeClusterCommandError = async (output, conte
     switch (errorCode) {
         case "ClientException":
         case "com.amazonaws.eks#ClientException":
-            throw await deserializeAws_restJson1ClientExceptionResponse(parsedOutput, context);
+            throw await de_ClientExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.eks#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServerException":
         case "com.amazonaws.eks#ServerException":
-            throw await deserializeAws_restJson1ServerExceptionResponse(parsedOutput, context);
+            throw await de_ServerExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.eks#ServiceUnavailableException":
-            throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1514,20 +1498,20 @@ const deserializeAws_restJson1DescribeClusterCommandError = async (output, conte
             });
     }
 };
-export const deserializeAws_restJson1DescribeFargateProfileCommand = async (output, context) => {
+export const de_DescribeFargateProfileCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1DescribeFargateProfileCommandError(output, context);
+        return de_DescribeFargateProfileCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.fargateProfile != null) {
-        contents.fargateProfile = deserializeAws_restJson1FargateProfile(data.fargateProfile, context);
+        contents.fargateProfile = de_FargateProfile(data.fargateProfile, context);
     }
     return contents;
 };
-const deserializeAws_restJson1DescribeFargateProfileCommandError = async (output, context) => {
+const de_DescribeFargateProfileCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1536,16 +1520,16 @@ const deserializeAws_restJson1DescribeFargateProfileCommandError = async (output
     switch (errorCode) {
         case "ClientException":
         case "com.amazonaws.eks#ClientException":
-            throw await deserializeAws_restJson1ClientExceptionResponse(parsedOutput, context);
+            throw await de_ClientExceptionRes(parsedOutput, context);
         case "InvalidParameterException":
         case "com.amazonaws.eks#InvalidParameterException":
-            throw await deserializeAws_restJson1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.eks#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServerException":
         case "com.amazonaws.eks#ServerException":
-            throw await deserializeAws_restJson1ServerExceptionResponse(parsedOutput, context);
+            throw await de_ServerExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1556,20 +1540,20 @@ const deserializeAws_restJson1DescribeFargateProfileCommandError = async (output
             });
     }
 };
-export const deserializeAws_restJson1DescribeIdentityProviderConfigCommand = async (output, context) => {
+export const de_DescribeIdentityProviderConfigCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1DescribeIdentityProviderConfigCommandError(output, context);
+        return de_DescribeIdentityProviderConfigCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.identityProviderConfig != null) {
-        contents.identityProviderConfig = deserializeAws_restJson1IdentityProviderConfigResponse(data.identityProviderConfig, context);
+        contents.identityProviderConfig = de_IdentityProviderConfigResponse(data.identityProviderConfig, context);
     }
     return contents;
 };
-const deserializeAws_restJson1DescribeIdentityProviderConfigCommandError = async (output, context) => {
+const de_DescribeIdentityProviderConfigCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1578,19 +1562,19 @@ const deserializeAws_restJson1DescribeIdentityProviderConfigCommandError = async
     switch (errorCode) {
         case "ClientException":
         case "com.amazonaws.eks#ClientException":
-            throw await deserializeAws_restJson1ClientExceptionResponse(parsedOutput, context);
+            throw await de_ClientExceptionRes(parsedOutput, context);
         case "InvalidParameterException":
         case "com.amazonaws.eks#InvalidParameterException":
-            throw await deserializeAws_restJson1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.eks#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServerException":
         case "com.amazonaws.eks#ServerException":
-            throw await deserializeAws_restJson1ServerExceptionResponse(parsedOutput, context);
+            throw await de_ServerExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.eks#ServiceUnavailableException":
-            throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1601,20 +1585,20 @@ const deserializeAws_restJson1DescribeIdentityProviderConfigCommandError = async
             });
     }
 };
-export const deserializeAws_restJson1DescribeNodegroupCommand = async (output, context) => {
+export const de_DescribeNodegroupCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1DescribeNodegroupCommandError(output, context);
+        return de_DescribeNodegroupCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.nodegroup != null) {
-        contents.nodegroup = deserializeAws_restJson1Nodegroup(data.nodegroup, context);
+        contents.nodegroup = de_Nodegroup(data.nodegroup, context);
     }
     return contents;
 };
-const deserializeAws_restJson1DescribeNodegroupCommandError = async (output, context) => {
+const de_DescribeNodegroupCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1623,19 +1607,19 @@ const deserializeAws_restJson1DescribeNodegroupCommandError = async (output, con
     switch (errorCode) {
         case "ClientException":
         case "com.amazonaws.eks#ClientException":
-            throw await deserializeAws_restJson1ClientExceptionResponse(parsedOutput, context);
+            throw await de_ClientExceptionRes(parsedOutput, context);
         case "InvalidParameterException":
         case "com.amazonaws.eks#InvalidParameterException":
-            throw await deserializeAws_restJson1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.eks#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServerException":
         case "com.amazonaws.eks#ServerException":
-            throw await deserializeAws_restJson1ServerExceptionResponse(parsedOutput, context);
+            throw await de_ServerExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.eks#ServiceUnavailableException":
-            throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1646,20 +1630,20 @@ const deserializeAws_restJson1DescribeNodegroupCommandError = async (output, con
             });
     }
 };
-export const deserializeAws_restJson1DescribeUpdateCommand = async (output, context) => {
+export const de_DescribeUpdateCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1DescribeUpdateCommandError(output, context);
+        return de_DescribeUpdateCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.update != null) {
-        contents.update = deserializeAws_restJson1Update(data.update, context);
+        contents.update = de_Update(data.update, context);
     }
     return contents;
 };
-const deserializeAws_restJson1DescribeUpdateCommandError = async (output, context) => {
+const de_DescribeUpdateCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1668,16 +1652,16 @@ const deserializeAws_restJson1DescribeUpdateCommandError = async (output, contex
     switch (errorCode) {
         case "ClientException":
         case "com.amazonaws.eks#ClientException":
-            throw await deserializeAws_restJson1ClientExceptionResponse(parsedOutput, context);
+            throw await de_ClientExceptionRes(parsedOutput, context);
         case "InvalidParameterException":
         case "com.amazonaws.eks#InvalidParameterException":
-            throw await deserializeAws_restJson1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.eks#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServerException":
         case "com.amazonaws.eks#ServerException":
-            throw await deserializeAws_restJson1ServerExceptionResponse(parsedOutput, context);
+            throw await de_ServerExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1688,20 +1672,20 @@ const deserializeAws_restJson1DescribeUpdateCommandError = async (output, contex
             });
     }
 };
-export const deserializeAws_restJson1DisassociateIdentityProviderConfigCommand = async (output, context) => {
+export const de_DisassociateIdentityProviderConfigCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1DisassociateIdentityProviderConfigCommandError(output, context);
+        return de_DisassociateIdentityProviderConfigCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.update != null) {
-        contents.update = deserializeAws_restJson1Update(data.update, context);
+        contents.update = de_Update(data.update, context);
     }
     return contents;
 };
-const deserializeAws_restJson1DisassociateIdentityProviderConfigCommandError = async (output, context) => {
+const de_DisassociateIdentityProviderConfigCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1710,22 +1694,22 @@ const deserializeAws_restJson1DisassociateIdentityProviderConfigCommandError = a
     switch (errorCode) {
         case "ClientException":
         case "com.amazonaws.eks#ClientException":
-            throw await deserializeAws_restJson1ClientExceptionResponse(parsedOutput, context);
+            throw await de_ClientExceptionRes(parsedOutput, context);
         case "InvalidParameterException":
         case "com.amazonaws.eks#InvalidParameterException":
-            throw await deserializeAws_restJson1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "InvalidRequestException":
         case "com.amazonaws.eks#InvalidRequestException":
-            throw await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context);
+            throw await de_InvalidRequestExceptionRes(parsedOutput, context);
         case "ResourceInUseException":
         case "com.amazonaws.eks#ResourceInUseException":
-            throw await deserializeAws_restJson1ResourceInUseExceptionResponse(parsedOutput, context);
+            throw await de_ResourceInUseExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.eks#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServerException":
         case "com.amazonaws.eks#ServerException":
-            throw await deserializeAws_restJson1ServerExceptionResponse(parsedOutput, context);
+            throw await de_ServerExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1736,23 +1720,23 @@ const deserializeAws_restJson1DisassociateIdentityProviderConfigCommandError = a
             });
     }
 };
-export const deserializeAws_restJson1ListAddonsCommand = async (output, context) => {
+export const de_ListAddonsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1ListAddonsCommandError(output, context);
+        return de_ListAddonsCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.addons != null) {
-        contents.addons = deserializeAws_restJson1StringList(data.addons, context);
+        contents.addons = de_StringList(data.addons, context);
     }
     if (data.nextToken != null) {
         contents.nextToken = __expectString(data.nextToken);
     }
     return contents;
 };
-const deserializeAws_restJson1ListAddonsCommandError = async (output, context) => {
+const de_ListAddonsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1761,19 +1745,19 @@ const deserializeAws_restJson1ListAddonsCommandError = async (output, context) =
     switch (errorCode) {
         case "ClientException":
         case "com.amazonaws.eks#ClientException":
-            throw await deserializeAws_restJson1ClientExceptionResponse(parsedOutput, context);
+            throw await de_ClientExceptionRes(parsedOutput, context);
         case "InvalidParameterException":
         case "com.amazonaws.eks#InvalidParameterException":
-            throw await deserializeAws_restJson1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "InvalidRequestException":
         case "com.amazonaws.eks#InvalidRequestException":
-            throw await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context);
+            throw await de_InvalidRequestExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.eks#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServerException":
         case "com.amazonaws.eks#ServerException":
-            throw await deserializeAws_restJson1ServerExceptionResponse(parsedOutput, context);
+            throw await de_ServerExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1784,23 +1768,23 @@ const deserializeAws_restJson1ListAddonsCommandError = async (output, context) =
             });
     }
 };
-export const deserializeAws_restJson1ListClustersCommand = async (output, context) => {
+export const de_ListClustersCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1ListClustersCommandError(output, context);
+        return de_ListClustersCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.clusters != null) {
-        contents.clusters = deserializeAws_restJson1StringList(data.clusters, context);
+        contents.clusters = de_StringList(data.clusters, context);
     }
     if (data.nextToken != null) {
         contents.nextToken = __expectString(data.nextToken);
     }
     return contents;
 };
-const deserializeAws_restJson1ListClustersCommandError = async (output, context) => {
+const de_ListClustersCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1809,16 +1793,16 @@ const deserializeAws_restJson1ListClustersCommandError = async (output, context)
     switch (errorCode) {
         case "ClientException":
         case "com.amazonaws.eks#ClientException":
-            throw await deserializeAws_restJson1ClientExceptionResponse(parsedOutput, context);
+            throw await de_ClientExceptionRes(parsedOutput, context);
         case "InvalidParameterException":
         case "com.amazonaws.eks#InvalidParameterException":
-            throw await deserializeAws_restJson1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "ServerException":
         case "com.amazonaws.eks#ServerException":
-            throw await deserializeAws_restJson1ServerExceptionResponse(parsedOutput, context);
+            throw await de_ServerExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.eks#ServiceUnavailableException":
-            throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1829,23 +1813,23 @@ const deserializeAws_restJson1ListClustersCommandError = async (output, context)
             });
     }
 };
-export const deserializeAws_restJson1ListFargateProfilesCommand = async (output, context) => {
+export const de_ListFargateProfilesCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1ListFargateProfilesCommandError(output, context);
+        return de_ListFargateProfilesCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.fargateProfileNames != null) {
-        contents.fargateProfileNames = deserializeAws_restJson1StringList(data.fargateProfileNames, context);
+        contents.fargateProfileNames = de_StringList(data.fargateProfileNames, context);
     }
     if (data.nextToken != null) {
         contents.nextToken = __expectString(data.nextToken);
     }
     return contents;
 };
-const deserializeAws_restJson1ListFargateProfilesCommandError = async (output, context) => {
+const de_ListFargateProfilesCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1854,16 +1838,16 @@ const deserializeAws_restJson1ListFargateProfilesCommandError = async (output, c
     switch (errorCode) {
         case "ClientException":
         case "com.amazonaws.eks#ClientException":
-            throw await deserializeAws_restJson1ClientExceptionResponse(parsedOutput, context);
+            throw await de_ClientExceptionRes(parsedOutput, context);
         case "InvalidParameterException":
         case "com.amazonaws.eks#InvalidParameterException":
-            throw await deserializeAws_restJson1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.eks#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServerException":
         case "com.amazonaws.eks#ServerException":
-            throw await deserializeAws_restJson1ServerExceptionResponse(parsedOutput, context);
+            throw await de_ServerExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1874,23 +1858,23 @@ const deserializeAws_restJson1ListFargateProfilesCommandError = async (output, c
             });
     }
 };
-export const deserializeAws_restJson1ListIdentityProviderConfigsCommand = async (output, context) => {
+export const de_ListIdentityProviderConfigsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1ListIdentityProviderConfigsCommandError(output, context);
+        return de_ListIdentityProviderConfigsCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.identityProviderConfigs != null) {
-        contents.identityProviderConfigs = deserializeAws_restJson1IdentityProviderConfigs(data.identityProviderConfigs, context);
+        contents.identityProviderConfigs = de_IdentityProviderConfigs(data.identityProviderConfigs, context);
     }
     if (data.nextToken != null) {
         contents.nextToken = __expectString(data.nextToken);
     }
     return contents;
 };
-const deserializeAws_restJson1ListIdentityProviderConfigsCommandError = async (output, context) => {
+const de_ListIdentityProviderConfigsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1899,19 +1883,19 @@ const deserializeAws_restJson1ListIdentityProviderConfigsCommandError = async (o
     switch (errorCode) {
         case "ClientException":
         case "com.amazonaws.eks#ClientException":
-            throw await deserializeAws_restJson1ClientExceptionResponse(parsedOutput, context);
+            throw await de_ClientExceptionRes(parsedOutput, context);
         case "InvalidParameterException":
         case "com.amazonaws.eks#InvalidParameterException":
-            throw await deserializeAws_restJson1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.eks#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServerException":
         case "com.amazonaws.eks#ServerException":
-            throw await deserializeAws_restJson1ServerExceptionResponse(parsedOutput, context);
+            throw await de_ServerExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.eks#ServiceUnavailableException":
-            throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1922,9 +1906,9 @@ const deserializeAws_restJson1ListIdentityProviderConfigsCommandError = async (o
             });
     }
 };
-export const deserializeAws_restJson1ListNodegroupsCommand = async (output, context) => {
+export const de_ListNodegroupsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1ListNodegroupsCommandError(output, context);
+        return de_ListNodegroupsCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1934,11 +1918,11 @@ export const deserializeAws_restJson1ListNodegroupsCommand = async (output, cont
         contents.nextToken = __expectString(data.nextToken);
     }
     if (data.nodegroups != null) {
-        contents.nodegroups = deserializeAws_restJson1StringList(data.nodegroups, context);
+        contents.nodegroups = de_StringList(data.nodegroups, context);
     }
     return contents;
 };
-const deserializeAws_restJson1ListNodegroupsCommandError = async (output, context) => {
+const de_ListNodegroupsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1947,19 +1931,19 @@ const deserializeAws_restJson1ListNodegroupsCommandError = async (output, contex
     switch (errorCode) {
         case "ClientException":
         case "com.amazonaws.eks#ClientException":
-            throw await deserializeAws_restJson1ClientExceptionResponse(parsedOutput, context);
+            throw await de_ClientExceptionRes(parsedOutput, context);
         case "InvalidParameterException":
         case "com.amazonaws.eks#InvalidParameterException":
-            throw await deserializeAws_restJson1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.eks#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServerException":
         case "com.amazonaws.eks#ServerException":
-            throw await deserializeAws_restJson1ServerExceptionResponse(parsedOutput, context);
+            throw await de_ServerExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.eks#ServiceUnavailableException":
-            throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1970,20 +1954,20 @@ const deserializeAws_restJson1ListNodegroupsCommandError = async (output, contex
             });
     }
 };
-export const deserializeAws_restJson1ListTagsForResourceCommand = async (output, context) => {
+export const de_ListTagsForResourceCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1ListTagsForResourceCommandError(output, context);
+        return de_ListTagsForResourceCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.tags != null) {
-        contents.tags = deserializeAws_restJson1TagMap(data.tags, context);
+        contents.tags = de_TagMap(data.tags, context);
     }
     return contents;
 };
-const deserializeAws_restJson1ListTagsForResourceCommandError = async (output, context) => {
+const de_ListTagsForResourceCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1992,10 +1976,10 @@ const deserializeAws_restJson1ListTagsForResourceCommandError = async (output, c
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.eks#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.eks#NotFoundException":
-            throw await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2006,9 +1990,9 @@ const deserializeAws_restJson1ListTagsForResourceCommandError = async (output, c
             });
     }
 };
-export const deserializeAws_restJson1ListUpdatesCommand = async (output, context) => {
+export const de_ListUpdatesCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1ListUpdatesCommandError(output, context);
+        return de_ListUpdatesCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -2018,11 +2002,11 @@ export const deserializeAws_restJson1ListUpdatesCommand = async (output, context
         contents.nextToken = __expectString(data.nextToken);
     }
     if (data.updateIds != null) {
-        contents.updateIds = deserializeAws_restJson1StringList(data.updateIds, context);
+        contents.updateIds = de_StringList(data.updateIds, context);
     }
     return contents;
 };
-const deserializeAws_restJson1ListUpdatesCommandError = async (output, context) => {
+const de_ListUpdatesCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2031,16 +2015,16 @@ const deserializeAws_restJson1ListUpdatesCommandError = async (output, context)
     switch (errorCode) {
         case "ClientException":
         case "com.amazonaws.eks#ClientException":
-            throw await deserializeAws_restJson1ClientExceptionResponse(parsedOutput, context);
+            throw await de_ClientExceptionRes(parsedOutput, context);
         case "InvalidParameterException":
         case "com.amazonaws.eks#InvalidParameterException":
-            throw await deserializeAws_restJson1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.eks#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServerException":
         case "com.amazonaws.eks#ServerException":
-            throw await deserializeAws_restJson1ServerExceptionResponse(parsedOutput, context);
+            throw await de_ServerExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2051,20 +2035,20 @@ const deserializeAws_restJson1ListUpdatesCommandError = async (output, context)
             });
     }
 };
-export const deserializeAws_restJson1RegisterClusterCommand = async (output, context) => {
+export const de_RegisterClusterCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1RegisterClusterCommandError(output, context);
+        return de_RegisterClusterCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.cluster != null) {
-        contents.cluster = deserializeAws_restJson1Cluster(data.cluster, context);
+        contents.cluster = de_Cluster(data.cluster, context);
     }
     return contents;
 };
-const deserializeAws_restJson1RegisterClusterCommandError = async (output, context) => {
+const de_RegisterClusterCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2073,28 +2057,28 @@ const deserializeAws_restJson1RegisterClusterCommandError = async (output, conte
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.eks#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "ClientException":
         case "com.amazonaws.eks#ClientException":
-            throw await deserializeAws_restJson1ClientExceptionResponse(parsedOutput, context);
+            throw await de_ClientExceptionRes(parsedOutput, context);
         case "InvalidParameterException":
         case "com.amazonaws.eks#InvalidParameterException":
-            throw await deserializeAws_restJson1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "ResourceInUseException":
         case "com.amazonaws.eks#ResourceInUseException":
-            throw await deserializeAws_restJson1ResourceInUseExceptionResponse(parsedOutput, context);
+            throw await de_ResourceInUseExceptionRes(parsedOutput, context);
         case "ResourceLimitExceededException":
         case "com.amazonaws.eks#ResourceLimitExceededException":
-            throw await deserializeAws_restJson1ResourceLimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_ResourceLimitExceededExceptionRes(parsedOutput, context);
         case "ResourcePropagationDelayException":
         case "com.amazonaws.eks#ResourcePropagationDelayException":
-            throw await deserializeAws_restJson1ResourcePropagationDelayExceptionResponse(parsedOutput, context);
+            throw await de_ResourcePropagationDelayExceptionRes(parsedOutput, context);
         case "ServerException":
         case "com.amazonaws.eks#ServerException":
-            throw await deserializeAws_restJson1ServerExceptionResponse(parsedOutput, context);
+            throw await de_ServerExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.eks#ServiceUnavailableException":
-            throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2105,9 +2089,9 @@ const deserializeAws_restJson1RegisterClusterCommandError = async (output, conte
             });
     }
 };
-export const deserializeAws_restJson1TagResourceCommand = async (output, context) => {
+export const de_TagResourceCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1TagResourceCommandError(output, context);
+        return de_TagResourceCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -2115,7 +2099,7 @@ export const deserializeAws_restJson1TagResourceCommand = async (output, context
     await collectBody(output.body, context);
     return contents;
 };
-const deserializeAws_restJson1TagResourceCommandError = async (output, context) => {
+const de_TagResourceCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2124,10 +2108,10 @@ const deserializeAws_restJson1TagResourceCommandError = async (output, context)
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.eks#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.eks#NotFoundException":
-            throw await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2138,9 +2122,9 @@ const deserializeAws_restJson1TagResourceCommandError = async (output, context)
             });
     }
 };
-export const deserializeAws_restJson1UntagResourceCommand = async (output, context) => {
+export const de_UntagResourceCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1UntagResourceCommandError(output, context);
+        return de_UntagResourceCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -2148,7 +2132,7 @@ export const deserializeAws_restJson1UntagResourceCommand = async (output, conte
     await collectBody(output.body, context);
     return contents;
 };
-const deserializeAws_restJson1UntagResourceCommandError = async (output, context) => {
+const de_UntagResourceCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2157,10 +2141,10 @@ const deserializeAws_restJson1UntagResourceCommandError = async (output, context
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.eks#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.eks#NotFoundException":
-            throw await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2171,20 +2155,20 @@ const deserializeAws_restJson1UntagResourceCommandError = async (output, context
             });
     }
 };
-export const deserializeAws_restJson1UpdateAddonCommand = async (output, context) => {
+export const de_UpdateAddonCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1UpdateAddonCommandError(output, context);
+        return de_UpdateAddonCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.update != null) {
-        contents.update = deserializeAws_restJson1Update(data.update, context);
+        contents.update = de_Update(data.update, context);
     }
     return contents;
 };
-const deserializeAws_restJson1UpdateAddonCommandError = async (output, context) => {
+const de_UpdateAddonCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2193,22 +2177,22 @@ const deserializeAws_restJson1UpdateAddonCommandError = async (output, context)
     switch (errorCode) {
         case "ClientException":
         case "com.amazonaws.eks#ClientException":
-            throw await deserializeAws_restJson1ClientExceptionResponse(parsedOutput, context);
+            throw await de_ClientExceptionRes(parsedOutput, context);
         case "InvalidParameterException":
         case "com.amazonaws.eks#InvalidParameterException":
-            throw await deserializeAws_restJson1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "InvalidRequestException":
         case "com.amazonaws.eks#InvalidRequestException":
-            throw await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context);
+            throw await de_InvalidRequestExceptionRes(parsedOutput, context);
         case "ResourceInUseException":
         case "com.amazonaws.eks#ResourceInUseException":
-            throw await deserializeAws_restJson1ResourceInUseExceptionResponse(parsedOutput, context);
+            throw await de_ResourceInUseExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.eks#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServerException":
         case "com.amazonaws.eks#ServerException":
-            throw await deserializeAws_restJson1ServerExceptionResponse(parsedOutput, context);
+            throw await de_ServerExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2219,20 +2203,20 @@ const deserializeAws_restJson1UpdateAddonCommandError = async (output, context)
             });
     }
 };
-export const deserializeAws_restJson1UpdateClusterConfigCommand = async (output, context) => {
+export const de_UpdateClusterConfigCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1UpdateClusterConfigCommandError(output, context);
+        return de_UpdateClusterConfigCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.update != null) {
-        contents.update = deserializeAws_restJson1Update(data.update, context);
+        contents.update = de_Update(data.update, context);
     }
     return contents;
 };
-const deserializeAws_restJson1UpdateClusterConfigCommandError = async (output, context) => {
+const de_UpdateClusterConfigCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2241,22 +2225,22 @@ const deserializeAws_restJson1UpdateClusterConfigCommandError = async (output, c
     switch (errorCode) {
         case "ClientException":
         case "com.amazonaws.eks#ClientException":
-            throw await deserializeAws_restJson1ClientExceptionResponse(parsedOutput, context);
+            throw await de_ClientExceptionRes(parsedOutput, context);
         case "InvalidParameterException":
         case "com.amazonaws.eks#InvalidParameterException":
-            throw await deserializeAws_restJson1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "InvalidRequestException":
         case "com.amazonaws.eks#InvalidRequestException":
-            throw await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context);
+            throw await de_InvalidRequestExceptionRes(parsedOutput, context);
         case "ResourceInUseException":
         case "com.amazonaws.eks#ResourceInUseException":
-            throw await deserializeAws_restJson1ResourceInUseExceptionResponse(parsedOutput, context);
+            throw await de_ResourceInUseExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.eks#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServerException":
         case "com.amazonaws.eks#ServerException":
-            throw await deserializeAws_restJson1ServerExceptionResponse(parsedOutput, context);
+            throw await de_ServerExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2267,20 +2251,20 @@ const deserializeAws_restJson1UpdateClusterConfigCommandError = async (output, c
             });
     }
 };
-export const deserializeAws_restJson1UpdateClusterVersionCommand = async (output, context) => {
+export const de_UpdateClusterVersionCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1UpdateClusterVersionCommandError(output, context);
+        return de_UpdateClusterVersionCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.update != null) {
-        contents.update = deserializeAws_restJson1Update(data.update, context);
+        contents.update = de_Update(data.update, context);
     }
     return contents;
 };
-const deserializeAws_restJson1UpdateClusterVersionCommandError = async (output, context) => {
+const de_UpdateClusterVersionCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2289,22 +2273,22 @@ const deserializeAws_restJson1UpdateClusterVersionCommandError = async (output,
     switch (errorCode) {
         case "ClientException":
         case "com.amazonaws.eks#ClientException":
-            throw await deserializeAws_restJson1ClientExceptionResponse(parsedOutput, context);
+            throw await de_ClientExceptionRes(parsedOutput, context);
         case "InvalidParameterException":
         case "com.amazonaws.eks#InvalidParameterException":
-            throw await deserializeAws_restJson1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "InvalidRequestException":
         case "com.amazonaws.eks#InvalidRequestException":
-            throw await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context);
+            throw await de_InvalidRequestExceptionRes(parsedOutput, context);
         case "ResourceInUseException":
         case "com.amazonaws.eks#ResourceInUseException":
-            throw await deserializeAws_restJson1ResourceInUseExceptionResponse(parsedOutput, context);
+            throw await de_ResourceInUseExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.eks#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServerException":
         case "com.amazonaws.eks#ServerException":
-            throw await deserializeAws_restJson1ServerExceptionResponse(parsedOutput, context);
+            throw await de_ServerExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2315,20 +2299,20 @@ const deserializeAws_restJson1UpdateClusterVersionCommandError = async (output,
             });
     }
 };
-export const deserializeAws_restJson1UpdateNodegroupConfigCommand = async (output, context) => {
+export const de_UpdateNodegroupConfigCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1UpdateNodegroupConfigCommandError(output, context);
+        return de_UpdateNodegroupConfigCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.update != null) {
-        contents.update = deserializeAws_restJson1Update(data.update, context);
+        contents.update = de_Update(data.update, context);
     }
     return contents;
 };
-const deserializeAws_restJson1UpdateNodegroupConfigCommandError = async (output, context) => {
+const de_UpdateNodegroupConfigCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2337,22 +2321,22 @@ const deserializeAws_restJson1UpdateNodegroupConfigCommandError = async (output,
     switch (errorCode) {
         case "ClientException":
         case "com.amazonaws.eks#ClientException":
-            throw await deserializeAws_restJson1ClientExceptionResponse(parsedOutput, context);
+            throw await de_ClientExceptionRes(parsedOutput, context);
         case "InvalidParameterException":
         case "com.amazonaws.eks#InvalidParameterException":
-            throw await deserializeAws_restJson1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "InvalidRequestException":
         case "com.amazonaws.eks#InvalidRequestException":
-            throw await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context);
+            throw await de_InvalidRequestExceptionRes(parsedOutput, context);
         case "ResourceInUseException":
         case "com.amazonaws.eks#ResourceInUseException":
-            throw await deserializeAws_restJson1ResourceInUseExceptionResponse(parsedOutput, context);
+            throw await de_ResourceInUseExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.eks#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServerException":
         case "com.amazonaws.eks#ServerException":
-            throw await deserializeAws_restJson1ServerExceptionResponse(parsedOutput, context);
+            throw await de_ServerExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2363,20 +2347,20 @@ const deserializeAws_restJson1UpdateNodegroupConfigCommandError = async (output,
             });
     }
 };
-export const deserializeAws_restJson1UpdateNodegroupVersionCommand = async (output, context) => {
+export const de_UpdateNodegroupVersionCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1UpdateNodegroupVersionCommandError(output, context);
+        return de_UpdateNodegroupVersionCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.update != null) {
-        contents.update = deserializeAws_restJson1Update(data.update, context);
+        contents.update = de_Update(data.update, context);
     }
     return contents;
 };
-const deserializeAws_restJson1UpdateNodegroupVersionCommandError = async (output, context) => {
+const de_UpdateNodegroupVersionCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2385,22 +2369,22 @@ const deserializeAws_restJson1UpdateNodegroupVersionCommandError = async (output
     switch (errorCode) {
         case "ClientException":
         case "com.amazonaws.eks#ClientException":
-            throw await deserializeAws_restJson1ClientExceptionResponse(parsedOutput, context);
+            throw await de_ClientExceptionRes(parsedOutput, context);
         case "InvalidParameterException":
         case "com.amazonaws.eks#InvalidParameterException":
-            throw await deserializeAws_restJson1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "InvalidRequestException":
         case "com.amazonaws.eks#InvalidRequestException":
-            throw await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context);
+            throw await de_InvalidRequestExceptionRes(parsedOutput, context);
         case "ResourceInUseException":
         case "com.amazonaws.eks#ResourceInUseException":
-            throw await deserializeAws_restJson1ResourceInUseExceptionResponse(parsedOutput, context);
+            throw await de_ResourceInUseExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.eks#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServerException":
         case "com.amazonaws.eks#ServerException":
-            throw await deserializeAws_restJson1ServerExceptionResponse(parsedOutput, context);
+            throw await de_ServerExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2412,7 +2396,7 @@ const deserializeAws_restJson1UpdateNodegroupVersionCommandError = async (output
     }
 };
 const map = __map;
-const deserializeAws_restJson1AccessDeniedExceptionResponse = async (parsedOutput, context) => {
+const de_AccessDeniedExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     if (data.message != null) {
@@ -2424,7 +2408,7 @@ const deserializeAws_restJson1AccessDeniedExceptionResponse = async (parsedOutpu
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const deserializeAws_restJson1BadRequestExceptionResponse = async (parsedOutput, context) => {
+const de_BadRequestExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     if (data.message != null) {
@@ -2436,7 +2420,7 @@ const deserializeAws_restJson1BadRequestExceptionResponse = async (parsedOutput,
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const deserializeAws_restJson1ClientExceptionResponse = async (parsedOutput, context) => {
+const de_ClientExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     if (data.addonName != null) {
@@ -2457,7 +2441,7 @@ const deserializeAws_restJson1ClientExceptionResponse = async (parsedOutput, con
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const deserializeAws_restJson1InvalidParameterExceptionResponse = async (parsedOutput, context) => {
+const de_InvalidParameterExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     if (data.addonName != null) {
@@ -2481,7 +2465,7 @@ const deserializeAws_restJson1InvalidParameterExceptionResponse = async (parsedO
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const deserializeAws_restJson1InvalidRequestExceptionResponse = async (parsedOutput, context) => {
+const de_InvalidRequestExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     if (data.addonName != null) {
@@ -2502,7 +2486,7 @@ const deserializeAws_restJson1InvalidRequestExceptionResponse = async (parsedOut
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const deserializeAws_restJson1NotFoundExceptionResponse = async (parsedOutput, context) => {
+const de_NotFoundExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     if (data.message != null) {
@@ -2514,7 +2498,7 @@ const deserializeAws_restJson1NotFoundExceptionResponse = async (parsedOutput, c
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const deserializeAws_restJson1ResourceInUseExceptionResponse = async (parsedOutput, context) => {
+const de_ResourceInUseExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     if (data.addonName != null) {
@@ -2535,7 +2519,7 @@ const deserializeAws_restJson1ResourceInUseExceptionResponse = async (parsedOutp
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const deserializeAws_restJson1ResourceLimitExceededExceptionResponse = async (parsedOutput, context) => {
+const de_ResourceLimitExceededExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     if (data.clusterName != null) {
@@ -2553,7 +2537,7 @@ const deserializeAws_restJson1ResourceLimitExceededExceptionResponse = async (pa
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const deserializeAws_restJson1ResourceNotFoundExceptionResponse = async (parsedOutput, context) => {
+const de_ResourceNotFoundExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     if (data.addonName != null) {
@@ -2577,7 +2561,7 @@ const deserializeAws_restJson1ResourceNotFoundExceptionResponse = async (parsedO
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const deserializeAws_restJson1ResourcePropagationDelayExceptionResponse = async (parsedOutput, context) => {
+const de_ResourcePropagationDelayExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     if (data.message != null) {
@@ -2589,7 +2573,7 @@ const deserializeAws_restJson1ResourcePropagationDelayExceptionResponse = async
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const deserializeAws_restJson1ServerExceptionResponse = async (parsedOutput, context) => {
+const de_ServerExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     if (data.addonName != null) {
@@ -2610,7 +2594,7 @@ const deserializeAws_restJson1ServerExceptionResponse = async (parsedOutput, con
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const deserializeAws_restJson1ServiceUnavailableExceptionResponse = async (parsedOutput, context) => {
+const de_ServiceUnavailableExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     if (data.message != null) {
@@ -2622,7 +2606,7 @@ const deserializeAws_restJson1ServiceUnavailableExceptionResponse = async (parse
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const deserializeAws_restJson1UnsupportedAvailabilityZoneExceptionResponse = async (parsedOutput, context) => {
+const de_UnsupportedAvailabilityZoneExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     if (data.clusterName != null) {
@@ -2635,7 +2619,7 @@ const deserializeAws_restJson1UnsupportedAvailabilityZoneExceptionResponse = asy
         contents.nodegroupName = __expectString(data.nodegroupName);
     }
     if (data.validZones != null) {
-        contents.validZones = deserializeAws_restJson1StringList(data.validZones, context);
+        contents.validZones = de_StringList(data.validZones, context);
     }
     const exception = new UnsupportedAvailabilityZoneException({
         $metadata: deserializeMetadata(parsedOutput),
@@ -2643,31 +2627,31 @@ const deserializeAws_restJson1UnsupportedAvailabilityZoneExceptionResponse = asy
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const serializeAws_restJson1ConnectorConfigRequest = (input, context) => {
+const se_ConnectorConfigRequest = (input, context) => {
     return {
         ...(input.provider != null && { provider: input.provider }),
         ...(input.roleArn != null && { roleArn: input.roleArn }),
     };
 };
-const serializeAws_restJson1ControlPlanePlacementRequest = (input, context) => {
+const se_ControlPlanePlacementRequest = (input, context) => {
     return {
         ...(input.groupName != null && { groupName: input.groupName }),
     };
 };
-const serializeAws_restJson1EncryptionConfig = (input, context) => {
+const se_EncryptionConfig = (input, context) => {
     return {
-        ...(input.provider != null && { provider: serializeAws_restJson1Provider(input.provider, context) }),
-        ...(input.resources != null && { resources: serializeAws_restJson1StringList(input.resources, context) }),
+        ...(input.provider != null && { provider: se_Provider(input.provider, context) }),
+        ...(input.resources != null && { resources: se_StringList(input.resources, context) }),
     };
 };
-const serializeAws_restJson1EncryptionConfigList = (input, context) => {
+const se_EncryptionConfigList = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
-        return serializeAws_restJson1EncryptionConfig(entry, context);
+        return se_EncryptionConfig(entry, context);
     });
 };
-const serializeAws_restJson1FargateProfileLabel = (input, context) => {
+const se_FargateProfileLabel = (input, context) => {
     return Object.entries(input).reduce((acc, [key, value]) => {
         if (value === null) {
             return acc;
@@ -2676,39 +2660,39 @@ const serializeAws_restJson1FargateProfileLabel = (input, context) => {
         return acc;
     }, {});
 };
-const serializeAws_restJson1FargateProfileSelector = (input, context) => {
+const se_FargateProfileSelector = (input, context) => {
     return {
-        ...(input.labels != null && { labels: serializeAws_restJson1FargateProfileLabel(input.labels, context) }),
+        ...(input.labels != null && { labels: se_FargateProfileLabel(input.labels, context) }),
         ...(input.namespace != null && { namespace: input.namespace }),
     };
 };
-const serializeAws_restJson1FargateProfileSelectors = (input, context) => {
+const se_FargateProfileSelectors = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
-        return serializeAws_restJson1FargateProfileSelector(entry, context);
+        return se_FargateProfileSelector(entry, context);
     });
 };
-const serializeAws_restJson1IdentityProviderConfig = (input, context) => {
+const se_IdentityProviderConfig = (input, context) => {
     return {
         ...(input.name != null && { name: input.name }),
         ...(input.type != null && { type: input.type }),
     };
 };
-const serializeAws_restJson1KubernetesNetworkConfigRequest = (input, context) => {
+const se_KubernetesNetworkConfigRequest = (input, context) => {
     return {
         ...(input.ipFamily != null && { ipFamily: input.ipFamily }),
         ...(input.serviceIpv4Cidr != null && { serviceIpv4Cidr: input.serviceIpv4Cidr }),
     };
 };
-const serializeAws_restJson1labelsKeyList = (input, context) => {
+const se_labelsKeyList = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
         return entry;
     });
 };
-const serializeAws_restJson1labelsMap = (input, context) => {
+const se_labelsMap = (input, context) => {
     return Object.entries(input).reduce((acc, [key, value]) => {
         if (value === null) {
             return acc;
@@ -2717,90 +2701,86 @@ const serializeAws_restJson1labelsMap = (input, context) => {
         return acc;
     }, {});
 };
-const serializeAws_restJson1LaunchTemplateSpecification = (input, context) => {
+const se_LaunchTemplateSpecification = (input, context) => {
     return {
         ...(input.id != null && { id: input.id }),
         ...(input.name != null && { name: input.name }),
         ...(input.version != null && { version: input.version }),
     };
 };
-const serializeAws_restJson1Logging = (input, context) => {
+const se_Logging = (input, context) => {
     return {
-        ...(input.clusterLogging != null && {
-            clusterLogging: serializeAws_restJson1LogSetups(input.clusterLogging, context),
-        }),
+        ...(input.clusterLogging != null && { clusterLogging: se_LogSetups(input.clusterLogging, context) }),
     };
 };
-const serializeAws_restJson1LogSetup = (input, context) => {
+const se_LogSetup = (input, context) => {
     return {
         ...(input.enabled != null && { enabled: input.enabled }),
-        ...(input.types != null && { types: serializeAws_restJson1LogTypes(input.types, context) }),
+        ...(input.types != null && { types: se_LogTypes(input.types, context) }),
     };
 };
-const serializeAws_restJson1LogSetups = (input, context) => {
+const se_LogSetups = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
-        return serializeAws_restJson1LogSetup(entry, context);
+        return se_LogSetup(entry, context);
     });
 };
-const serializeAws_restJson1LogTypes = (input, context) => {
+const se_LogTypes = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
         return entry;
     });
 };
-const serializeAws_restJson1NodegroupScalingConfig = (input, context) => {
+const se_NodegroupScalingConfig = (input, context) => {
     return {
         ...(input.desiredSize != null && { desiredSize: input.desiredSize }),
         ...(input.maxSize != null && { maxSize: input.maxSize }),
         ...(input.minSize != null && { minSize: input.minSize }),
     };
 };
-const serializeAws_restJson1NodegroupUpdateConfig = (input, context) => {
+const se_NodegroupUpdateConfig = (input, context) => {
     return {
         ...(input.maxUnavailable != null && { maxUnavailable: input.maxUnavailable }),
         ...(input.maxUnavailablePercentage != null && { maxUnavailablePercentage: input.maxUnavailablePercentage }),
     };
 };
-const serializeAws_restJson1OidcIdentityProviderConfigRequest = (input, context) => {
+const se_OidcIdentityProviderConfigRequest = (input, context) => {
     return {
         ...(input.clientId != null && { clientId: input.clientId }),
         ...(input.groupsClaim != null && { groupsClaim: input.groupsClaim }),
         ...(input.groupsPrefix != null && { groupsPrefix: input.groupsPrefix }),
         ...(input.identityProviderConfigName != null && { identityProviderConfigName: input.identityProviderConfigName }),
         ...(input.issuerUrl != null && { issuerUrl: input.issuerUrl }),
-        ...(input.requiredClaims != null && {
-            requiredClaims: serializeAws_restJson1requiredClaimsMap(input.requiredClaims, context),
-        }),
+        ...(input.requiredClaims != null && { requiredClaims: se_requiredClaimsMap(input.requiredClaims, context) }),
         ...(input.usernameClaim != null && { usernameClaim: input.usernameClaim }),
         ...(input.usernamePrefix != null && { usernamePrefix: input.usernamePrefix }),
     };
 };
-const serializeAws_restJson1OutpostConfigRequest = (input, context) => {
+const se_OutpostConfigRequest = (input, context) => {
     return {
         ...(input.controlPlaneInstanceType != null && { controlPlaneInstanceType: input.controlPlaneInstanceType }),
         ...(input.controlPlanePlacement != null && {
-            controlPlanePlacement: serializeAws_restJson1ControlPlanePlacementRequest(input.controlPlanePlacement, context),
+            controlPlanePlacement: se_ControlPlanePlacementRequest(input.controlPlanePlacement, context),
         }),
-        ...(input.outpostArns != null && { outpostArns: serializeAws_restJson1StringList(input.outpostArns, context) }),
+        ...(input.outpostArns != null && { outpostArns: se_StringList(input.outpostArns, context) }),
     };
 };
-const serializeAws_restJson1Provider = (input, context) => {
+const se_Provider = (input, context) => {
     return {
         ...(input.keyArn != null && { keyArn: input.keyArn }),
     };
 };
-const serializeAws_restJson1RemoteAccessConfig = (input, context) => {
+const se_RemoteAccessConfig = (input, context) => {
     return {
         ...(input.ec2SshKey != null && { ec2SshKey: input.ec2SshKey }),
         ...(input.sourceSecurityGroups != null && {
-            sourceSecurityGroups: serializeAws_restJson1StringList(input.sourceSecurityGroups, context),
+            sourceSecurityGroups: se_StringList(input.sourceSecurityGroups, context),
         }),
     };
 };
-const serializeAws_restJson1requiredClaimsMap = (input, context) => {
+const se_requiredClaimsMap = (input, context) => {
     return Object.entries(input).reduce((acc, [key, value]) => {
         if (value === null) {
             return acc;
@@ -2809,14 +2789,14 @@ const serializeAws_restJson1requiredClaimsMap = (input, context) => {
         return acc;
     }, {});
 };
-const serializeAws_restJson1StringList = (input, context) => {
+const se_StringList = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
         return entry;
     });
 };
-const serializeAws_restJson1TagMap = (input, context) => {
+const se_TagMap = (input, context) => {
     return Object.entries(input).reduce((acc, [key, value]) => {
         if (value === null) {
             return acc;
@@ -2825,52 +2805,42 @@ const serializeAws_restJson1TagMap = (input, context) => {
         return acc;
     }, {});
 };
-const serializeAws_restJson1Taint = (input, context) => {
+const se_Taint = (input, context) => {
     return {
         ...(input.effect != null && { effect: input.effect }),
         ...(input.key != null && { key: input.key }),
         ...(input.value != null && { value: input.value }),
     };
 };
-const serializeAws_restJson1taintsList = (input, context) => {
+const se_taintsList = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
-        return serializeAws_restJson1Taint(entry, context);
+        return se_Taint(entry, context);
     });
 };
-const serializeAws_restJson1UpdateLabelsPayload = (input, context) => {
+const se_UpdateLabelsPayload = (input, context) => {
     return {
-        ...(input.addOrUpdateLabels != null && {
-            addOrUpdateLabels: serializeAws_restJson1labelsMap(input.addOrUpdateLabels, context),
-        }),
-        ...(input.removeLabels != null && {
-            removeLabels: serializeAws_restJson1labelsKeyList(input.removeLabels, context),
-        }),
+        ...(input.addOrUpdateLabels != null && { addOrUpdateLabels: se_labelsMap(input.addOrUpdateLabels, context) }),
+        ...(input.removeLabels != null && { removeLabels: se_labelsKeyList(input.removeLabels, context) }),
     };
 };
-const serializeAws_restJson1UpdateTaintsPayload = (input, context) => {
+const se_UpdateTaintsPayload = (input, context) => {
     return {
-        ...(input.addOrUpdateTaints != null && {
-            addOrUpdateTaints: serializeAws_restJson1taintsList(input.addOrUpdateTaints, context),
-        }),
-        ...(input.removeTaints != null && { removeTaints: serializeAws_restJson1taintsList(input.removeTaints, context) }),
+        ...(input.addOrUpdateTaints != null && { addOrUpdateTaints: se_taintsList(input.addOrUpdateTaints, context) }),
+        ...(input.removeTaints != null && { removeTaints: se_taintsList(input.removeTaints, context) }),
     };
 };
-const serializeAws_restJson1VpcConfigRequest = (input, context) => {
+const se_VpcConfigRequest = (input, context) => {
     return {
         ...(input.endpointPrivateAccess != null && { endpointPrivateAccess: input.endpointPrivateAccess }),
         ...(input.endpointPublicAccess != null && { endpointPublicAccess: input.endpointPublicAccess }),
-        ...(input.publicAccessCidrs != null && {
-            publicAccessCidrs: serializeAws_restJson1StringList(input.publicAccessCidrs, context),
-        }),
-        ...(input.securityGroupIds != null && {
-            securityGroupIds: serializeAws_restJson1StringList(input.securityGroupIds, context),
-        }),
-        ...(input.subnetIds != null && { subnetIds: serializeAws_restJson1StringList(input.subnetIds, context) }),
+        ...(input.publicAccessCidrs != null && { publicAccessCidrs: se_StringList(input.publicAccessCidrs, context) }),
+        ...(input.securityGroupIds != null && { securityGroupIds: se_StringList(input.securityGroupIds, context) }),
+        ...(input.subnetIds != null && { subnetIds: se_StringList(input.subnetIds, context) }),
     };
 };
-const deserializeAws_restJson1Addon = (output, context) => {
+const de_Addon = (output, context) => {
     return {
         addonArn: __expectString(output.addonArn),
         addonName: __expectString(output.addonName),
@@ -2878,188 +2848,172 @@ const deserializeAws_restJson1Addon = (output, context) => {
         clusterName: __expectString(output.clusterName),
         configurationValues: __expectString(output.configurationValues),
         createdAt: output.createdAt != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.createdAt))) : undefined,
-        health: output.health != null ? deserializeAws_restJson1AddonHealth(output.health, context) : undefined,
+        health: output.health != null ? de_AddonHealth(output.health, context) : undefined,
         marketplaceInformation: output.marketplaceInformation != null
-            ? deserializeAws_restJson1MarketplaceInformation(output.marketplaceInformation, context)
+            ? de_MarketplaceInformation(output.marketplaceInformation, context)
             : undefined,
         modifiedAt: output.modifiedAt != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.modifiedAt))) : undefined,
         owner: __expectString(output.owner),
         publisher: __expectString(output.publisher),
         serviceAccountRoleArn: __expectString(output.serviceAccountRoleArn),
         status: __expectString(output.status),
-        tags: output.tags != null ? deserializeAws_restJson1TagMap(output.tags, context) : undefined,
+        tags: output.tags != null ? de_TagMap(output.tags, context) : undefined,
     };
 };
-const deserializeAws_restJson1AddonHealth = (output, context) => {
+const de_AddonHealth = (output, context) => {
     return {
-        issues: output.issues != null ? deserializeAws_restJson1AddonIssueList(output.issues, context) : undefined,
+        issues: output.issues != null ? de_AddonIssueList(output.issues, context) : undefined,
     };
 };
-const deserializeAws_restJson1AddonInfo = (output, context) => {
+const de_AddonInfo = (output, context) => {
     return {
         addonName: __expectString(output.addonName),
-        addonVersions: output.addonVersions != null
-            ? deserializeAws_restJson1AddonVersionInfoList(output.addonVersions, context)
-            : undefined,
+        addonVersions: output.addonVersions != null ? de_AddonVersionInfoList(output.addonVersions, context) : undefined,
         marketplaceInformation: output.marketplaceInformation != null
-            ? deserializeAws_restJson1MarketplaceInformation(output.marketplaceInformation, context)
+            ? de_MarketplaceInformation(output.marketplaceInformation, context)
             : undefined,
         owner: __expectString(output.owner),
         publisher: __expectString(output.publisher),
         type: __expectString(output.type),
     };
 };
-const deserializeAws_restJson1AddonIssue = (output, context) => {
+const de_AddonIssue = (output, context) => {
     return {
         code: __expectString(output.code),
         message: __expectString(output.message),
-        resourceIds: output.resourceIds != null ? deserializeAws_restJson1StringList(output.resourceIds, context) : undefined,
+        resourceIds: output.resourceIds != null ? de_StringList(output.resourceIds, context) : undefined,
     };
 };
-const deserializeAws_restJson1AddonIssueList = (output, context) => {
+const de_AddonIssueList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1AddonIssue(entry, context);
+        return de_AddonIssue(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1Addons = (output, context) => {
+const de_Addons = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1AddonInfo(entry, context);
+        return de_AddonInfo(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1AddonVersionInfo = (output, context) => {
+const de_AddonVersionInfo = (output, context) => {
     return {
         addonVersion: __expectString(output.addonVersion),
-        architecture: output.architecture != null ? deserializeAws_restJson1StringList(output.architecture, context) : undefined,
-        compatibilities: output.compatibilities != null
-            ? deserializeAws_restJson1Compatibilities(output.compatibilities, context)
-            : undefined,
+        architecture: output.architecture != null ? de_StringList(output.architecture, context) : undefined,
+        compatibilities: output.compatibilities != null ? de_Compatibilities(output.compatibilities, context) : undefined,
         requiresConfiguration: __expectBoolean(output.requiresConfiguration),
     };
 };
-const deserializeAws_restJson1AddonVersionInfoList = (output, context) => {
+const de_AddonVersionInfoList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1AddonVersionInfo(entry, context);
+        return de_AddonVersionInfo(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1AutoScalingGroup = (output, context) => {
+const de_AutoScalingGroup = (output, context) => {
     return {
         name: __expectString(output.name),
     };
 };
-const deserializeAws_restJson1AutoScalingGroupList = (output, context) => {
+const de_AutoScalingGroupList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1AutoScalingGroup(entry, context);
+        return de_AutoScalingGroup(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1Certificate = (output, context) => {
+const de_Certificate = (output, context) => {
     return {
         data: __expectString(output.data),
     };
 };
-const deserializeAws_restJson1Cluster = (output, context) => {
+const de_Cluster = (output, context) => {
     return {
         arn: __expectString(output.arn),
-        certificateAuthority: output.certificateAuthority != null
-            ? deserializeAws_restJson1Certificate(output.certificateAuthority, context)
-            : undefined,
+        certificateAuthority: output.certificateAuthority != null ? de_Certificate(output.certificateAuthority, context) : undefined,
         clientRequestToken: __expectString(output.clientRequestToken),
-        connectorConfig: output.connectorConfig != null
-            ? deserializeAws_restJson1ConnectorConfigResponse(output.connectorConfig, context)
-            : undefined,
+        connectorConfig: output.connectorConfig != null ? de_ConnectorConfigResponse(output.connectorConfig, context) : undefined,
         createdAt: output.createdAt != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.createdAt))) : undefined,
-        encryptionConfig: output.encryptionConfig != null
-            ? deserializeAws_restJson1EncryptionConfigList(output.encryptionConfig, context)
-            : undefined,
+        encryptionConfig: output.encryptionConfig != null ? de_EncryptionConfigList(output.encryptionConfig, context) : undefined,
         endpoint: __expectString(output.endpoint),
-        health: output.health != null ? deserializeAws_restJson1ClusterHealth(output.health, context) : undefined,
+        health: output.health != null ? de_ClusterHealth(output.health, context) : undefined,
         id: __expectString(output.id),
-        identity: output.identity != null ? deserializeAws_restJson1Identity(output.identity, context) : undefined,
+        identity: output.identity != null ? de_Identity(output.identity, context) : undefined,
         kubernetesNetworkConfig: output.kubernetesNetworkConfig != null
-            ? deserializeAws_restJson1KubernetesNetworkConfigResponse(output.kubernetesNetworkConfig, context)
+            ? de_KubernetesNetworkConfigResponse(output.kubernetesNetworkConfig, context)
             : undefined,
-        logging: output.logging != null ? deserializeAws_restJson1Logging(output.logging, context) : undefined,
+        logging: output.logging != null ? de_Logging(output.logging, context) : undefined,
         name: __expectString(output.name),
-        outpostConfig: output.outpostConfig != null
-            ? deserializeAws_restJson1OutpostConfigResponse(output.outpostConfig, context)
-            : undefined,
+        outpostConfig: output.outpostConfig != null ? de_OutpostConfigResponse(output.outpostConfig, context) : undefined,
         platformVersion: __expectString(output.platformVersion),
-        resourcesVpcConfig: output.resourcesVpcConfig != null
-            ? deserializeAws_restJson1VpcConfigResponse(output.resourcesVpcConfig, context)
-            : undefined,
+        resourcesVpcConfig: output.resourcesVpcConfig != null ? de_VpcConfigResponse(output.resourcesVpcConfig, context) : undefined,
         roleArn: __expectString(output.roleArn),
         status: __expectString(output.status),
-        tags: output.tags != null ? deserializeAws_restJson1TagMap(output.tags, context) : undefined,
+        tags: output.tags != null ? de_TagMap(output.tags, context) : undefined,
         version: __expectString(output.version),
     };
 };
-const deserializeAws_restJson1ClusterHealth = (output, context) => {
+const de_ClusterHealth = (output, context) => {
     return {
-        issues: output.issues != null ? deserializeAws_restJson1ClusterIssueList(output.issues, context) : undefined,
+        issues: output.issues != null ? de_ClusterIssueList(output.issues, context) : undefined,
     };
 };
-const deserializeAws_restJson1ClusterIssue = (output, context) => {
+const de_ClusterIssue = (output, context) => {
     return {
         code: __expectString(output.code),
         message: __expectString(output.message),
-        resourceIds: output.resourceIds != null ? deserializeAws_restJson1StringList(output.resourceIds, context) : undefined,
+        resourceIds: output.resourceIds != null ? de_StringList(output.resourceIds, context) : undefined,
     };
 };
-const deserializeAws_restJson1ClusterIssueList = (output, context) => {
+const de_ClusterIssueList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1ClusterIssue(entry, context);
+        return de_ClusterIssue(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1Compatibilities = (output, context) => {
+const de_Compatibilities = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1Compatibility(entry, context);
+        return de_Compatibility(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1Compatibility = (output, context) => {
+const de_Compatibility = (output, context) => {
     return {
         clusterVersion: __expectString(output.clusterVersion),
         defaultVersion: __expectBoolean(output.defaultVersion),
-        platformVersions: output.platformVersions != null
-            ? deserializeAws_restJson1StringList(output.platformVersions, context)
-            : undefined,
+        platformVersions: output.platformVersions != null ? de_StringList(output.platformVersions, context) : undefined,
     };
 };
-const deserializeAws_restJson1ConnectorConfigResponse = (output, context) => {
+const de_ConnectorConfigResponse = (output, context) => {
     return {
         activationCode: __expectString(output.activationCode),
         activationExpiry: output.activationExpiry != null
@@ -3070,60 +3024,60 @@ const deserializeAws_restJson1ConnectorConfigResponse = (output, context) => {
         roleArn: __expectString(output.roleArn),
     };
 };
-const deserializeAws_restJson1ControlPlanePlacementResponse = (output, context) => {
+const de_ControlPlanePlacementResponse = (output, context) => {
     return {
         groupName: __expectString(output.groupName),
     };
 };
-const deserializeAws_restJson1EncryptionConfig = (output, context) => {
+const de_EncryptionConfig = (output, context) => {
     return {
-        provider: output.provider != null ? deserializeAws_restJson1Provider(output.provider, context) : undefined,
-        resources: output.resources != null ? deserializeAws_restJson1StringList(output.resources, context) : undefined,
+        provider: output.provider != null ? de_Provider(output.provider, context) : undefined,
+        resources: output.resources != null ? de_StringList(output.resources, context) : undefined,
     };
 };
-const deserializeAws_restJson1EncryptionConfigList = (output, context) => {
+const de_EncryptionConfigList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1EncryptionConfig(entry, context);
+        return de_EncryptionConfig(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1ErrorDetail = (output, context) => {
+const de_ErrorDetail = (output, context) => {
     return {
         errorCode: __expectString(output.errorCode),
         errorMessage: __expectString(output.errorMessage),
-        resourceIds: output.resourceIds != null ? deserializeAws_restJson1StringList(output.resourceIds, context) : undefined,
+        resourceIds: output.resourceIds != null ? de_StringList(output.resourceIds, context) : undefined,
     };
 };
-const deserializeAws_restJson1ErrorDetails = (output, context) => {
+const de_ErrorDetails = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1ErrorDetail(entry, context);
+        return de_ErrorDetail(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1FargateProfile = (output, context) => {
+const de_FargateProfile = (output, context) => {
     return {
         clusterName: __expectString(output.clusterName),
         createdAt: output.createdAt != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.createdAt))) : undefined,
         fargateProfileArn: __expectString(output.fargateProfileArn),
         fargateProfileName: __expectString(output.fargateProfileName),
         podExecutionRoleArn: __expectString(output.podExecutionRoleArn),
-        selectors: output.selectors != null ? deserializeAws_restJson1FargateProfileSelectors(output.selectors, context) : undefined,
+        selectors: output.selectors != null ? de_FargateProfileSelectors(output.selectors, context) : undefined,
         status: __expectString(output.status),
-        subnets: output.subnets != null ? deserializeAws_restJson1StringList(output.subnets, context) : undefined,
-        tags: output.tags != null ? deserializeAws_restJson1TagMap(output.tags, context) : undefined,
+        subnets: output.subnets != null ? de_StringList(output.subnets, context) : undefined,
+        tags: output.tags != null ? de_TagMap(output.tags, context) : undefined,
     };
 };
-const deserializeAws_restJson1FargateProfileLabel = (output, context) => {
+const de_FargateProfileLabel = (output, context) => {
     return Object.entries(output).reduce((acc, [key, value]) => {
         if (value === null) {
             return acc;
@@ -3132,76 +3086,76 @@ const deserializeAws_restJson1FargateProfileLabel = (output, context) => {
         return acc;
     }, {});
 };
-const deserializeAws_restJson1FargateProfileSelector = (output, context) => {
+const de_FargateProfileSelector = (output, context) => {
     return {
-        labels: output.labels != null ? deserializeAws_restJson1FargateProfileLabel(output.labels, context) : undefined,
+        labels: output.labels != null ? de_FargateProfileLabel(output.labels, context) : undefined,
         namespace: __expectString(output.namespace),
     };
 };
-const deserializeAws_restJson1FargateProfileSelectors = (output, context) => {
+const de_FargateProfileSelectors = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1FargateProfileSelector(entry, context);
+        return de_FargateProfileSelector(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1Identity = (output, context) => {
+const de_Identity = (output, context) => {
     return {
-        oidc: output.oidc != null ? deserializeAws_restJson1OIDC(output.oidc, context) : undefined,
+        oidc: output.oidc != null ? de_OIDC(output.oidc, context) : undefined,
     };
 };
-const deserializeAws_restJson1IdentityProviderConfig = (output, context) => {
+const de_IdentityProviderConfig = (output, context) => {
     return {
         name: __expectString(output.name),
         type: __expectString(output.type),
     };
 };
-const deserializeAws_restJson1IdentityProviderConfigResponse = (output, context) => {
+const de_IdentityProviderConfigResponse = (output, context) => {
     return {
-        oidc: output.oidc != null ? deserializeAws_restJson1OidcIdentityProviderConfig(output.oidc, context) : undefined,
+        oidc: output.oidc != null ? de_OidcIdentityProviderConfig(output.oidc, context) : undefined,
     };
 };
-const deserializeAws_restJson1IdentityProviderConfigs = (output, context) => {
+const de_IdentityProviderConfigs = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1IdentityProviderConfig(entry, context);
+        return de_IdentityProviderConfig(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1Issue = (output, context) => {
+const de_Issue = (output, context) => {
     return {
         code: __expectString(output.code),
         message: __expectString(output.message),
-        resourceIds: output.resourceIds != null ? deserializeAws_restJson1StringList(output.resourceIds, context) : undefined,
+        resourceIds: output.resourceIds != null ? de_StringList(output.resourceIds, context) : undefined,
     };
 };
-const deserializeAws_restJson1IssueList = (output, context) => {
+const de_IssueList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1Issue(entry, context);
+        return de_Issue(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1KubernetesNetworkConfigResponse = (output, context) => {
+const de_KubernetesNetworkConfigResponse = (output, context) => {
     return {
         ipFamily: __expectString(output.ipFamily),
         serviceIpv4Cidr: __expectString(output.serviceIpv4Cidr),
         serviceIpv6Cidr: __expectString(output.serviceIpv6Cidr),
     };
 };
-const deserializeAws_restJson1labelsMap = (output, context) => {
+const de_labelsMap = (output, context) => {
     return Object.entries(output).reduce((acc, [key, value]) => {
         if (value === null) {
             return acc;
@@ -3210,36 +3164,36 @@ const deserializeAws_restJson1labelsMap = (output, context) => {
         return acc;
     }, {});
 };
-const deserializeAws_restJson1LaunchTemplateSpecification = (output, context) => {
+const de_LaunchTemplateSpecification = (output, context) => {
     return {
         id: __expectString(output.id),
         name: __expectString(output.name),
         version: __expectString(output.version),
     };
 };
-const deserializeAws_restJson1Logging = (output, context) => {
+const de_Logging = (output, context) => {
     return {
-        clusterLogging: output.clusterLogging != null ? deserializeAws_restJson1LogSetups(output.clusterLogging, context) : undefined,
+        clusterLogging: output.clusterLogging != null ? de_LogSetups(output.clusterLogging, context) : undefined,
     };
 };
-const deserializeAws_restJson1LogSetup = (output, context) => {
+const de_LogSetup = (output, context) => {
     return {
         enabled: __expectBoolean(output.enabled),
-        types: output.types != null ? deserializeAws_restJson1LogTypes(output.types, context) : undefined,
+        types: output.types != null ? de_LogTypes(output.types, context) : undefined,
     };
 };
-const deserializeAws_restJson1LogSetups = (output, context) => {
+const de_LogSetups = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1LogSetup(entry, context);
+        return de_LogSetup(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1LogTypes = (output, context) => {
+const de_LogTypes = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
@@ -3250,79 +3204,69 @@ const deserializeAws_restJson1LogTypes = (output, context) => {
     });
     return retVal;
 };
-const deserializeAws_restJson1MarketplaceInformation = (output, context) => {
+const de_MarketplaceInformation = (output, context) => {
     return {
         productId: __expectString(output.productId),
         productUrl: __expectString(output.productUrl),
     };
 };
-const deserializeAws_restJson1Nodegroup = (output, context) => {
+const de_Nodegroup = (output, context) => {
     return {
         amiType: __expectString(output.amiType),
         capacityType: __expectString(output.capacityType),
         clusterName: __expectString(output.clusterName),
         createdAt: output.createdAt != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.createdAt))) : undefined,
         diskSize: __expectInt32(output.diskSize),
-        health: output.health != null ? deserializeAws_restJson1NodegroupHealth(output.health, context) : undefined,
-        instanceTypes: output.instanceTypes != null ? deserializeAws_restJson1StringList(output.instanceTypes, context) : undefined,
-        labels: output.labels != null ? deserializeAws_restJson1labelsMap(output.labels, context) : undefined,
-        launchTemplate: output.launchTemplate != null
-            ? deserializeAws_restJson1LaunchTemplateSpecification(output.launchTemplate, context)
-            : undefined,
+        health: output.health != null ? de_NodegroupHealth(output.health, context) : undefined,
+        instanceTypes: output.instanceTypes != null ? de_StringList(output.instanceTypes, context) : undefined,
+        labels: output.labels != null ? de_labelsMap(output.labels, context) : undefined,
+        launchTemplate: output.launchTemplate != null ? de_LaunchTemplateSpecification(output.launchTemplate, context) : undefined,
         modifiedAt: output.modifiedAt != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.modifiedAt))) : undefined,
         nodeRole: __expectString(output.nodeRole),
         nodegroupArn: __expectString(output.nodegroupArn),
         nodegroupName: __expectString(output.nodegroupName),
         releaseVersion: __expectString(output.releaseVersion),
-        remoteAccess: output.remoteAccess != null
-            ? deserializeAws_restJson1RemoteAccessConfig(output.remoteAccess, context)
-            : undefined,
-        resources: output.resources != null ? deserializeAws_restJson1NodegroupResources(output.resources, context) : undefined,
-        scalingConfig: output.scalingConfig != null
-            ? deserializeAws_restJson1NodegroupScalingConfig(output.scalingConfig, context)
-            : undefined,
+        remoteAccess: output.remoteAccess != null ? de_RemoteAccessConfig(output.remoteAccess, context) : undefined,
+        resources: output.resources != null ? de_NodegroupResources(output.resources, context) : undefined,
+        scalingConfig: output.scalingConfig != null ? de_NodegroupScalingConfig(output.scalingConfig, context) : undefined,
         status: __expectString(output.status),
-        subnets: output.subnets != null ? deserializeAws_restJson1StringList(output.subnets, context) : undefined,
-        tags: output.tags != null ? deserializeAws_restJson1TagMap(output.tags, context) : undefined,
-        taints: output.taints != null ? deserializeAws_restJson1taintsList(output.taints, context) : undefined,
-        updateConfig: output.updateConfig != null
-            ? deserializeAws_restJson1NodegroupUpdateConfig(output.updateConfig, context)
-            : undefined,
+        subnets: output.subnets != null ? de_StringList(output.subnets, context) : undefined,
+        tags: output.tags != null ? de_TagMap(output.tags, context) : undefined,
+        taints: output.taints != null ? de_taintsList(output.taints, context) : undefined,
+        updateConfig: output.updateConfig != null ? de_NodegroupUpdateConfig(output.updateConfig, context) : undefined,
         version: __expectString(output.version),
     };
 };
-const deserializeAws_restJson1NodegroupHealth = (output, context) => {
+const de_NodegroupHealth = (output, context) => {
     return {
-        issues: output.issues != null ? deserializeAws_restJson1IssueList(output.issues, context) : undefined,
+        issues: output.issues != null ? de_IssueList(output.issues, context) : undefined,
     };
 };
-const deserializeAws_restJson1NodegroupResources = (output, context) => {
+const de_NodegroupResources = (output, context) => {
     return {
-        autoScalingGroups: output.autoScalingGroups != null
-            ? deserializeAws_restJson1AutoScalingGroupList(output.autoScalingGroups, context)
-            : undefined,
+        autoScalingGroups: output.autoScalingGroups != null ? de_AutoScalingGroupList(output.autoScalingGroups, context) : undefined,
         remoteAccessSecurityGroup: __expectString(output.remoteAccessSecurityGroup),
     };
 };
-const deserializeAws_restJson1NodegroupScalingConfig = (output, context) => {
+const de_NodegroupScalingConfig = (output, context) => {
     return {
         desiredSize: __expectInt32(output.desiredSize),
         maxSize: __expectInt32(output.maxSize),
         minSize: __expectInt32(output.minSize),
     };
 };
-const deserializeAws_restJson1NodegroupUpdateConfig = (output, context) => {
+const de_NodegroupUpdateConfig = (output, context) => {
     return {
         maxUnavailable: __expectInt32(output.maxUnavailable),
         maxUnavailablePercentage: __expectInt32(output.maxUnavailablePercentage),
     };
 };
-const deserializeAws_restJson1OIDC = (output, context) => {
+const de_OIDC = (output, context) => {
     return {
         issuer: __expectString(output.issuer),
     };
 };
-const deserializeAws_restJson1OidcIdentityProviderConfig = (output, context) => {
+const de_OidcIdentityProviderConfig = (output, context) => {
     return {
         clientId: __expectString(output.clientId),
         clusterName: __expectString(output.clusterName),
@@ -3331,38 +3275,34 @@ const deserializeAws_restJson1OidcIdentityProviderConfig = (output, context) =>
         identityProviderConfigArn: __expectString(output.identityProviderConfigArn),
         identityProviderConfigName: __expectString(output.identityProviderConfigName),
         issuerUrl: __expectString(output.issuerUrl),
-        requiredClaims: output.requiredClaims != null
-            ? deserializeAws_restJson1requiredClaimsMap(output.requiredClaims, context)
-            : undefined,
+        requiredClaims: output.requiredClaims != null ? de_requiredClaimsMap(output.requiredClaims, context) : undefined,
         status: __expectString(output.status),
-        tags: output.tags != null ? deserializeAws_restJson1TagMap(output.tags, context) : undefined,
+        tags: output.tags != null ? de_TagMap(output.tags, context) : undefined,
         usernameClaim: __expectString(output.usernameClaim),
         usernamePrefix: __expectString(output.usernamePrefix),
     };
 };
-const deserializeAws_restJson1OutpostConfigResponse = (output, context) => {
+const de_OutpostConfigResponse = (output, context) => {
     return {
         controlPlaneInstanceType: __expectString(output.controlPlaneInstanceType),
         controlPlanePlacement: output.controlPlanePlacement != null
-            ? deserializeAws_restJson1ControlPlanePlacementResponse(output.controlPlanePlacement, context)
+            ? de_ControlPlanePlacementResponse(output.controlPlanePlacement, context)
             : undefined,
-        outpostArns: output.outpostArns != null ? deserializeAws_restJson1StringList(output.outpostArns, context) : undefined,
+        outpostArns: output.outpostArns != null ? de_StringList(output.outpostArns, context) : undefined,
     };
 };
-const deserializeAws_restJson1Provider = (output, context) => {
+const de_Provider = (output, context) => {
     return {
         keyArn: __expectString(output.keyArn),
     };
 };
-const deserializeAws_restJson1RemoteAccessConfig = (output, context) => {
+const de_RemoteAccessConfig = (output, context) => {
     return {
         ec2SshKey: __expectString(output.ec2SshKey),
-        sourceSecurityGroups: output.sourceSecurityGroups != null
-            ? deserializeAws_restJson1StringList(output.sourceSecurityGroups, context)
-            : undefined,
+        sourceSecurityGroups: output.sourceSecurityGroups != null ? de_StringList(output.sourceSecurityGroups, context) : undefined,
     };
 };
-const deserializeAws_restJson1requiredClaimsMap = (output, context) => {
+const de_requiredClaimsMap = (output, context) => {
     return Object.entries(output).reduce((acc, [key, value]) => {
         if (value === null) {
             return acc;
@@ -3371,7 +3311,7 @@ const deserializeAws_restJson1requiredClaimsMap = (output, context) => {
         return acc;
     }, {});
 };
-const deserializeAws_restJson1StringList = (output, context) => {
+const de_StringList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
@@ -3382,7 +3322,7 @@ const deserializeAws_restJson1StringList = (output, context) => {
     });
     return retVal;
 };
-const deserializeAws_restJson1TagMap = (output, context) => {
+const de_TagMap = (output, context) => {
     return Object.entries(output).reduce((acc, [key, value]) => {
         if (value === null) {
             return acc;
@@ -3391,63 +3331,59 @@ const deserializeAws_restJson1TagMap = (output, context) => {
         return acc;
     }, {});
 };
-const deserializeAws_restJson1Taint = (output, context) => {
+const de_Taint = (output, context) => {
     return {
         effect: __expectString(output.effect),
         key: __expectString(output.key),
         value: __expectString(output.value),
     };
 };
-const deserializeAws_restJson1taintsList = (output, context) => {
+const de_taintsList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1Taint(entry, context);
+        return de_Taint(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1Update = (output, context) => {
+const de_Update = (output, context) => {
     return {
         createdAt: output.createdAt != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.createdAt))) : undefined,
-        errors: output.errors != null ? deserializeAws_restJson1ErrorDetails(output.errors, context) : undefined,
+        errors: output.errors != null ? de_ErrorDetails(output.errors, context) : undefined,
         id: __expectString(output.id),
-        params: output.params != null ? deserializeAws_restJson1UpdateParams(output.params, context) : undefined,
+        params: output.params != null ? de_UpdateParams(output.params, context) : undefined,
         status: __expectString(output.status),
         type: __expectString(output.type),
     };
 };
-const deserializeAws_restJson1UpdateParam = (output, context) => {
+const de_UpdateParam = (output, context) => {
     return {
         type: __expectString(output.type),
         value: __expectString(output.value),
     };
 };
-const deserializeAws_restJson1UpdateParams = (output, context) => {
+const de_UpdateParams = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1UpdateParam(entry, context);
+        return de_UpdateParam(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1VpcConfigResponse = (output, context) => {
+const de_VpcConfigResponse = (output, context) => {
     return {
         clusterSecurityGroupId: __expectString(output.clusterSecurityGroupId),
         endpointPrivateAccess: __expectBoolean(output.endpointPrivateAccess),
         endpointPublicAccess: __expectBoolean(output.endpointPublicAccess),
-        publicAccessCidrs: output.publicAccessCidrs != null
-            ? deserializeAws_restJson1StringList(output.publicAccessCidrs, context)
-            : undefined,
-        securityGroupIds: output.securityGroupIds != null
-            ? deserializeAws_restJson1StringList(output.securityGroupIds, context)
-            : undefined,
-        subnetIds: output.subnetIds != null ? deserializeAws_restJson1StringList(output.subnetIds, context) : undefined,
+        publicAccessCidrs: output.publicAccessCidrs != null ? de_StringList(output.publicAccessCidrs, context) : undefined,
+        securityGroupIds: output.securityGroupIds != null ? de_StringList(output.securityGroupIds, context) : undefined,
+        subnetIds: output.subnetIds != null ? de_StringList(output.subnetIds, context) : undefined,
         vpcId: __expectString(output.vpcId),
     };
 };