@aws-sdk/client-kafka 3.303.0 → 3.309.0

package/dist-es/protocols/Aws_restJson1.js

@@ -2,7 +2,7 @@ import { HttpRequest as __HttpRequest } from "@aws-sdk/protocol-http";
 import { decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectInt32 as __expectInt32, expectLong as __expectLong, expectNonNull as __expectNonNull, expectObject as __expectObject, expectString as __expectString, limitedParseDouble as __limitedParseDouble, map as __map, parseRfc3339DateTimeWithOffset as __parseRfc3339DateTimeWithOffset, resolvedPath as __resolvedPath, throwDefaultError, } from "@aws-sdk/smithy-client";
 import { KafkaServiceException as __BaseException } from "../models/KafkaServiceException";
 import { BadRequestException, ConflictException, ForbiddenException, InternalServerErrorException, NotFoundException, ServiceUnavailableException, TooManyRequestsException, UnauthorizedException, } from "../models/models_0";
-export const serializeAws_restJson1BatchAssociateScramSecretCommand = async (input, context) => {
+export const se_BatchAssociateScramSecretCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -11,9 +11,7 @@ export const serializeAws_restJson1BatchAssociateScramSecretCommand = async (inp
     resolvedPath = __resolvedPath(resolvedPath, input, "ClusterArn", () => input.ClusterArn, "{ClusterArn}", false);
     let body;
     body = JSON.stringify({
-        ...(input.SecretArnList != null && {
-            secretArnList: serializeAws_restJson1__listOf__string(input.SecretArnList, context),
-        }),
+        ...(input.SecretArnList != null && { secretArnList: se___listOf__string(input.SecretArnList, context) }),
     });
     return new __HttpRequest({
         protocol,
@@ -25,7 +23,7 @@ export const serializeAws_restJson1BatchAssociateScramSecretCommand = async (inp
         body,
     });
 };
-export const serializeAws_restJson1BatchDisassociateScramSecretCommand = async (input, context) => {
+export const se_BatchDisassociateScramSecretCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -34,9 +32,7 @@ export const serializeAws_restJson1BatchDisassociateScramSecretCommand = async (
     resolvedPath = __resolvedPath(resolvedPath, input, "ClusterArn", () => input.ClusterArn, "{ClusterArn}", false);
     let body;
     body = JSON.stringify({
-        ...(input.SecretArnList != null && {
-            secretArnList: serializeAws_restJson1__listOf__string(input.SecretArnList, context),
-        }),
+        ...(input.SecretArnList != null && { secretArnList: se___listOf__string(input.SecretArnList, context) }),
     });
     return new __HttpRequest({
         protocol,
@@ -48,7 +44,7 @@ export const serializeAws_restJson1BatchDisassociateScramSecretCommand = async (
         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",
@@ -57,27 +53,23 @@ export const serializeAws_restJson1CreateClusterCommand = async (input, context)
     let body;
     body = JSON.stringify({
         ...(input.BrokerNodeGroupInfo != null && {
-            brokerNodeGroupInfo: serializeAws_restJson1BrokerNodeGroupInfo(input.BrokerNodeGroupInfo, context),
+            brokerNodeGroupInfo: se_BrokerNodeGroupInfo(input.BrokerNodeGroupInfo, context),
         }),
         ...(input.ClientAuthentication != null && {
-            clientAuthentication: serializeAws_restJson1ClientAuthentication(input.ClientAuthentication, context),
+            clientAuthentication: se_ClientAuthentication(input.ClientAuthentication, context),
         }),
         ...(input.ClusterName != null && { clusterName: input.ClusterName }),
         ...(input.ConfigurationInfo != null && {
-            configurationInfo: serializeAws_restJson1ConfigurationInfo(input.ConfigurationInfo, context),
-        }),
-        ...(input.EncryptionInfo != null && {
-            encryptionInfo: serializeAws_restJson1EncryptionInfo(input.EncryptionInfo, context),
+            configurationInfo: se_ConfigurationInfo(input.ConfigurationInfo, context),
         }),
+        ...(input.EncryptionInfo != null && { encryptionInfo: se_EncryptionInfo(input.EncryptionInfo, context) }),
         ...(input.EnhancedMonitoring != null && { enhancedMonitoring: input.EnhancedMonitoring }),
         ...(input.KafkaVersion != null && { kafkaVersion: input.KafkaVersion }),
-        ...(input.LoggingInfo != null && { loggingInfo: serializeAws_restJson1LoggingInfo(input.LoggingInfo, context) }),
+        ...(input.LoggingInfo != null && { loggingInfo: se_LoggingInfo(input.LoggingInfo, context) }),
         ...(input.NumberOfBrokerNodes != null && { numberOfBrokerNodes: input.NumberOfBrokerNodes }),
-        ...(input.OpenMonitoring != null && {
-            openMonitoring: serializeAws_restJson1OpenMonitoringInfo(input.OpenMonitoring, context),
-        }),
+        ...(input.OpenMonitoring != null && { openMonitoring: se_OpenMonitoringInfo(input.OpenMonitoring, context) }),
         ...(input.StorageMode != null && { storageMode: input.StorageMode }),
-        ...(input.Tags != null && { tags: serializeAws_restJson1__mapOf__string(input.Tags, context) }),
+        ...(input.Tags != null && { tags: se___mapOf__string(input.Tags, context) }),
     });
     return new __HttpRequest({
         protocol,
@@ -89,7 +81,7 @@ export const serializeAws_restJson1CreateClusterCommand = async (input, context)
         body,
     });
 };
-export const serializeAws_restJson1CreateClusterV2Command = async (input, context) => {
+export const se_CreateClusterV2Command = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -98,11 +90,9 @@ export const serializeAws_restJson1CreateClusterV2Command = async (input, contex
     let body;
     body = JSON.stringify({
         ...(input.ClusterName != null && { clusterName: input.ClusterName }),
-        ...(input.Provisioned != null && {
-            provisioned: serializeAws_restJson1ProvisionedRequest(input.Provisioned, context),
-        }),
-        ...(input.Serverless != null && { serverless: serializeAws_restJson1ServerlessRequest(input.Serverless, context) }),
-        ...(input.Tags != null && { tags: serializeAws_restJson1__mapOf__string(input.Tags, context) }),
+        ...(input.Provisioned != null && { provisioned: se_ProvisionedRequest(input.Provisioned, context) }),
+        ...(input.Serverless != null && { serverless: se_ServerlessRequest(input.Serverless, context) }),
+        ...(input.Tags != null && { tags: se___mapOf__string(input.Tags, context) }),
     });
     return new __HttpRequest({
         protocol,
@@ -114,7 +104,7 @@ export const serializeAws_restJson1CreateClusterV2Command = async (input, contex
         body,
     });
 };
-export const serializeAws_restJson1CreateConfigurationCommand = async (input, context) => {
+export const se_CreateConfigurationCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -123,9 +113,7 @@ export const serializeAws_restJson1CreateConfigurationCommand = async (input, co
     let body;
     body = JSON.stringify({
         ...(input.Description != null && { description: input.Description }),
-        ...(input.KafkaVersions != null && {
-            kafkaVersions: serializeAws_restJson1__listOf__string(input.KafkaVersions, context),
-        }),
+        ...(input.KafkaVersions != null && { kafkaVersions: se___listOf__string(input.KafkaVersions, context) }),
         ...(input.Name != null && { name: input.Name }),
         ...(input.ServerProperties != null && { serverProperties: context.base64Encoder(input.ServerProperties) }),
     });
@@ -139,7 +127,7 @@ export const serializeAws_restJson1CreateConfigurationCommand = async (input, co
         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 || ""}` + "/v1/clusters/{ClusterArn}";
@@ -159,7 +147,7 @@ export const serializeAws_restJson1DeleteClusterCommand = async (input, context)
         body,
     });
 };
-export const serializeAws_restJson1DeleteConfigurationCommand = async (input, context) => {
+export const se_DeleteConfigurationCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/configurations/{Arn}";
@@ -175,7 +163,7 @@ export const serializeAws_restJson1DeleteConfigurationCommand = async (input, co
         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 || ""}` + "/v1/clusters/{ClusterArn}";
@@ -191,7 +179,7 @@ export const serializeAws_restJson1DescribeClusterCommand = async (input, contex
         body,
     });
 };
-export const serializeAws_restJson1DescribeClusterOperationCommand = async (input, context) => {
+export const se_DescribeClusterOperationCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/operations/{ClusterOperationArn}";
@@ -207,7 +195,7 @@ export const serializeAws_restJson1DescribeClusterOperationCommand = async (inpu
         body,
     });
 };
-export const serializeAws_restJson1DescribeClusterV2Command = async (input, context) => {
+export const se_DescribeClusterV2Command = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/api/v2/clusters/{ClusterArn}";
@@ -223,7 +211,7 @@ export const serializeAws_restJson1DescribeClusterV2Command = async (input, cont
         body,
     });
 };
-export const serializeAws_restJson1DescribeConfigurationCommand = async (input, context) => {
+export const se_DescribeConfigurationCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/configurations/{Arn}";
@@ -239,7 +227,7 @@ export const serializeAws_restJson1DescribeConfigurationCommand = async (input,
         body,
     });
 };
-export const serializeAws_restJson1DescribeConfigurationRevisionCommand = async (input, context) => {
+export const se_DescribeConfigurationRevisionCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
@@ -257,7 +245,7 @@ export const serializeAws_restJson1DescribeConfigurationRevisionCommand = async
         body,
     });
 };
-export const serializeAws_restJson1GetBootstrapBrokersCommand = async (input, context) => {
+export const se_GetBootstrapBrokersCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
@@ -274,7 +262,7 @@ export const serializeAws_restJson1GetBootstrapBrokersCommand = async (input, co
         body,
     });
 };
-export const serializeAws_restJson1GetCompatibleKafkaVersionsCommand = async (input, context) => {
+export const se_GetCompatibleKafkaVersionsCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/compatible-kafka-versions";
@@ -293,7 +281,7 @@ export const serializeAws_restJson1GetCompatibleKafkaVersionsCommand = async (in
         body,
     });
 };
-export const serializeAws_restJson1ListClusterOperationsCommand = async (input, context) => {
+export const se_ListClusterOperationsCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/clusters/{ClusterArn}/operations";
@@ -314,7 +302,7 @@ export const serializeAws_restJson1ListClusterOperationsCommand = async (input,
         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 || ""}` + "/v1/clusters";
@@ -335,7 +323,7 @@ export const serializeAws_restJson1ListClustersCommand = async (input, context)
         body,
     });
 };
-export const serializeAws_restJson1ListClustersV2Command = async (input, context) => {
+export const se_ListClustersV2Command = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/api/v2/clusters";
@@ -357,7 +345,7 @@ export const serializeAws_restJson1ListClustersV2Command = async (input, context
         body,
     });
 };
-export const serializeAws_restJson1ListConfigurationRevisionsCommand = async (input, context) => {
+export const se_ListConfigurationRevisionsCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/configurations/{Arn}/revisions";
@@ -378,7 +366,7 @@ export const serializeAws_restJson1ListConfigurationRevisionsCommand = async (in
         body,
     });
 };
-export const serializeAws_restJson1ListConfigurationsCommand = async (input, context) => {
+export const se_ListConfigurationsCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/configurations";
@@ -398,7 +386,7 @@ export const serializeAws_restJson1ListConfigurationsCommand = async (input, con
         body,
     });
 };
-export const serializeAws_restJson1ListKafkaVersionsCommand = async (input, context) => {
+export const se_ListKafkaVersionsCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/kafka-versions";
@@ -418,7 +406,7 @@ export const serializeAws_restJson1ListKafkaVersionsCommand = async (input, cont
         body,
     });
 };
-export const serializeAws_restJson1ListNodesCommand = async (input, context) => {
+export const se_ListNodesCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/clusters/{ClusterArn}/nodes";
@@ -439,7 +427,7 @@ export const serializeAws_restJson1ListNodesCommand = async (input, context) =>
         body,
     });
 };
-export const serializeAws_restJson1ListScramSecretsCommand = async (input, context) => {
+export const se_ListScramSecretsCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/clusters/{ClusterArn}/scram-secrets";
@@ -460,7 +448,7 @@ export const serializeAws_restJson1ListScramSecretsCommand = async (input, conte
         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 || ""}` + "/v1/tags/{ResourceArn}";
@@ -476,7 +464,7 @@ export const serializeAws_restJson1ListTagsForResourceCommand = async (input, co
         body,
     });
 };
-export const serializeAws_restJson1RebootBrokerCommand = async (input, context) => {
+export const se_RebootBrokerCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -485,7 +473,7 @@ export const serializeAws_restJson1RebootBrokerCommand = async (input, context)
     resolvedPath = __resolvedPath(resolvedPath, input, "ClusterArn", () => input.ClusterArn, "{ClusterArn}", false);
     let body;
     body = JSON.stringify({
-        ...(input.BrokerIds != null && { brokerIds: serializeAws_restJson1__listOf__string(input.BrokerIds, context) }),
+        ...(input.BrokerIds != null && { brokerIds: se___listOf__string(input.BrokerIds, context) }),
     });
     return new __HttpRequest({
         protocol,
@@ -497,7 +485,7 @@ export const serializeAws_restJson1RebootBrokerCommand = async (input, context)
         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",
@@ -506,7 +494,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_restJson1__mapOf__string(input.Tags, context) }),
+        ...(input.Tags != null && { tags: se___mapOf__string(input.Tags, context) }),
     });
     return new __HttpRequest({
         protocol,
@@ -518,7 +506,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 || ""}` + "/v1/tags/{ResourceArn}";
@@ -541,7 +529,7 @@ export const serializeAws_restJson1UntagResourceCommand = async (input, context)
         body,
     });
 };
-export const serializeAws_restJson1UpdateBrokerCountCommand = async (input, context) => {
+export const se_UpdateBrokerCountCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -563,7 +551,7 @@ export const serializeAws_restJson1UpdateBrokerCountCommand = async (input, cont
         body,
     });
 };
-export const serializeAws_restJson1UpdateBrokerStorageCommand = async (input, context) => {
+export const se_UpdateBrokerStorageCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -574,7 +562,7 @@ export const serializeAws_restJson1UpdateBrokerStorageCommand = async (input, co
     body = JSON.stringify({
         ...(input.CurrentVersion != null && { currentVersion: input.CurrentVersion }),
         ...(input.TargetBrokerEBSVolumeInfo != null && {
-            targetBrokerEBSVolumeInfo: serializeAws_restJson1__listOfBrokerEBSVolumeInfo(input.TargetBrokerEBSVolumeInfo, context),
+            targetBrokerEBSVolumeInfo: se___listOfBrokerEBSVolumeInfo(input.TargetBrokerEBSVolumeInfo, context),
         }),
     });
     return new __HttpRequest({
@@ -587,7 +575,7 @@ export const serializeAws_restJson1UpdateBrokerStorageCommand = async (input, co
         body,
     });
 };
-export const serializeAws_restJson1UpdateBrokerTypeCommand = async (input, context) => {
+export const se_UpdateBrokerTypeCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -609,7 +597,7 @@ export const serializeAws_restJson1UpdateBrokerTypeCommand = async (input, conte
         body,
     });
 };
-export const serializeAws_restJson1UpdateClusterConfigurationCommand = async (input, context) => {
+export const se_UpdateClusterConfigurationCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -619,7 +607,7 @@ export const serializeAws_restJson1UpdateClusterConfigurationCommand = async (in
     let body;
     body = JSON.stringify({
         ...(input.ConfigurationInfo != null && {
-            configurationInfo: serializeAws_restJson1ConfigurationInfo(input.ConfigurationInfo, context),
+            configurationInfo: se_ConfigurationInfo(input.ConfigurationInfo, context),
         }),
         ...(input.CurrentVersion != null && { currentVersion: input.CurrentVersion }),
     });
@@ -633,7 +621,7 @@ export const serializeAws_restJson1UpdateClusterConfigurationCommand = async (in
         body,
     });
 };
-export const serializeAws_restJson1UpdateClusterKafkaVersionCommand = async (input, context) => {
+export const se_UpdateClusterKafkaVersionCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -643,7 +631,7 @@ export const serializeAws_restJson1UpdateClusterKafkaVersionCommand = async (inp
     let body;
     body = JSON.stringify({
         ...(input.ConfigurationInfo != null && {
-            configurationInfo: serializeAws_restJson1ConfigurationInfo(input.ConfigurationInfo, context),
+            configurationInfo: se_ConfigurationInfo(input.ConfigurationInfo, context),
         }),
         ...(input.CurrentVersion != null && { currentVersion: input.CurrentVersion }),
         ...(input.TargetKafkaVersion != null && { targetKafkaVersion: input.TargetKafkaVersion }),
@@ -658,7 +646,7 @@ export const serializeAws_restJson1UpdateClusterKafkaVersionCommand = async (inp
         body,
     });
 };
-export const serializeAws_restJson1UpdateConfigurationCommand = async (input, context) => {
+export const se_UpdateConfigurationCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -680,7 +668,7 @@ export const serializeAws_restJson1UpdateConfigurationCommand = async (input, co
         body,
     });
 };
-export const serializeAws_restJson1UpdateConnectivityCommand = async (input, context) => {
+export const se_UpdateConnectivityCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -689,9 +677,7 @@ export const serializeAws_restJson1UpdateConnectivityCommand = async (input, con
     resolvedPath = __resolvedPath(resolvedPath, input, "ClusterArn", () => input.ClusterArn, "{ClusterArn}", false);
     let body;
     body = JSON.stringify({
-        ...(input.ConnectivityInfo != null && {
-            connectivityInfo: serializeAws_restJson1ConnectivityInfo(input.ConnectivityInfo, context),
-        }),
+        ...(input.ConnectivityInfo != null && { connectivityInfo: se_ConnectivityInfo(input.ConnectivityInfo, context) }),
         ...(input.CurrentVersion != null && { currentVersion: input.CurrentVersion }),
     });
     return new __HttpRequest({
@@ -704,7 +690,7 @@ export const serializeAws_restJson1UpdateConnectivityCommand = async (input, con
         body,
     });
 };
-export const serializeAws_restJson1UpdateMonitoringCommand = async (input, context) => {
+export const se_UpdateMonitoringCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -715,10 +701,8 @@ export const serializeAws_restJson1UpdateMonitoringCommand = async (input, conte
     body = JSON.stringify({
         ...(input.CurrentVersion != null && { currentVersion: input.CurrentVersion }),
         ...(input.EnhancedMonitoring != null && { enhancedMonitoring: input.EnhancedMonitoring }),
-        ...(input.LoggingInfo != null && { loggingInfo: serializeAws_restJson1LoggingInfo(input.LoggingInfo, context) }),
-        ...(input.OpenMonitoring != null && {
-            openMonitoring: serializeAws_restJson1OpenMonitoringInfo(input.OpenMonitoring, context),
-        }),
+        ...(input.LoggingInfo != null && { loggingInfo: se_LoggingInfo(input.LoggingInfo, context) }),
+        ...(input.OpenMonitoring != null && { openMonitoring: se_OpenMonitoringInfo(input.OpenMonitoring, context) }),
     });
     return new __HttpRequest({
         protocol,
@@ -730,7 +714,7 @@ export const serializeAws_restJson1UpdateMonitoringCommand = async (input, conte
         body,
     });
 };
-export const serializeAws_restJson1UpdateSecurityCommand = async (input, context) => {
+export const se_UpdateSecurityCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -740,12 +724,10 @@ export const serializeAws_restJson1UpdateSecurityCommand = async (input, context
     let body;
     body = JSON.stringify({
         ...(input.ClientAuthentication != null && {
-            clientAuthentication: serializeAws_restJson1ClientAuthentication(input.ClientAuthentication, context),
+            clientAuthentication: se_ClientAuthentication(input.ClientAuthentication, context),
         }),
         ...(input.CurrentVersion != null && { currentVersion: input.CurrentVersion }),
-        ...(input.EncryptionInfo != null && {
-            encryptionInfo: serializeAws_restJson1EncryptionInfo(input.EncryptionInfo, context),
-        }),
+        ...(input.EncryptionInfo != null && { encryptionInfo: se_EncryptionInfo(input.EncryptionInfo, context) }),
     });
     return new __HttpRequest({
         protocol,
@@ -757,7 +739,7 @@ export const serializeAws_restJson1UpdateSecurityCommand = async (input, context
         body,
     });
 };
-export const serializeAws_restJson1UpdateStorageCommand = async (input, context) => {
+export const se_UpdateStorageCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -768,7 +750,7 @@ export const serializeAws_restJson1UpdateStorageCommand = async (input, context)
     body = JSON.stringify({
         ...(input.CurrentVersion != null && { currentVersion: input.CurrentVersion }),
         ...(input.ProvisionedThroughput != null && {
-            provisionedThroughput: serializeAws_restJson1ProvisionedThroughput(input.ProvisionedThroughput, context),
+            provisionedThroughput: se_ProvisionedThroughput(input.ProvisionedThroughput, context),
         }),
         ...(input.StorageMode != null && { storageMode: input.StorageMode }),
         ...(input.VolumeSizeGB != null && { volumeSizeGB: input.VolumeSizeGB }),
@@ -783,9 +765,9 @@ export const serializeAws_restJson1UpdateStorageCommand = async (input, context)
         body,
     });
 };
-export const deserializeAws_restJson1BatchAssociateScramSecretCommand = async (output, context) => {
+export const de_BatchAssociateScramSecretCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1BatchAssociateScramSecretCommandError(output, context);
+        return de_BatchAssociateScramSecretCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -795,11 +777,11 @@ export const deserializeAws_restJson1BatchAssociateScramSecretCommand = async (o
         contents.ClusterArn = __expectString(data.clusterArn);
     }
     if (data.unprocessedScramSecrets != null) {
-        contents.UnprocessedScramSecrets = deserializeAws_restJson1__listOfUnprocessedScramSecret(data.unprocessedScramSecrets, context);
+        contents.UnprocessedScramSecrets = de___listOfUnprocessedScramSecret(data.unprocessedScramSecrets, context);
     }
     return contents;
 };
-const deserializeAws_restJson1BatchAssociateScramSecretCommandError = async (output, context) => {
+const de_BatchAssociateScramSecretCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -808,25 +790,25 @@ const deserializeAws_restJson1BatchAssociateScramSecretCommandError = async (out
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.kafka#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "ForbiddenException":
         case "com.amazonaws.kafka#ForbiddenException":
-            throw await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context);
+            throw await de_ForbiddenExceptionRes(parsedOutput, context);
         case "InternalServerErrorException":
         case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.kafka#NotFoundException":
-            throw await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.kafka#ServiceUnavailableException":
-            throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         case "TooManyRequestsException":
         case "com.amazonaws.kafka#TooManyRequestsException":
-            throw await deserializeAws_restJson1TooManyRequestsExceptionResponse(parsedOutput, context);
+            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
         case "UnauthorizedException":
         case "com.amazonaws.kafka#UnauthorizedException":
-            throw await deserializeAws_restJson1UnauthorizedExceptionResponse(parsedOutput, context);
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -837,9 +819,9 @@ const deserializeAws_restJson1BatchAssociateScramSecretCommandError = async (out
             });
     }
 };
-export const deserializeAws_restJson1BatchDisassociateScramSecretCommand = async (output, context) => {
+export const de_BatchDisassociateScramSecretCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1BatchDisassociateScramSecretCommandError(output, context);
+        return de_BatchDisassociateScramSecretCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -849,11 +831,11 @@ export const deserializeAws_restJson1BatchDisassociateScramSecretCommand = async
         contents.ClusterArn = __expectString(data.clusterArn);
     }
     if (data.unprocessedScramSecrets != null) {
-        contents.UnprocessedScramSecrets = deserializeAws_restJson1__listOfUnprocessedScramSecret(data.unprocessedScramSecrets, context);
+        contents.UnprocessedScramSecrets = de___listOfUnprocessedScramSecret(data.unprocessedScramSecrets, context);
     }
     return contents;
 };
-const deserializeAws_restJson1BatchDisassociateScramSecretCommandError = async (output, context) => {
+const de_BatchDisassociateScramSecretCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -862,25 +844,25 @@ const deserializeAws_restJson1BatchDisassociateScramSecretCommandError = async (
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.kafka#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "ForbiddenException":
         case "com.amazonaws.kafka#ForbiddenException":
-            throw await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context);
+            throw await de_ForbiddenExceptionRes(parsedOutput, context);
         case "InternalServerErrorException":
         case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.kafka#NotFoundException":
-            throw await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.kafka#ServiceUnavailableException":
-            throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         case "TooManyRequestsException":
         case "com.amazonaws.kafka#TooManyRequestsException":
-            throw await deserializeAws_restJson1TooManyRequestsExceptionResponse(parsedOutput, context);
+            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
         case "UnauthorizedException":
         case "com.amazonaws.kafka#UnauthorizedException":
-            throw await deserializeAws_restJson1UnauthorizedExceptionResponse(parsedOutput, context);
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -891,9 +873,9 @@ const deserializeAws_restJson1BatchDisassociateScramSecretCommandError = async (
             });
     }
 };
-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),
@@ -910,7 +892,7 @@ export const deserializeAws_restJson1CreateClusterCommand = async (output, conte
     }
     return contents;
 };
-const deserializeAws_restJson1CreateClusterCommandError = async (output, context) => {
+const de_CreateClusterCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -919,25 +901,25 @@ const deserializeAws_restJson1CreateClusterCommandError = async (output, context
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.kafka#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "ConflictException":
         case "com.amazonaws.kafka#ConflictException":
-            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "ForbiddenException":
         case "com.amazonaws.kafka#ForbiddenException":
-            throw await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context);
+            throw await de_ForbiddenExceptionRes(parsedOutput, context);
         case "InternalServerErrorException":
         case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.kafka#ServiceUnavailableException":
-            throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         case "TooManyRequestsException":
         case "com.amazonaws.kafka#TooManyRequestsException":
-            throw await deserializeAws_restJson1TooManyRequestsExceptionResponse(parsedOutput, context);
+            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
         case "UnauthorizedException":
         case "com.amazonaws.kafka#UnauthorizedException":
-            throw await deserializeAws_restJson1UnauthorizedExceptionResponse(parsedOutput, context);
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -948,9 +930,9 @@ const deserializeAws_restJson1CreateClusterCommandError = async (output, context
             });
     }
 };
-export const deserializeAws_restJson1CreateClusterV2Command = async (output, context) => {
+export const de_CreateClusterV2Command = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1CreateClusterV2CommandError(output, context);
+        return de_CreateClusterV2CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -970,7 +952,7 @@ export const deserializeAws_restJson1CreateClusterV2Command = async (output, con
     }
     return contents;
 };
-const deserializeAws_restJson1CreateClusterV2CommandError = async (output, context) => {
+const de_CreateClusterV2CommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -979,25 +961,25 @@ const deserializeAws_restJson1CreateClusterV2CommandError = async (output, conte
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.kafka#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "ConflictException":
         case "com.amazonaws.kafka#ConflictException":
-            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "ForbiddenException":
         case "com.amazonaws.kafka#ForbiddenException":
-            throw await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context);
+            throw await de_ForbiddenExceptionRes(parsedOutput, context);
         case "InternalServerErrorException":
         case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.kafka#ServiceUnavailableException":
-            throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         case "TooManyRequestsException":
         case "com.amazonaws.kafka#TooManyRequestsException":
-            throw await deserializeAws_restJson1TooManyRequestsExceptionResponse(parsedOutput, context);
+            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
         case "UnauthorizedException":
         case "com.amazonaws.kafka#UnauthorizedException":
-            throw await deserializeAws_restJson1UnauthorizedExceptionResponse(parsedOutput, context);
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1008,9 +990,9 @@ const deserializeAws_restJson1CreateClusterV2CommandError = async (output, conte
             });
     }
 };
-export const deserializeAws_restJson1CreateConfigurationCommand = async (output, context) => {
+export const de_CreateConfigurationCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1CreateConfigurationCommandError(output, context);
+        return de_CreateConfigurationCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1023,7 +1005,7 @@ export const deserializeAws_restJson1CreateConfigurationCommand = async (output,
         contents.CreationTime = __expectNonNull(__parseRfc3339DateTimeWithOffset(data.creationTime));
     }
     if (data.latestRevision != null) {
-        contents.LatestRevision = deserializeAws_restJson1ConfigurationRevision(data.latestRevision, context);
+        contents.LatestRevision = de_ConfigurationRevision(data.latestRevision, context);
     }
     if (data.name != null) {
         contents.Name = __expectString(data.name);
@@ -1033,7 +1015,7 @@ export const deserializeAws_restJson1CreateConfigurationCommand = async (output,
     }
     return contents;
 };
-const deserializeAws_restJson1CreateConfigurationCommandError = async (output, context) => {
+const de_CreateConfigurationCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1042,25 +1024,25 @@ const deserializeAws_restJson1CreateConfigurationCommandError = async (output, c
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.kafka#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "ConflictException":
         case "com.amazonaws.kafka#ConflictException":
-            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "ForbiddenException":
         case "com.amazonaws.kafka#ForbiddenException":
-            throw await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context);
+            throw await de_ForbiddenExceptionRes(parsedOutput, context);
         case "InternalServerErrorException":
         case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.kafka#ServiceUnavailableException":
-            throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         case "TooManyRequestsException":
         case "com.amazonaws.kafka#TooManyRequestsException":
-            throw await deserializeAws_restJson1TooManyRequestsExceptionResponse(parsedOutput, context);
+            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
         case "UnauthorizedException":
         case "com.amazonaws.kafka#UnauthorizedException":
-            throw await deserializeAws_restJson1UnauthorizedExceptionResponse(parsedOutput, context);
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1071,9 +1053,9 @@ const deserializeAws_restJson1CreateConfigurationCommandError = async (output, c
             });
     }
 };
-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),
@@ -1087,7 +1069,7 @@ export const deserializeAws_restJson1DeleteClusterCommand = async (output, conte
     }
     return contents;
 };
-const deserializeAws_restJson1DeleteClusterCommandError = async (output, context) => {
+const de_DeleteClusterCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1096,16 +1078,16 @@ const deserializeAws_restJson1DeleteClusterCommandError = async (output, context
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.kafka#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "ForbiddenException":
         case "com.amazonaws.kafka#ForbiddenException":
-            throw await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context);
+            throw await de_ForbiddenExceptionRes(parsedOutput, context);
         case "InternalServerErrorException":
         case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.kafka#NotFoundException":
-            throw await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1116,9 +1098,9 @@ const deserializeAws_restJson1DeleteClusterCommandError = async (output, context
             });
     }
 };
-export const deserializeAws_restJson1DeleteConfigurationCommand = async (output, context) => {
+export const de_DeleteConfigurationCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1DeleteConfigurationCommandError(output, context);
+        return de_DeleteConfigurationCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1132,7 +1114,7 @@ export const deserializeAws_restJson1DeleteConfigurationCommand = async (output,
     }
     return contents;
 };
-const deserializeAws_restJson1DeleteConfigurationCommandError = async (output, context) => {
+const de_DeleteConfigurationCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1141,16 +1123,16 @@ const deserializeAws_restJson1DeleteConfigurationCommandError = async (output, c
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.kafka#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "ForbiddenException":
         case "com.amazonaws.kafka#ForbiddenException":
-            throw await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context);
+            throw await de_ForbiddenExceptionRes(parsedOutput, context);
         case "InternalServerErrorException":
         case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.kafka#NotFoundException":
-            throw await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1161,20 +1143,20 @@ const deserializeAws_restJson1DeleteConfigurationCommandError = async (output, c
             });
     }
 };
-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.clusterInfo != null) {
-        contents.ClusterInfo = deserializeAws_restJson1ClusterInfo(data.clusterInfo, context);
+        contents.ClusterInfo = de_ClusterInfo(data.clusterInfo, context);
     }
     return contents;
 };
-const deserializeAws_restJson1DescribeClusterCommandError = async (output, context) => {
+const de_DescribeClusterCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1183,19 +1165,19 @@ const deserializeAws_restJson1DescribeClusterCommandError = async (output, conte
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.kafka#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "ForbiddenException":
         case "com.amazonaws.kafka#ForbiddenException":
-            throw await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context);
+            throw await de_ForbiddenExceptionRes(parsedOutput, context);
         case "InternalServerErrorException":
         case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.kafka#NotFoundException":
-            throw await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         case "UnauthorizedException":
         case "com.amazonaws.kafka#UnauthorizedException":
-            throw await deserializeAws_restJson1UnauthorizedExceptionResponse(parsedOutput, context);
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1206,20 +1188,20 @@ const deserializeAws_restJson1DescribeClusterCommandError = async (output, conte
             });
     }
 };
-export const deserializeAws_restJson1DescribeClusterOperationCommand = async (output, context) => {
+export const de_DescribeClusterOperationCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1DescribeClusterOperationCommandError(output, context);
+        return de_DescribeClusterOperationCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.clusterOperationInfo != null) {
-        contents.ClusterOperationInfo = deserializeAws_restJson1ClusterOperationInfo(data.clusterOperationInfo, context);
+        contents.ClusterOperationInfo = de_ClusterOperationInfo(data.clusterOperationInfo, context);
     }
     return contents;
 };
-const deserializeAws_restJson1DescribeClusterOperationCommandError = async (output, context) => {
+const de_DescribeClusterOperationCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1228,19 +1210,19 @@ const deserializeAws_restJson1DescribeClusterOperationCommandError = async (outp
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.kafka#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "ForbiddenException":
         case "com.amazonaws.kafka#ForbiddenException":
-            throw await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context);
+            throw await de_ForbiddenExceptionRes(parsedOutput, context);
         case "InternalServerErrorException":
         case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.kafka#NotFoundException":
-            throw await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         case "UnauthorizedException":
         case "com.amazonaws.kafka#UnauthorizedException":
-            throw await deserializeAws_restJson1UnauthorizedExceptionResponse(parsedOutput, context);
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1251,20 +1233,20 @@ const deserializeAws_restJson1DescribeClusterOperationCommandError = async (outp
             });
     }
 };
-export const deserializeAws_restJson1DescribeClusterV2Command = async (output, context) => {
+export const de_DescribeClusterV2Command = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1DescribeClusterV2CommandError(output, context);
+        return de_DescribeClusterV2CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.clusterInfo != null) {
-        contents.ClusterInfo = deserializeAws_restJson1Cluster(data.clusterInfo, context);
+        contents.ClusterInfo = de_Cluster(data.clusterInfo, context);
     }
     return contents;
 };
-const deserializeAws_restJson1DescribeClusterV2CommandError = async (output, context) => {
+const de_DescribeClusterV2CommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1273,19 +1255,19 @@ const deserializeAws_restJson1DescribeClusterV2CommandError = async (output, con
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.kafka#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "ForbiddenException":
         case "com.amazonaws.kafka#ForbiddenException":
-            throw await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context);
+            throw await de_ForbiddenExceptionRes(parsedOutput, context);
         case "InternalServerErrorException":
         case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.kafka#NotFoundException":
-            throw await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         case "UnauthorizedException":
         case "com.amazonaws.kafka#UnauthorizedException":
-            throw await deserializeAws_restJson1UnauthorizedExceptionResponse(parsedOutput, context);
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1296,9 +1278,9 @@ const deserializeAws_restJson1DescribeClusterV2CommandError = async (output, con
             });
     }
 };
-export const deserializeAws_restJson1DescribeConfigurationCommand = async (output, context) => {
+export const de_DescribeConfigurationCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1DescribeConfigurationCommandError(output, context);
+        return de_DescribeConfigurationCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1314,10 +1296,10 @@ export const deserializeAws_restJson1DescribeConfigurationCommand = async (outpu
         contents.Description = __expectString(data.description);
     }
     if (data.kafkaVersions != null) {
-        contents.KafkaVersions = deserializeAws_restJson1__listOf__string(data.kafkaVersions, context);
+        contents.KafkaVersions = de___listOf__string(data.kafkaVersions, context);
     }
     if (data.latestRevision != null) {
-        contents.LatestRevision = deserializeAws_restJson1ConfigurationRevision(data.latestRevision, context);
+        contents.LatestRevision = de_ConfigurationRevision(data.latestRevision, context);
     }
     if (data.name != null) {
         contents.Name = __expectString(data.name);
@@ -1327,7 +1309,7 @@ export const deserializeAws_restJson1DescribeConfigurationCommand = async (outpu
     }
     return contents;
 };
-const deserializeAws_restJson1DescribeConfigurationCommandError = async (output, context) => {
+const de_DescribeConfigurationCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1336,22 +1318,22 @@ const deserializeAws_restJson1DescribeConfigurationCommandError = async (output,
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.kafka#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "ForbiddenException":
         case "com.amazonaws.kafka#ForbiddenException":
-            throw await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context);
+            throw await de_ForbiddenExceptionRes(parsedOutput, context);
         case "InternalServerErrorException":
         case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.kafka#NotFoundException":
-            throw await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.kafka#ServiceUnavailableException":
-            throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         case "UnauthorizedException":
         case "com.amazonaws.kafka#UnauthorizedException":
-            throw await deserializeAws_restJson1UnauthorizedExceptionResponse(parsedOutput, context);
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1362,9 +1344,9 @@ const deserializeAws_restJson1DescribeConfigurationCommandError = async (output,
             });
     }
 };
-export const deserializeAws_restJson1DescribeConfigurationRevisionCommand = async (output, context) => {
+export const de_DescribeConfigurationRevisionCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1DescribeConfigurationRevisionCommandError(output, context);
+        return de_DescribeConfigurationRevisionCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1387,7 +1369,7 @@ export const deserializeAws_restJson1DescribeConfigurationRevisionCommand = asyn
     }
     return contents;
 };
-const deserializeAws_restJson1DescribeConfigurationRevisionCommandError = async (output, context) => {
+const de_DescribeConfigurationRevisionCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1396,22 +1378,22 @@ const deserializeAws_restJson1DescribeConfigurationRevisionCommandError = async
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.kafka#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "ForbiddenException":
         case "com.amazonaws.kafka#ForbiddenException":
-            throw await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context);
+            throw await de_ForbiddenExceptionRes(parsedOutput, context);
         case "InternalServerErrorException":
         case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.kafka#NotFoundException":
-            throw await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.kafka#ServiceUnavailableException":
-            throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         case "UnauthorizedException":
         case "com.amazonaws.kafka#UnauthorizedException":
-            throw await deserializeAws_restJson1UnauthorizedExceptionResponse(parsedOutput, context);
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1422,9 +1404,9 @@ const deserializeAws_restJson1DescribeConfigurationRevisionCommandError = async
             });
     }
 };
-export const deserializeAws_restJson1GetBootstrapBrokersCommand = async (output, context) => {
+export const de_GetBootstrapBrokersCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1GetBootstrapBrokersCommandError(output, context);
+        return de_GetBootstrapBrokersCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1453,7 +1435,7 @@ export const deserializeAws_restJson1GetBootstrapBrokersCommand = async (output,
     }
     return contents;
 };
-const deserializeAws_restJson1GetBootstrapBrokersCommandError = async (output, context) => {
+const de_GetBootstrapBrokersCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1462,19 +1444,19 @@ const deserializeAws_restJson1GetBootstrapBrokersCommandError = async (output, c
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.kafka#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "ConflictException":
         case "com.amazonaws.kafka#ConflictException":
-            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "ForbiddenException":
         case "com.amazonaws.kafka#ForbiddenException":
-            throw await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context);
+            throw await de_ForbiddenExceptionRes(parsedOutput, context);
         case "InternalServerErrorException":
         case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
         case "UnauthorizedException":
         case "com.amazonaws.kafka#UnauthorizedException":
-            throw await deserializeAws_restJson1UnauthorizedExceptionResponse(parsedOutput, context);
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1485,20 +1467,20 @@ const deserializeAws_restJson1GetBootstrapBrokersCommandError = async (output, c
             });
     }
 };
-export const deserializeAws_restJson1GetCompatibleKafkaVersionsCommand = async (output, context) => {
+export const de_GetCompatibleKafkaVersionsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1GetCompatibleKafkaVersionsCommandError(output, context);
+        return de_GetCompatibleKafkaVersionsCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.compatibleKafkaVersions != null) {
-        contents.CompatibleKafkaVersions = deserializeAws_restJson1__listOfCompatibleKafkaVersion(data.compatibleKafkaVersions, context);
+        contents.CompatibleKafkaVersions = de___listOfCompatibleKafkaVersion(data.compatibleKafkaVersions, context);
     }
     return contents;
 };
-const deserializeAws_restJson1GetCompatibleKafkaVersionsCommandError = async (output, context) => {
+const de_GetCompatibleKafkaVersionsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1507,25 +1489,25 @@ const deserializeAws_restJson1GetCompatibleKafkaVersionsCommandError = async (ou
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.kafka#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "ForbiddenException":
         case "com.amazonaws.kafka#ForbiddenException":
-            throw await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context);
+            throw await de_ForbiddenExceptionRes(parsedOutput, context);
         case "InternalServerErrorException":
         case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.kafka#NotFoundException":
-            throw await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.kafka#ServiceUnavailableException":
-            throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         case "TooManyRequestsException":
         case "com.amazonaws.kafka#TooManyRequestsException":
-            throw await deserializeAws_restJson1TooManyRequestsExceptionResponse(parsedOutput, context);
+            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
         case "UnauthorizedException":
         case "com.amazonaws.kafka#UnauthorizedException":
-            throw await deserializeAws_restJson1UnauthorizedExceptionResponse(parsedOutput, context);
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1536,23 +1518,23 @@ const deserializeAws_restJson1GetCompatibleKafkaVersionsCommandError = async (ou
             });
     }
 };
-export const deserializeAws_restJson1ListClusterOperationsCommand = async (output, context) => {
+export const de_ListClusterOperationsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1ListClusterOperationsCommandError(output, context);
+        return de_ListClusterOperationsCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.clusterOperationInfoList != null) {
-        contents.ClusterOperationInfoList = deserializeAws_restJson1__listOfClusterOperationInfo(data.clusterOperationInfoList, context);
+        contents.ClusterOperationInfoList = de___listOfClusterOperationInfo(data.clusterOperationInfoList, context);
     }
     if (data.nextToken != null) {
         contents.NextToken = __expectString(data.nextToken);
     }
     return contents;
 };
-const deserializeAws_restJson1ListClusterOperationsCommandError = async (output, context) => {
+const de_ListClusterOperationsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1561,16 +1543,16 @@ const deserializeAws_restJson1ListClusterOperationsCommandError = async (output,
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.kafka#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "ForbiddenException":
         case "com.amazonaws.kafka#ForbiddenException":
-            throw await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context);
+            throw await de_ForbiddenExceptionRes(parsedOutput, context);
         case "InternalServerErrorException":
         case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
         case "UnauthorizedException":
         case "com.amazonaws.kafka#UnauthorizedException":
-            throw await deserializeAws_restJson1UnauthorizedExceptionResponse(parsedOutput, context);
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1581,23 +1563,23 @@ const deserializeAws_restJson1ListClusterOperationsCommandError = async (output,
             });
     }
 };
-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.clusterInfoList != null) {
-        contents.ClusterInfoList = deserializeAws_restJson1__listOfClusterInfo(data.clusterInfoList, context);
+        contents.ClusterInfoList = de___listOfClusterInfo(data.clusterInfoList, 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),
@@ -1606,16 +1588,16 @@ const deserializeAws_restJson1ListClustersCommandError = async (output, context)
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.kafka#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "ForbiddenException":
         case "com.amazonaws.kafka#ForbiddenException":
-            throw await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context);
+            throw await de_ForbiddenExceptionRes(parsedOutput, context);
         case "InternalServerErrorException":
         case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
         case "UnauthorizedException":
         case "com.amazonaws.kafka#UnauthorizedException":
-            throw await deserializeAws_restJson1UnauthorizedExceptionResponse(parsedOutput, context);
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1626,23 +1608,23 @@ const deserializeAws_restJson1ListClustersCommandError = async (output, context)
             });
     }
 };
-export const deserializeAws_restJson1ListClustersV2Command = async (output, context) => {
+export const de_ListClustersV2Command = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1ListClustersV2CommandError(output, context);
+        return de_ListClustersV2CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.clusterInfoList != null) {
-        contents.ClusterInfoList = deserializeAws_restJson1__listOfCluster(data.clusterInfoList, context);
+        contents.ClusterInfoList = de___listOfCluster(data.clusterInfoList, context);
     }
     if (data.nextToken != null) {
         contents.NextToken = __expectString(data.nextToken);
     }
     return contents;
 };
-const deserializeAws_restJson1ListClustersV2CommandError = async (output, context) => {
+const de_ListClustersV2CommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1651,16 +1633,16 @@ const deserializeAws_restJson1ListClustersV2CommandError = async (output, contex
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.kafka#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "ForbiddenException":
         case "com.amazonaws.kafka#ForbiddenException":
-            throw await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context);
+            throw await de_ForbiddenExceptionRes(parsedOutput, context);
         case "InternalServerErrorException":
         case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
         case "UnauthorizedException":
         case "com.amazonaws.kafka#UnauthorizedException":
-            throw await deserializeAws_restJson1UnauthorizedExceptionResponse(parsedOutput, context);
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1671,9 +1653,9 @@ const deserializeAws_restJson1ListClustersV2CommandError = async (output, contex
             });
     }
 };
-export const deserializeAws_restJson1ListConfigurationRevisionsCommand = async (output, context) => {
+export const de_ListConfigurationRevisionsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1ListConfigurationRevisionsCommandError(output, context);
+        return de_ListConfigurationRevisionsCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1683,11 +1665,11 @@ export const deserializeAws_restJson1ListConfigurationRevisionsCommand = async (
         contents.NextToken = __expectString(data.nextToken);
     }
     if (data.revisions != null) {
-        contents.Revisions = deserializeAws_restJson1__listOfConfigurationRevision(data.revisions, context);
+        contents.Revisions = de___listOfConfigurationRevision(data.revisions, context);
     }
     return contents;
 };
-const deserializeAws_restJson1ListConfigurationRevisionsCommandError = async (output, context) => {
+const de_ListConfigurationRevisionsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1696,22 +1678,22 @@ const deserializeAws_restJson1ListConfigurationRevisionsCommandError = async (ou
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.kafka#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "ForbiddenException":
         case "com.amazonaws.kafka#ForbiddenException":
-            throw await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context);
+            throw await de_ForbiddenExceptionRes(parsedOutput, context);
         case "InternalServerErrorException":
         case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.kafka#NotFoundException":
-            throw await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.kafka#ServiceUnavailableException":
-            throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         case "UnauthorizedException":
         case "com.amazonaws.kafka#UnauthorizedException":
-            throw await deserializeAws_restJson1UnauthorizedExceptionResponse(parsedOutput, context);
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1722,23 +1704,23 @@ const deserializeAws_restJson1ListConfigurationRevisionsCommandError = async (ou
             });
     }
 };
-export const deserializeAws_restJson1ListConfigurationsCommand = async (output, context) => {
+export const de_ListConfigurationsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1ListConfigurationsCommandError(output, context);
+        return de_ListConfigurationsCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.configurations != null) {
-        contents.Configurations = deserializeAws_restJson1__listOfConfiguration(data.configurations, context);
+        contents.Configurations = de___listOfConfiguration(data.configurations, context);
     }
     if (data.nextToken != null) {
         contents.NextToken = __expectString(data.nextToken);
     }
     return contents;
 };
-const deserializeAws_restJson1ListConfigurationsCommandError = async (output, context) => {
+const de_ListConfigurationsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1747,19 +1729,19 @@ const deserializeAws_restJson1ListConfigurationsCommandError = async (output, co
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.kafka#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "ForbiddenException":
         case "com.amazonaws.kafka#ForbiddenException":
-            throw await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context);
+            throw await de_ForbiddenExceptionRes(parsedOutput, context);
         case "InternalServerErrorException":
         case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.kafka#ServiceUnavailableException":
-            throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         case "UnauthorizedException":
         case "com.amazonaws.kafka#UnauthorizedException":
-            throw await deserializeAws_restJson1UnauthorizedExceptionResponse(parsedOutput, context);
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1770,23 +1752,23 @@ const deserializeAws_restJson1ListConfigurationsCommandError = async (output, co
             });
     }
 };
-export const deserializeAws_restJson1ListKafkaVersionsCommand = async (output, context) => {
+export const de_ListKafkaVersionsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1ListKafkaVersionsCommandError(output, context);
+        return de_ListKafkaVersionsCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.kafkaVersions != null) {
-        contents.KafkaVersions = deserializeAws_restJson1__listOfKafkaVersion(data.kafkaVersions, context);
+        contents.KafkaVersions = de___listOfKafkaVersion(data.kafkaVersions, context);
     }
     if (data.nextToken != null) {
         contents.NextToken = __expectString(data.nextToken);
     }
     return contents;
 };
-const deserializeAws_restJson1ListKafkaVersionsCommandError = async (output, context) => {
+const de_ListKafkaVersionsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1795,16 +1777,16 @@ const deserializeAws_restJson1ListKafkaVersionsCommandError = async (output, con
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.kafka#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "ForbiddenException":
         case "com.amazonaws.kafka#ForbiddenException":
-            throw await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context);
+            throw await de_ForbiddenExceptionRes(parsedOutput, context);
         case "InternalServerErrorException":
         case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
         case "UnauthorizedException":
         case "com.amazonaws.kafka#UnauthorizedException":
-            throw await deserializeAws_restJson1UnauthorizedExceptionResponse(parsedOutput, context);
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1815,9 +1797,9 @@ const deserializeAws_restJson1ListKafkaVersionsCommandError = async (output, con
             });
     }
 };
-export const deserializeAws_restJson1ListNodesCommand = async (output, context) => {
+export const de_ListNodesCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1ListNodesCommandError(output, context);
+        return de_ListNodesCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1827,11 +1809,11 @@ export const deserializeAws_restJson1ListNodesCommand = async (output, context)
         contents.NextToken = __expectString(data.nextToken);
     }
     if (data.nodeInfoList != null) {
-        contents.NodeInfoList = deserializeAws_restJson1__listOfNodeInfo(data.nodeInfoList, context);
+        contents.NodeInfoList = de___listOfNodeInfo(data.nodeInfoList, context);
     }
     return contents;
 };
-const deserializeAws_restJson1ListNodesCommandError = async (output, context) => {
+const de_ListNodesCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1840,16 +1822,16 @@ const deserializeAws_restJson1ListNodesCommandError = async (output, context) =>
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.kafka#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "ForbiddenException":
         case "com.amazonaws.kafka#ForbiddenException":
-            throw await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context);
+            throw await de_ForbiddenExceptionRes(parsedOutput, context);
         case "InternalServerErrorException":
         case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.kafka#NotFoundException":
-            throw await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1860,9 +1842,9 @@ const deserializeAws_restJson1ListNodesCommandError = async (output, context) =>
             });
     }
 };
-export const deserializeAws_restJson1ListScramSecretsCommand = async (output, context) => {
+export const de_ListScramSecretsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1ListScramSecretsCommandError(output, context);
+        return de_ListScramSecretsCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1872,11 +1854,11 @@ export const deserializeAws_restJson1ListScramSecretsCommand = async (output, co
         contents.NextToken = __expectString(data.nextToken);
     }
     if (data.secretArnList != null) {
-        contents.SecretArnList = deserializeAws_restJson1__listOf__string(data.secretArnList, context);
+        contents.SecretArnList = de___listOf__string(data.secretArnList, context);
     }
     return contents;
 };
-const deserializeAws_restJson1ListScramSecretsCommandError = async (output, context) => {
+const de_ListScramSecretsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1885,25 +1867,25 @@ const deserializeAws_restJson1ListScramSecretsCommandError = async (output, cont
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.kafka#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "ForbiddenException":
         case "com.amazonaws.kafka#ForbiddenException":
-            throw await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context);
+            throw await de_ForbiddenExceptionRes(parsedOutput, context);
         case "InternalServerErrorException":
         case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.kafka#NotFoundException":
-            throw await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.kafka#ServiceUnavailableException":
-            throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         case "TooManyRequestsException":
         case "com.amazonaws.kafka#TooManyRequestsException":
-            throw await deserializeAws_restJson1TooManyRequestsExceptionResponse(parsedOutput, context);
+            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
         case "UnauthorizedException":
         case "com.amazonaws.kafka#UnauthorizedException":
-            throw await deserializeAws_restJson1UnauthorizedExceptionResponse(parsedOutput, context);
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1914,20 +1896,20 @@ const deserializeAws_restJson1ListScramSecretsCommandError = async (output, cont
             });
     }
 };
-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_restJson1__mapOf__string(data.tags, context);
+        contents.Tags = de___mapOf__string(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),
@@ -1936,13 +1918,13 @@ const deserializeAws_restJson1ListTagsForResourceCommandError = async (output, c
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.kafka#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "InternalServerErrorException":
         case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.kafka#NotFoundException":
-            throw await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1953,9 +1935,9 @@ const deserializeAws_restJson1ListTagsForResourceCommandError = async (output, c
             });
     }
 };
-export const deserializeAws_restJson1RebootBrokerCommand = async (output, context) => {
+export const de_RebootBrokerCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1RebootBrokerCommandError(output, context);
+        return de_RebootBrokerCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1969,7 +1951,7 @@ export const deserializeAws_restJson1RebootBrokerCommand = async (output, contex
     }
     return contents;
 };
-const deserializeAws_restJson1RebootBrokerCommandError = async (output, context) => {
+const de_RebootBrokerCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1978,25 +1960,25 @@ const deserializeAws_restJson1RebootBrokerCommandError = async (output, context)
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.kafka#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "ForbiddenException":
         case "com.amazonaws.kafka#ForbiddenException":
-            throw await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context);
+            throw await de_ForbiddenExceptionRes(parsedOutput, context);
         case "InternalServerErrorException":
         case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.kafka#NotFoundException":
-            throw await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.kafka#ServiceUnavailableException":
-            throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         case "TooManyRequestsException":
         case "com.amazonaws.kafka#TooManyRequestsException":
-            throw await deserializeAws_restJson1TooManyRequestsExceptionResponse(parsedOutput, context);
+            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
         case "UnauthorizedException":
         case "com.amazonaws.kafka#UnauthorizedException":
-            throw await deserializeAws_restJson1UnauthorizedExceptionResponse(parsedOutput, context);
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2007,9 +1989,9 @@ const deserializeAws_restJson1RebootBrokerCommandError = async (output, context)
             });
     }
 };
-export const deserializeAws_restJson1TagResourceCommand = async (output, context) => {
+export const de_TagResourceCommand = async (output, context) => {
     if (output.statusCode !== 204 && output.statusCode >= 300) {
-        return deserializeAws_restJson1TagResourceCommandError(output, context);
+        return de_TagResourceCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -2017,7 +1999,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),
@@ -2026,13 +2008,13 @@ const deserializeAws_restJson1TagResourceCommandError = async (output, context)
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.kafka#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "InternalServerErrorException":
         case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.kafka#NotFoundException":
-            throw await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2043,9 +2025,9 @@ const deserializeAws_restJson1TagResourceCommandError = async (output, context)
             });
     }
 };
-export const deserializeAws_restJson1UntagResourceCommand = async (output, context) => {
+export const de_UntagResourceCommand = async (output, context) => {
     if (output.statusCode !== 204 && output.statusCode >= 300) {
-        return deserializeAws_restJson1UntagResourceCommandError(output, context);
+        return de_UntagResourceCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -2053,7 +2035,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),
@@ -2062,13 +2044,13 @@ const deserializeAws_restJson1UntagResourceCommandError = async (output, context
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.kafka#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "InternalServerErrorException":
         case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.kafka#NotFoundException":
-            throw await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2079,9 +2061,9 @@ const deserializeAws_restJson1UntagResourceCommandError = async (output, context
             });
     }
 };
-export const deserializeAws_restJson1UpdateBrokerCountCommand = async (output, context) => {
+export const de_UpdateBrokerCountCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1UpdateBrokerCountCommandError(output, context);
+        return de_UpdateBrokerCountCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -2095,7 +2077,7 @@ export const deserializeAws_restJson1UpdateBrokerCountCommand = async (output, c
     }
     return contents;
 };
-const deserializeAws_restJson1UpdateBrokerCountCommandError = async (output, context) => {
+const de_UpdateBrokerCountCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2104,19 +2086,19 @@ const deserializeAws_restJson1UpdateBrokerCountCommandError = async (output, con
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.kafka#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "ForbiddenException":
         case "com.amazonaws.kafka#ForbiddenException":
-            throw await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context);
+            throw await de_ForbiddenExceptionRes(parsedOutput, context);
         case "InternalServerErrorException":
         case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.kafka#ServiceUnavailableException":
-            throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         case "UnauthorizedException":
         case "com.amazonaws.kafka#UnauthorizedException":
-            throw await deserializeAws_restJson1UnauthorizedExceptionResponse(parsedOutput, context);
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2127,9 +2109,9 @@ const deserializeAws_restJson1UpdateBrokerCountCommandError = async (output, con
             });
     }
 };
-export const deserializeAws_restJson1UpdateBrokerStorageCommand = async (output, context) => {
+export const de_UpdateBrokerStorageCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1UpdateBrokerStorageCommandError(output, context);
+        return de_UpdateBrokerStorageCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -2143,7 +2125,7 @@ export const deserializeAws_restJson1UpdateBrokerStorageCommand = async (output,
     }
     return contents;
 };
-const deserializeAws_restJson1UpdateBrokerStorageCommandError = async (output, context) => {
+const de_UpdateBrokerStorageCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2152,19 +2134,19 @@ const deserializeAws_restJson1UpdateBrokerStorageCommandError = async (output, c
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.kafka#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "ForbiddenException":
         case "com.amazonaws.kafka#ForbiddenException":
-            throw await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context);
+            throw await de_ForbiddenExceptionRes(parsedOutput, context);
         case "InternalServerErrorException":
         case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.kafka#ServiceUnavailableException":
-            throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         case "UnauthorizedException":
         case "com.amazonaws.kafka#UnauthorizedException":
-            throw await deserializeAws_restJson1UnauthorizedExceptionResponse(parsedOutput, context);
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2175,9 +2157,9 @@ const deserializeAws_restJson1UpdateBrokerStorageCommandError = async (output, c
             });
     }
 };
-export const deserializeAws_restJson1UpdateBrokerTypeCommand = async (output, context) => {
+export const de_UpdateBrokerTypeCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1UpdateBrokerTypeCommandError(output, context);
+        return de_UpdateBrokerTypeCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -2191,7 +2173,7 @@ export const deserializeAws_restJson1UpdateBrokerTypeCommand = async (output, co
     }
     return contents;
 };
-const deserializeAws_restJson1UpdateBrokerTypeCommandError = async (output, context) => {
+const de_UpdateBrokerTypeCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2200,25 +2182,25 @@ const deserializeAws_restJson1UpdateBrokerTypeCommandError = async (output, cont
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.kafka#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "ForbiddenException":
         case "com.amazonaws.kafka#ForbiddenException":
-            throw await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context);
+            throw await de_ForbiddenExceptionRes(parsedOutput, context);
         case "InternalServerErrorException":
         case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.kafka#NotFoundException":
-            throw await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.kafka#ServiceUnavailableException":
-            throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         case "TooManyRequestsException":
         case "com.amazonaws.kafka#TooManyRequestsException":
-            throw await deserializeAws_restJson1TooManyRequestsExceptionResponse(parsedOutput, context);
+            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
         case "UnauthorizedException":
         case "com.amazonaws.kafka#UnauthorizedException":
-            throw await deserializeAws_restJson1UnauthorizedExceptionResponse(parsedOutput, context);
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2229,9 +2211,9 @@ const deserializeAws_restJson1UpdateBrokerTypeCommandError = async (output, cont
             });
     }
 };
-export const deserializeAws_restJson1UpdateClusterConfigurationCommand = async (output, context) => {
+export const de_UpdateClusterConfigurationCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1UpdateClusterConfigurationCommandError(output, context);
+        return de_UpdateClusterConfigurationCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -2245,7 +2227,7 @@ export const deserializeAws_restJson1UpdateClusterConfigurationCommand = async (
     }
     return contents;
 };
-const deserializeAws_restJson1UpdateClusterConfigurationCommandError = async (output, context) => {
+const de_UpdateClusterConfigurationCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2254,22 +2236,22 @@ const deserializeAws_restJson1UpdateClusterConfigurationCommandError = async (ou
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.kafka#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "ForbiddenException":
         case "com.amazonaws.kafka#ForbiddenException":
-            throw await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context);
+            throw await de_ForbiddenExceptionRes(parsedOutput, context);
         case "InternalServerErrorException":
         case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.kafka#NotFoundException":
-            throw await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.kafka#ServiceUnavailableException":
-            throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         case "UnauthorizedException":
         case "com.amazonaws.kafka#UnauthorizedException":
-            throw await deserializeAws_restJson1UnauthorizedExceptionResponse(parsedOutput, context);
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2280,9 +2262,9 @@ const deserializeAws_restJson1UpdateClusterConfigurationCommandError = async (ou
             });
     }
 };
-export const deserializeAws_restJson1UpdateClusterKafkaVersionCommand = async (output, context) => {
+export const de_UpdateClusterKafkaVersionCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1UpdateClusterKafkaVersionCommandError(output, context);
+        return de_UpdateClusterKafkaVersionCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -2296,7 +2278,7 @@ export const deserializeAws_restJson1UpdateClusterKafkaVersionCommand = async (o
     }
     return contents;
 };
-const deserializeAws_restJson1UpdateClusterKafkaVersionCommandError = async (output, context) => {
+const de_UpdateClusterKafkaVersionCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2305,25 +2287,25 @@ const deserializeAws_restJson1UpdateClusterKafkaVersionCommandError = async (out
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.kafka#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "ForbiddenException":
         case "com.amazonaws.kafka#ForbiddenException":
-            throw await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context);
+            throw await de_ForbiddenExceptionRes(parsedOutput, context);
         case "InternalServerErrorException":
         case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.kafka#NotFoundException":
-            throw await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.kafka#ServiceUnavailableException":
-            throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         case "TooManyRequestsException":
         case "com.amazonaws.kafka#TooManyRequestsException":
-            throw await deserializeAws_restJson1TooManyRequestsExceptionResponse(parsedOutput, context);
+            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
         case "UnauthorizedException":
         case "com.amazonaws.kafka#UnauthorizedException":
-            throw await deserializeAws_restJson1UnauthorizedExceptionResponse(parsedOutput, context);
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2334,9 +2316,9 @@ const deserializeAws_restJson1UpdateClusterKafkaVersionCommandError = async (out
             });
     }
 };
-export const deserializeAws_restJson1UpdateConfigurationCommand = async (output, context) => {
+export const de_UpdateConfigurationCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1UpdateConfigurationCommandError(output, context);
+        return de_UpdateConfigurationCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -2346,11 +2328,11 @@ export const deserializeAws_restJson1UpdateConfigurationCommand = async (output,
         contents.Arn = __expectString(data.arn);
     }
     if (data.latestRevision != null) {
-        contents.LatestRevision = deserializeAws_restJson1ConfigurationRevision(data.latestRevision, context);
+        contents.LatestRevision = de_ConfigurationRevision(data.latestRevision, context);
     }
     return contents;
 };
-const deserializeAws_restJson1UpdateConfigurationCommandError = async (output, context) => {
+const de_UpdateConfigurationCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2359,22 +2341,22 @@ const deserializeAws_restJson1UpdateConfigurationCommandError = async (output, c
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.kafka#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "ForbiddenException":
         case "com.amazonaws.kafka#ForbiddenException":
-            throw await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context);
+            throw await de_ForbiddenExceptionRes(parsedOutput, context);
         case "InternalServerErrorException":
         case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.kafka#NotFoundException":
-            throw await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.kafka#ServiceUnavailableException":
-            throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         case "UnauthorizedException":
         case "com.amazonaws.kafka#UnauthorizedException":
-            throw await deserializeAws_restJson1UnauthorizedExceptionResponse(parsedOutput, context);
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2385,9 +2367,9 @@ const deserializeAws_restJson1UpdateConfigurationCommandError = async (output, c
             });
     }
 };
-export const deserializeAws_restJson1UpdateConnectivityCommand = async (output, context) => {
+export const de_UpdateConnectivityCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1UpdateConnectivityCommandError(output, context);
+        return de_UpdateConnectivityCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -2401,7 +2383,7 @@ export const deserializeAws_restJson1UpdateConnectivityCommand = async (output,
     }
     return contents;
 };
-const deserializeAws_restJson1UpdateConnectivityCommandError = async (output, context) => {
+const de_UpdateConnectivityCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2410,22 +2392,22 @@ const deserializeAws_restJson1UpdateConnectivityCommandError = async (output, co
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.kafka#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "ForbiddenException":
         case "com.amazonaws.kafka#ForbiddenException":
-            throw await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context);
+            throw await de_ForbiddenExceptionRes(parsedOutput, context);
         case "InternalServerErrorException":
         case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.kafka#NotFoundException":
-            throw await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.kafka#ServiceUnavailableException":
-            throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         case "UnauthorizedException":
         case "com.amazonaws.kafka#UnauthorizedException":
-            throw await deserializeAws_restJson1UnauthorizedExceptionResponse(parsedOutput, context);
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2436,9 +2418,9 @@ const deserializeAws_restJson1UpdateConnectivityCommandError = async (output, co
             });
     }
 };
-export const deserializeAws_restJson1UpdateMonitoringCommand = async (output, context) => {
+export const de_UpdateMonitoringCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1UpdateMonitoringCommandError(output, context);
+        return de_UpdateMonitoringCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -2452,7 +2434,7 @@ export const deserializeAws_restJson1UpdateMonitoringCommand = async (output, co
     }
     return contents;
 };
-const deserializeAws_restJson1UpdateMonitoringCommandError = async (output, context) => {
+const de_UpdateMonitoringCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2461,19 +2443,19 @@ const deserializeAws_restJson1UpdateMonitoringCommandError = async (output, cont
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.kafka#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "ForbiddenException":
         case "com.amazonaws.kafka#ForbiddenException":
-            throw await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context);
+            throw await de_ForbiddenExceptionRes(parsedOutput, context);
         case "InternalServerErrorException":
         case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.kafka#ServiceUnavailableException":
-            throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         case "UnauthorizedException":
         case "com.amazonaws.kafka#UnauthorizedException":
-            throw await deserializeAws_restJson1UnauthorizedExceptionResponse(parsedOutput, context);
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2484,9 +2466,9 @@ const deserializeAws_restJson1UpdateMonitoringCommandError = async (output, cont
             });
     }
 };
-export const deserializeAws_restJson1UpdateSecurityCommand = async (output, context) => {
+export const de_UpdateSecurityCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1UpdateSecurityCommandError(output, context);
+        return de_UpdateSecurityCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -2500,7 +2482,7 @@ export const deserializeAws_restJson1UpdateSecurityCommand = async (output, cont
     }
     return contents;
 };
-const deserializeAws_restJson1UpdateSecurityCommandError = async (output, context) => {
+const de_UpdateSecurityCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2509,25 +2491,25 @@ const deserializeAws_restJson1UpdateSecurityCommandError = async (output, contex
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.kafka#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "ForbiddenException":
         case "com.amazonaws.kafka#ForbiddenException":
-            throw await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context);
+            throw await de_ForbiddenExceptionRes(parsedOutput, context);
         case "InternalServerErrorException":
         case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.kafka#NotFoundException":
-            throw await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.kafka#ServiceUnavailableException":
-            throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         case "TooManyRequestsException":
         case "com.amazonaws.kafka#TooManyRequestsException":
-            throw await deserializeAws_restJson1TooManyRequestsExceptionResponse(parsedOutput, context);
+            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
         case "UnauthorizedException":
         case "com.amazonaws.kafka#UnauthorizedException":
-            throw await deserializeAws_restJson1UnauthorizedExceptionResponse(parsedOutput, context);
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2538,9 +2520,9 @@ const deserializeAws_restJson1UpdateSecurityCommandError = async (output, contex
             });
     }
 };
-export const deserializeAws_restJson1UpdateStorageCommand = async (output, context) => {
+export const de_UpdateStorageCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1UpdateStorageCommandError(output, context);
+        return de_UpdateStorageCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -2554,7 +2536,7 @@ export const deserializeAws_restJson1UpdateStorageCommand = async (output, conte
     }
     return contents;
 };
-const deserializeAws_restJson1UpdateStorageCommandError = async (output, context) => {
+const de_UpdateStorageCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2563,25 +2545,25 @@ const deserializeAws_restJson1UpdateStorageCommandError = async (output, context
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.kafka#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "ForbiddenException":
         case "com.amazonaws.kafka#ForbiddenException":
-            throw await deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context);
+            throw await de_ForbiddenExceptionRes(parsedOutput, context);
         case "InternalServerErrorException":
         case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await deserializeAws_restJson1InternalServerErrorExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.kafka#NotFoundException":
-            throw await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.kafka#ServiceUnavailableException":
-            throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         case "TooManyRequestsException":
         case "com.amazonaws.kafka#TooManyRequestsException":
-            throw await deserializeAws_restJson1TooManyRequestsExceptionResponse(parsedOutput, context);
+            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
         case "UnauthorizedException":
         case "com.amazonaws.kafka#UnauthorizedException":
-            throw await deserializeAws_restJson1UnauthorizedExceptionResponse(parsedOutput, context);
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2593,7 +2575,7 @@ const deserializeAws_restJson1UpdateStorageCommandError = async (output, context
     }
 };
 const map = __map;
-const deserializeAws_restJson1BadRequestExceptionResponse = async (parsedOutput, context) => {
+const de_BadRequestExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     if (data.invalidParameter != null) {
@@ -2608,7 +2590,7 @@ const deserializeAws_restJson1BadRequestExceptionResponse = async (parsedOutput,
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const deserializeAws_restJson1ConflictExceptionResponse = async (parsedOutput, context) => {
+const de_ConflictExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     if (data.invalidParameter != null) {
@@ -2623,7 +2605,7 @@ const deserializeAws_restJson1ConflictExceptionResponse = async (parsedOutput, c
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const deserializeAws_restJson1ForbiddenExceptionResponse = async (parsedOutput, context) => {
+const de_ForbiddenExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     if (data.invalidParameter != null) {
@@ -2638,7 +2620,7 @@ const deserializeAws_restJson1ForbiddenExceptionResponse = async (parsedOutput,
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const deserializeAws_restJson1InternalServerErrorExceptionResponse = async (parsedOutput, context) => {
+const de_InternalServerErrorExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     if (data.invalidParameter != null) {
@@ -2653,7 +2635,7 @@ const deserializeAws_restJson1InternalServerErrorExceptionResponse = async (pars
     });
     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.invalidParameter != null) {
@@ -2668,7 +2650,7 @@ const deserializeAws_restJson1NotFoundExceptionResponse = async (parsedOutput, c
     });
     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.invalidParameter != null) {
@@ -2683,7 +2665,7 @@ const deserializeAws_restJson1ServiceUnavailableExceptionResponse = async (parse
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const deserializeAws_restJson1TooManyRequestsExceptionResponse = async (parsedOutput, context) => {
+const de_TooManyRequestsExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     if (data.invalidParameter != null) {
@@ -2698,7 +2680,7 @@ const deserializeAws_restJson1TooManyRequestsExceptionResponse = async (parsedOu
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const deserializeAws_restJson1UnauthorizedExceptionResponse = async (parsedOutput, context) => {
+const de_UnauthorizedExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     if (data.invalidParameter != null) {
@@ -2713,28 +2695,28 @@ const deserializeAws_restJson1UnauthorizedExceptionResponse = async (parsedOutpu
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const serializeAws_restJson1__listOf__string = (input, context) => {
+const se___listOf__string = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
         return entry;
     });
 };
-const serializeAws_restJson1__listOfBrokerEBSVolumeInfo = (input, context) => {
+const se___listOfBrokerEBSVolumeInfo = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
-        return serializeAws_restJson1BrokerEBSVolumeInfo(entry, context);
+        return se_BrokerEBSVolumeInfo(entry, context);
     });
 };
-const serializeAws_restJson1__listOfVpcConfig = (input, context) => {
+const se___listOfVpcConfig = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
-        return serializeAws_restJson1VpcConfig(entry, context);
+        return se_VpcConfig(entry, context);
     });
 };
-const serializeAws_restJson1__mapOf__string = (input, context) => {
+const se___mapOf__string = (input, context) => {
     return Object.entries(input).reduce((acc, [key, value]) => {
         if (value === null) {
             return acc;
@@ -2743,238 +2725,212 @@ const serializeAws_restJson1__mapOf__string = (input, context) => {
         return acc;
     }, {});
 };
-const serializeAws_restJson1BrokerEBSVolumeInfo = (input, context) => {
+const se_BrokerEBSVolumeInfo = (input, context) => {
     return {
         ...(input.KafkaBrokerNodeId != null && { kafkaBrokerNodeId: input.KafkaBrokerNodeId }),
         ...(input.ProvisionedThroughput != null && {
-            provisionedThroughput: serializeAws_restJson1ProvisionedThroughput(input.ProvisionedThroughput, context),
+            provisionedThroughput: se_ProvisionedThroughput(input.ProvisionedThroughput, context),
         }),
         ...(input.VolumeSizeGB != null && { volumeSizeGB: input.VolumeSizeGB }),
     };
 };
-const serializeAws_restJson1BrokerLogs = (input, context) => {
+const se_BrokerLogs = (input, context) => {
     return {
-        ...(input.CloudWatchLogs != null && {
-            cloudWatchLogs: serializeAws_restJson1CloudWatchLogs(input.CloudWatchLogs, context),
-        }),
-        ...(input.Firehose != null && { firehose: serializeAws_restJson1Firehose(input.Firehose, context) }),
-        ...(input.S3 != null && { s3: serializeAws_restJson1S3(input.S3, context) }),
+        ...(input.CloudWatchLogs != null && { cloudWatchLogs: se_CloudWatchLogs(input.CloudWatchLogs, context) }),
+        ...(input.Firehose != null && { firehose: se_Firehose(input.Firehose, context) }),
+        ...(input.S3 != null && { s3: se_S3(input.S3, context) }),
     };
 };
-const serializeAws_restJson1BrokerNodeGroupInfo = (input, context) => {
+const se_BrokerNodeGroupInfo = (input, context) => {
     return {
         ...(input.BrokerAZDistribution != null && { brokerAZDistribution: input.BrokerAZDistribution }),
-        ...(input.ClientSubnets != null && {
-            clientSubnets: serializeAws_restJson1__listOf__string(input.ClientSubnets, context),
-        }),
-        ...(input.ConnectivityInfo != null && {
-            connectivityInfo: serializeAws_restJson1ConnectivityInfo(input.ConnectivityInfo, context),
-        }),
+        ...(input.ClientSubnets != null && { clientSubnets: se___listOf__string(input.ClientSubnets, context) }),
+        ...(input.ConnectivityInfo != null && { connectivityInfo: se_ConnectivityInfo(input.ConnectivityInfo, context) }),
         ...(input.InstanceType != null && { instanceType: input.InstanceType }),
-        ...(input.SecurityGroups != null && {
-            securityGroups: serializeAws_restJson1__listOf__string(input.SecurityGroups, context),
-        }),
-        ...(input.StorageInfo != null && { storageInfo: serializeAws_restJson1StorageInfo(input.StorageInfo, context) }),
+        ...(input.SecurityGroups != null && { securityGroups: se___listOf__string(input.SecurityGroups, context) }),
+        ...(input.StorageInfo != null && { storageInfo: se_StorageInfo(input.StorageInfo, context) }),
     };
 };
-const serializeAws_restJson1ClientAuthentication = (input, context) => {
+const se_ClientAuthentication = (input, context) => {
     return {
-        ...(input.Sasl != null && { sasl: serializeAws_restJson1Sasl(input.Sasl, context) }),
-        ...(input.Tls != null && { tls: serializeAws_restJson1Tls(input.Tls, context) }),
-        ...(input.Unauthenticated != null && {
-            unauthenticated: serializeAws_restJson1Unauthenticated(input.Unauthenticated, context),
-        }),
+        ...(input.Sasl != null && { sasl: se_Sasl(input.Sasl, context) }),
+        ...(input.Tls != null && { tls: se_Tls(input.Tls, context) }),
+        ...(input.Unauthenticated != null && { unauthenticated: se_Unauthenticated(input.Unauthenticated, context) }),
     };
 };
-const serializeAws_restJson1CloudWatchLogs = (input, context) => {
+const se_CloudWatchLogs = (input, context) => {
     return {
         ...(input.Enabled != null && { enabled: input.Enabled }),
         ...(input.LogGroup != null && { logGroup: input.LogGroup }),
     };
 };
-const serializeAws_restJson1ConfigurationInfo = (input, context) => {
+const se_ConfigurationInfo = (input, context) => {
     return {
         ...(input.Arn != null && { arn: input.Arn }),
         ...(input.Revision != null && { revision: input.Revision }),
     };
 };
-const serializeAws_restJson1ConnectivityInfo = (input, context) => {
+const se_ConnectivityInfo = (input, context) => {
     return {
-        ...(input.PublicAccess != null && {
-            publicAccess: serializeAws_restJson1PublicAccess(input.PublicAccess, context),
-        }),
+        ...(input.PublicAccess != null && { publicAccess: se_PublicAccess(input.PublicAccess, context) }),
     };
 };
-const serializeAws_restJson1EBSStorageInfo = (input, context) => {
+const se_EBSStorageInfo = (input, context) => {
     return {
         ...(input.ProvisionedThroughput != null && {
-            provisionedThroughput: serializeAws_restJson1ProvisionedThroughput(input.ProvisionedThroughput, context),
+            provisionedThroughput: se_ProvisionedThroughput(input.ProvisionedThroughput, context),
         }),
         ...(input.VolumeSize != null && { volumeSize: input.VolumeSize }),
     };
 };
-const serializeAws_restJson1EncryptionAtRest = (input, context) => {
+const se_EncryptionAtRest = (input, context) => {
     return {
         ...(input.DataVolumeKMSKeyId != null && { dataVolumeKMSKeyId: input.DataVolumeKMSKeyId }),
     };
 };
-const serializeAws_restJson1EncryptionInfo = (input, context) => {
+const se_EncryptionInfo = (input, context) => {
     return {
-        ...(input.EncryptionAtRest != null && {
-            encryptionAtRest: serializeAws_restJson1EncryptionAtRest(input.EncryptionAtRest, context),
-        }),
+        ...(input.EncryptionAtRest != null && { encryptionAtRest: se_EncryptionAtRest(input.EncryptionAtRest, context) }),
         ...(input.EncryptionInTransit != null && {
-            encryptionInTransit: serializeAws_restJson1EncryptionInTransit(input.EncryptionInTransit, context),
+            encryptionInTransit: se_EncryptionInTransit(input.EncryptionInTransit, context),
         }),
     };
 };
-const serializeAws_restJson1EncryptionInTransit = (input, context) => {
+const se_EncryptionInTransit = (input, context) => {
     return {
         ...(input.ClientBroker != null && { clientBroker: input.ClientBroker }),
         ...(input.InCluster != null && { inCluster: input.InCluster }),
     };
 };
-const serializeAws_restJson1Firehose = (input, context) => {
+const se_Firehose = (input, context) => {
     return {
         ...(input.DeliveryStream != null && { deliveryStream: input.DeliveryStream }),
         ...(input.Enabled != null && { enabled: input.Enabled }),
     };
 };
-const serializeAws_restJson1Iam = (input, context) => {
+const se_Iam = (input, context) => {
     return {
         ...(input.Enabled != null && { enabled: input.Enabled }),
     };
 };
-const serializeAws_restJson1JmxExporterInfo = (input, context) => {
+const se_JmxExporterInfo = (input, context) => {
     return {
         ...(input.EnabledInBroker != null && { enabledInBroker: input.EnabledInBroker }),
     };
 };
-const serializeAws_restJson1LoggingInfo = (input, context) => {
+const se_LoggingInfo = (input, context) => {
     return {
-        ...(input.BrokerLogs != null && { brokerLogs: serializeAws_restJson1BrokerLogs(input.BrokerLogs, context) }),
+        ...(input.BrokerLogs != null && { brokerLogs: se_BrokerLogs(input.BrokerLogs, context) }),
     };
 };
-const serializeAws_restJson1NodeExporterInfo = (input, context) => {
+const se_NodeExporterInfo = (input, context) => {
     return {
         ...(input.EnabledInBroker != null && { enabledInBroker: input.EnabledInBroker }),
     };
 };
-const serializeAws_restJson1OpenMonitoringInfo = (input, context) => {
+const se_OpenMonitoringInfo = (input, context) => {
     return {
-        ...(input.Prometheus != null && { prometheus: serializeAws_restJson1PrometheusInfo(input.Prometheus, context) }),
+        ...(input.Prometheus != null && { prometheus: se_PrometheusInfo(input.Prometheus, context) }),
     };
 };
-const serializeAws_restJson1PrometheusInfo = (input, context) => {
+const se_PrometheusInfo = (input, context) => {
     return {
-        ...(input.JmxExporter != null && {
-            jmxExporter: serializeAws_restJson1JmxExporterInfo(input.JmxExporter, context),
-        }),
-        ...(input.NodeExporter != null && {
-            nodeExporter: serializeAws_restJson1NodeExporterInfo(input.NodeExporter, context),
-        }),
+        ...(input.JmxExporter != null && { jmxExporter: se_JmxExporterInfo(input.JmxExporter, context) }),
+        ...(input.NodeExporter != null && { nodeExporter: se_NodeExporterInfo(input.NodeExporter, context) }),
     };
 };
-const serializeAws_restJson1ProvisionedRequest = (input, context) => {
+const se_ProvisionedRequest = (input, context) => {
     return {
         ...(input.BrokerNodeGroupInfo != null && {
-            brokerNodeGroupInfo: serializeAws_restJson1BrokerNodeGroupInfo(input.BrokerNodeGroupInfo, context),
+            brokerNodeGroupInfo: se_BrokerNodeGroupInfo(input.BrokerNodeGroupInfo, context),
         }),
         ...(input.ClientAuthentication != null && {
-            clientAuthentication: serializeAws_restJson1ClientAuthentication(input.ClientAuthentication, context),
+            clientAuthentication: se_ClientAuthentication(input.ClientAuthentication, context),
         }),
         ...(input.ConfigurationInfo != null && {
-            configurationInfo: serializeAws_restJson1ConfigurationInfo(input.ConfigurationInfo, context),
-        }),
-        ...(input.EncryptionInfo != null && {
-            encryptionInfo: serializeAws_restJson1EncryptionInfo(input.EncryptionInfo, context),
+            configurationInfo: se_ConfigurationInfo(input.ConfigurationInfo, context),
         }),
+        ...(input.EncryptionInfo != null && { encryptionInfo: se_EncryptionInfo(input.EncryptionInfo, context) }),
         ...(input.EnhancedMonitoring != null && { enhancedMonitoring: input.EnhancedMonitoring }),
         ...(input.KafkaVersion != null && { kafkaVersion: input.KafkaVersion }),
-        ...(input.LoggingInfo != null && { loggingInfo: serializeAws_restJson1LoggingInfo(input.LoggingInfo, context) }),
+        ...(input.LoggingInfo != null && { loggingInfo: se_LoggingInfo(input.LoggingInfo, context) }),
         ...(input.NumberOfBrokerNodes != null && { numberOfBrokerNodes: input.NumberOfBrokerNodes }),
-        ...(input.OpenMonitoring != null && {
-            openMonitoring: serializeAws_restJson1OpenMonitoringInfo(input.OpenMonitoring, context),
-        }),
+        ...(input.OpenMonitoring != null && { openMonitoring: se_OpenMonitoringInfo(input.OpenMonitoring, context) }),
         ...(input.StorageMode != null && { storageMode: input.StorageMode }),
     };
 };
-const serializeAws_restJson1ProvisionedThroughput = (input, context) => {
+const se_ProvisionedThroughput = (input, context) => {
     return {
         ...(input.Enabled != null && { enabled: input.Enabled }),
         ...(input.VolumeThroughput != null && { volumeThroughput: input.VolumeThroughput }),
     };
 };
-const serializeAws_restJson1PublicAccess = (input, context) => {
+const se_PublicAccess = (input, context) => {
     return {
         ...(input.Type != null && { type: input.Type }),
     };
 };
-const serializeAws_restJson1S3 = (input, context) => {
+const se_S3 = (input, context) => {
     return {
         ...(input.Bucket != null && { bucket: input.Bucket }),
         ...(input.Enabled != null && { enabled: input.Enabled }),
         ...(input.Prefix != null && { prefix: input.Prefix }),
     };
 };
-const serializeAws_restJson1Sasl = (input, context) => {
+const se_Sasl = (input, context) => {
     return {
-        ...(input.Iam != null && { iam: serializeAws_restJson1Iam(input.Iam, context) }),
-        ...(input.Scram != null && { scram: serializeAws_restJson1Scram(input.Scram, context) }),
+        ...(input.Iam != null && { iam: se_Iam(input.Iam, context) }),
+        ...(input.Scram != null && { scram: se_Scram(input.Scram, context) }),
     };
 };
-const serializeAws_restJson1Scram = (input, context) => {
+const se_Scram = (input, context) => {
     return {
         ...(input.Enabled != null && { enabled: input.Enabled }),
     };
 };
-const serializeAws_restJson1ServerlessClientAuthentication = (input, context) => {
+const se_ServerlessClientAuthentication = (input, context) => {
     return {
-        ...(input.Sasl != null && { sasl: serializeAws_restJson1ServerlessSasl(input.Sasl, context) }),
+        ...(input.Sasl != null && { sasl: se_ServerlessSasl(input.Sasl, context) }),
     };
 };
-const serializeAws_restJson1ServerlessRequest = (input, context) => {
+const se_ServerlessRequest = (input, context) => {
     return {
         ...(input.ClientAuthentication != null && {
-            clientAuthentication: serializeAws_restJson1ServerlessClientAuthentication(input.ClientAuthentication, context),
+            clientAuthentication: se_ServerlessClientAuthentication(input.ClientAuthentication, context),
         }),
-        ...(input.VpcConfigs != null && { vpcConfigs: serializeAws_restJson1__listOfVpcConfig(input.VpcConfigs, context) }),
+        ...(input.VpcConfigs != null && { vpcConfigs: se___listOfVpcConfig(input.VpcConfigs, context) }),
     };
 };
-const serializeAws_restJson1ServerlessSasl = (input, context) => {
+const se_ServerlessSasl = (input, context) => {
     return {
-        ...(input.Iam != null && { iam: serializeAws_restJson1Iam(input.Iam, context) }),
+        ...(input.Iam != null && { iam: se_Iam(input.Iam, context) }),
     };
 };
-const serializeAws_restJson1StorageInfo = (input, context) => {
+const se_StorageInfo = (input, context) => {
     return {
-        ...(input.EbsStorageInfo != null && {
-            ebsStorageInfo: serializeAws_restJson1EBSStorageInfo(input.EbsStorageInfo, context),
-        }),
+        ...(input.EbsStorageInfo != null && { ebsStorageInfo: se_EBSStorageInfo(input.EbsStorageInfo, context) }),
     };
 };
-const serializeAws_restJson1Tls = (input, context) => {
+const se_Tls = (input, context) => {
     return {
         ...(input.CertificateAuthorityArnList != null && {
-            certificateAuthorityArnList: serializeAws_restJson1__listOf__string(input.CertificateAuthorityArnList, context),
+            certificateAuthorityArnList: se___listOf__string(input.CertificateAuthorityArnList, context),
         }),
         ...(input.Enabled != null && { enabled: input.Enabled }),
     };
 };
-const serializeAws_restJson1Unauthenticated = (input, context) => {
+const se_Unauthenticated = (input, context) => {
     return {
         ...(input.Enabled != null && { enabled: input.Enabled }),
     };
 };
-const serializeAws_restJson1VpcConfig = (input, context) => {
+const se_VpcConfig = (input, context) => {
     return {
-        ...(input.SecurityGroupIds != null && {
-            securityGroupIds: serializeAws_restJson1__listOf__string(input.SecurityGroupIds, context),
-        }),
-        ...(input.SubnetIds != null && { subnetIds: serializeAws_restJson1__listOf__string(input.SubnetIds, context) }),
+        ...(input.SecurityGroupIds != null && { securityGroupIds: se___listOf__string(input.SecurityGroupIds, context) }),
+        ...(input.SubnetIds != null && { subnetIds: se___listOf__string(input.SubnetIds, context) }),
     };
 };
-const deserializeAws_restJson1__listOf__string = (output, context) => {
+const de___listOf__string = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
@@ -2985,139 +2941,139 @@ const deserializeAws_restJson1__listOf__string = (output, context) => {
     });
     return retVal;
 };
-const deserializeAws_restJson1__listOfBrokerEBSVolumeInfo = (output, context) => {
+const de___listOfBrokerEBSVolumeInfo = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1BrokerEBSVolumeInfo(entry, context);
+        return de_BrokerEBSVolumeInfo(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1__listOfCluster = (output, context) => {
+const de___listOfCluster = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1Cluster(entry, context);
+        return de_Cluster(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1__listOfClusterInfo = (output, context) => {
+const de___listOfClusterInfo = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1ClusterInfo(entry, context);
+        return de_ClusterInfo(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1__listOfClusterOperationInfo = (output, context) => {
+const de___listOfClusterOperationInfo = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1ClusterOperationInfo(entry, context);
+        return de_ClusterOperationInfo(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1__listOfClusterOperationStep = (output, context) => {
+const de___listOfClusterOperationStep = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1ClusterOperationStep(entry, context);
+        return de_ClusterOperationStep(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1__listOfCompatibleKafkaVersion = (output, context) => {
+const de___listOfCompatibleKafkaVersion = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1CompatibleKafkaVersion(entry, context);
+        return de_CompatibleKafkaVersion(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1__listOfConfiguration = (output, context) => {
+const de___listOfConfiguration = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1Configuration(entry, context);
+        return de_Configuration(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1__listOfConfigurationRevision = (output, context) => {
+const de___listOfConfigurationRevision = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1ConfigurationRevision(entry, context);
+        return de_ConfigurationRevision(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1__listOfKafkaVersion = (output, context) => {
+const de___listOfKafkaVersion = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1KafkaVersion(entry, context);
+        return de_KafkaVersion(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1__listOfNodeInfo = (output, context) => {
+const de___listOfNodeInfo = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1NodeInfo(entry, context);
+        return de_NodeInfo(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1__listOfUnprocessedScramSecret = (output, context) => {
+const de___listOfUnprocessedScramSecret = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1UnprocessedScramSecret(entry, context);
+        return de_UnprocessedScramSecret(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1__listOfVpcConfig = (output, context) => {
+const de___listOfVpcConfig = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1VpcConfig(entry, context);
+        return de_VpcConfig(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1__mapOf__string = (output, context) => {
+const de___mapOf__string = (output, context) => {
     return Object.entries(output).reduce((acc, [key, value]) => {
         if (value === null) {
             return acc;
@@ -3126,75 +3082,65 @@ const deserializeAws_restJson1__mapOf__string = (output, context) => {
         return acc;
     }, {});
 };
-const deserializeAws_restJson1BrokerEBSVolumeInfo = (output, context) => {
+const de_BrokerEBSVolumeInfo = (output, context) => {
     return {
         KafkaBrokerNodeId: __expectString(output.kafkaBrokerNodeId),
         ProvisionedThroughput: output.provisionedThroughput != null
-            ? deserializeAws_restJson1ProvisionedThroughput(output.provisionedThroughput, context)
+            ? de_ProvisionedThroughput(output.provisionedThroughput, context)
             : undefined,
         VolumeSizeGB: __expectInt32(output.volumeSizeGB),
     };
 };
-const deserializeAws_restJson1BrokerLogs = (output, context) => {
+const de_BrokerLogs = (output, context) => {
     return {
-        CloudWatchLogs: output.cloudWatchLogs != null
-            ? deserializeAws_restJson1CloudWatchLogs(output.cloudWatchLogs, context)
-            : undefined,
-        Firehose: output.firehose != null ? deserializeAws_restJson1Firehose(output.firehose, context) : undefined,
-        S3: output.s3 != null ? deserializeAws_restJson1S3(output.s3, context) : undefined,
+        CloudWatchLogs: output.cloudWatchLogs != null ? de_CloudWatchLogs(output.cloudWatchLogs, context) : undefined,
+        Firehose: output.firehose != null ? de_Firehose(output.firehose, context) : undefined,
+        S3: output.s3 != null ? de_S3(output.s3, context) : undefined,
     };
 };
-const deserializeAws_restJson1BrokerNodeGroupInfo = (output, context) => {
+const de_BrokerNodeGroupInfo = (output, context) => {
     return {
         BrokerAZDistribution: __expectString(output.brokerAZDistribution),
-        ClientSubnets: output.clientSubnets != null
-            ? deserializeAws_restJson1__listOf__string(output.clientSubnets, context)
-            : undefined,
-        ConnectivityInfo: output.connectivityInfo != null
-            ? deserializeAws_restJson1ConnectivityInfo(output.connectivityInfo, context)
-            : undefined,
+        ClientSubnets: output.clientSubnets != null ? de___listOf__string(output.clientSubnets, context) : undefined,
+        ConnectivityInfo: output.connectivityInfo != null ? de_ConnectivityInfo(output.connectivityInfo, context) : undefined,
         InstanceType: __expectString(output.instanceType),
-        SecurityGroups: output.securityGroups != null
-            ? deserializeAws_restJson1__listOf__string(output.securityGroups, context)
-            : undefined,
-        StorageInfo: output.storageInfo != null ? deserializeAws_restJson1StorageInfo(output.storageInfo, context) : undefined,
+        SecurityGroups: output.securityGroups != null ? de___listOf__string(output.securityGroups, context) : undefined,
+        StorageInfo: output.storageInfo != null ? de_StorageInfo(output.storageInfo, context) : undefined,
     };
 };
-const deserializeAws_restJson1BrokerNodeInfo = (output, context) => {
+const de_BrokerNodeInfo = (output, context) => {
     return {
         AttachedENIId: __expectString(output.attachedENIId),
         BrokerId: __limitedParseDouble(output.brokerId),
         ClientSubnet: __expectString(output.clientSubnet),
         ClientVpcIpAddress: __expectString(output.clientVpcIpAddress),
         CurrentBrokerSoftwareInfo: output.currentBrokerSoftwareInfo != null
-            ? deserializeAws_restJson1BrokerSoftwareInfo(output.currentBrokerSoftwareInfo, context)
+            ? de_BrokerSoftwareInfo(output.currentBrokerSoftwareInfo, context)
             : undefined,
-        Endpoints: output.endpoints != null ? deserializeAws_restJson1__listOf__string(output.endpoints, context) : undefined,
+        Endpoints: output.endpoints != null ? de___listOf__string(output.endpoints, context) : undefined,
     };
 };
-const deserializeAws_restJson1BrokerSoftwareInfo = (output, context) => {
+const de_BrokerSoftwareInfo = (output, context) => {
     return {
         ConfigurationArn: __expectString(output.configurationArn),
         ConfigurationRevision: __expectLong(output.configurationRevision),
         KafkaVersion: __expectString(output.kafkaVersion),
     };
 };
-const deserializeAws_restJson1ClientAuthentication = (output, context) => {
+const de_ClientAuthentication = (output, context) => {
     return {
-        Sasl: output.sasl != null ? deserializeAws_restJson1Sasl(output.sasl, context) : undefined,
-        Tls: output.tls != null ? deserializeAws_restJson1Tls(output.tls, context) : undefined,
-        Unauthenticated: output.unauthenticated != null
-            ? deserializeAws_restJson1Unauthenticated(output.unauthenticated, context)
-            : undefined,
+        Sasl: output.sasl != null ? de_Sasl(output.sasl, context) : undefined,
+        Tls: output.tls != null ? de_Tls(output.tls, context) : undefined,
+        Unauthenticated: output.unauthenticated != null ? de_Unauthenticated(output.unauthenticated, context) : undefined,
     };
 };
-const deserializeAws_restJson1CloudWatchLogs = (output, context) => {
+const de_CloudWatchLogs = (output, context) => {
     return {
         Enabled: __expectBoolean(output.enabled),
         LogGroup: __expectString(output.logGroup),
     };
 };
-const deserializeAws_restJson1Cluster = (output, context) => {
+const de_Cluster = (output, context) => {
     return {
         ActiveOperationArn: __expectString(output.activeOperationArn),
         ClusterArn: __expectString(output.clusterArn),
@@ -3202,378 +3148,328 @@ const deserializeAws_restJson1Cluster = (output, context) => {
         ClusterType: __expectString(output.clusterType),
         CreationTime: output.creationTime != null ? __expectNonNull(__parseRfc3339DateTimeWithOffset(output.creationTime)) : undefined,
         CurrentVersion: __expectString(output.currentVersion),
-        Provisioned: output.provisioned != null ? deserializeAws_restJson1Provisioned(output.provisioned, context) : undefined,
-        Serverless: output.serverless != null ? deserializeAws_restJson1Serverless(output.serverless, context) : undefined,
+        Provisioned: output.provisioned != null ? de_Provisioned(output.provisioned, context) : undefined,
+        Serverless: output.serverless != null ? de_Serverless(output.serverless, context) : undefined,
         State: __expectString(output.state),
-        StateInfo: output.stateInfo != null ? deserializeAws_restJson1StateInfo(output.stateInfo, context) : undefined,
-        Tags: output.tags != null ? deserializeAws_restJson1__mapOf__string(output.tags, context) : undefined,
+        StateInfo: output.stateInfo != null ? de_StateInfo(output.stateInfo, context) : undefined,
+        Tags: output.tags != null ? de___mapOf__string(output.tags, context) : undefined,
     };
 };
-const deserializeAws_restJson1ClusterInfo = (output, context) => {
+const de_ClusterInfo = (output, context) => {
     return {
         ActiveOperationArn: __expectString(output.activeOperationArn),
-        BrokerNodeGroupInfo: output.brokerNodeGroupInfo != null
-            ? deserializeAws_restJson1BrokerNodeGroupInfo(output.brokerNodeGroupInfo, context)
-            : undefined,
-        ClientAuthentication: output.clientAuthentication != null
-            ? deserializeAws_restJson1ClientAuthentication(output.clientAuthentication, context)
-            : undefined,
+        BrokerNodeGroupInfo: output.brokerNodeGroupInfo != null ? de_BrokerNodeGroupInfo(output.brokerNodeGroupInfo, context) : undefined,
+        ClientAuthentication: output.clientAuthentication != null ? de_ClientAuthentication(output.clientAuthentication, context) : undefined,
         ClusterArn: __expectString(output.clusterArn),
         ClusterName: __expectString(output.clusterName),
         CreationTime: output.creationTime != null ? __expectNonNull(__parseRfc3339DateTimeWithOffset(output.creationTime)) : undefined,
         CurrentBrokerSoftwareInfo: output.currentBrokerSoftwareInfo != null
-            ? deserializeAws_restJson1BrokerSoftwareInfo(output.currentBrokerSoftwareInfo, context)
+            ? de_BrokerSoftwareInfo(output.currentBrokerSoftwareInfo, context)
             : undefined,
         CurrentVersion: __expectString(output.currentVersion),
-        EncryptionInfo: output.encryptionInfo != null
-            ? deserializeAws_restJson1EncryptionInfo(output.encryptionInfo, context)
-            : undefined,
+        EncryptionInfo: output.encryptionInfo != null ? de_EncryptionInfo(output.encryptionInfo, context) : undefined,
         EnhancedMonitoring: __expectString(output.enhancedMonitoring),
-        LoggingInfo: output.loggingInfo != null ? deserializeAws_restJson1LoggingInfo(output.loggingInfo, context) : undefined,
+        LoggingInfo: output.loggingInfo != null ? de_LoggingInfo(output.loggingInfo, context) : undefined,
         NumberOfBrokerNodes: __expectInt32(output.numberOfBrokerNodes),
-        OpenMonitoring: output.openMonitoring != null
-            ? deserializeAws_restJson1OpenMonitoring(output.openMonitoring, context)
-            : undefined,
+        OpenMonitoring: output.openMonitoring != null ? de_OpenMonitoring(output.openMonitoring, context) : undefined,
         State: __expectString(output.state),
-        StateInfo: output.stateInfo != null ? deserializeAws_restJson1StateInfo(output.stateInfo, context) : undefined,
+        StateInfo: output.stateInfo != null ? de_StateInfo(output.stateInfo, context) : undefined,
         StorageMode: __expectString(output.storageMode),
-        Tags: output.tags != null ? deserializeAws_restJson1__mapOf__string(output.tags, context) : undefined,
+        Tags: output.tags != null ? de___mapOf__string(output.tags, context) : undefined,
         ZookeeperConnectString: __expectString(output.zookeeperConnectString),
         ZookeeperConnectStringTls: __expectString(output.zookeeperConnectStringTls),
     };
 };
-const deserializeAws_restJson1ClusterOperationInfo = (output, context) => {
+const de_ClusterOperationInfo = (output, context) => {
     return {
         ClientRequestId: __expectString(output.clientRequestId),
         ClusterArn: __expectString(output.clusterArn),
         CreationTime: output.creationTime != null ? __expectNonNull(__parseRfc3339DateTimeWithOffset(output.creationTime)) : undefined,
         EndTime: output.endTime != null ? __expectNonNull(__parseRfc3339DateTimeWithOffset(output.endTime)) : undefined,
-        ErrorInfo: output.errorInfo != null ? deserializeAws_restJson1ErrorInfo(output.errorInfo, context) : undefined,
+        ErrorInfo: output.errorInfo != null ? de_ErrorInfo(output.errorInfo, context) : undefined,
         OperationArn: __expectString(output.operationArn),
         OperationState: __expectString(output.operationState),
-        OperationSteps: output.operationSteps != null
-            ? deserializeAws_restJson1__listOfClusterOperationStep(output.operationSteps, context)
-            : undefined,
+        OperationSteps: output.operationSteps != null ? de___listOfClusterOperationStep(output.operationSteps, context) : undefined,
         OperationType: __expectString(output.operationType),
-        SourceClusterInfo: output.sourceClusterInfo != null
-            ? deserializeAws_restJson1MutableClusterInfo(output.sourceClusterInfo, context)
-            : undefined,
-        TargetClusterInfo: output.targetClusterInfo != null
-            ? deserializeAws_restJson1MutableClusterInfo(output.targetClusterInfo, context)
-            : undefined,
+        SourceClusterInfo: output.sourceClusterInfo != null ? de_MutableClusterInfo(output.sourceClusterInfo, context) : undefined,
+        TargetClusterInfo: output.targetClusterInfo != null ? de_MutableClusterInfo(output.targetClusterInfo, context) : undefined,
     };
 };
-const deserializeAws_restJson1ClusterOperationStep = (output, context) => {
+const de_ClusterOperationStep = (output, context) => {
     return {
-        StepInfo: output.stepInfo != null ? deserializeAws_restJson1ClusterOperationStepInfo(output.stepInfo, context) : undefined,
+        StepInfo: output.stepInfo != null ? de_ClusterOperationStepInfo(output.stepInfo, context) : undefined,
         StepName: __expectString(output.stepName),
     };
 };
-const deserializeAws_restJson1ClusterOperationStepInfo = (output, context) => {
+const de_ClusterOperationStepInfo = (output, context) => {
     return {
         StepStatus: __expectString(output.stepStatus),
     };
 };
-const deserializeAws_restJson1CompatibleKafkaVersion = (output, context) => {
+const de_CompatibleKafkaVersion = (output, context) => {
     return {
         SourceVersion: __expectString(output.sourceVersion),
-        TargetVersions: output.targetVersions != null
-            ? deserializeAws_restJson1__listOf__string(output.targetVersions, context)
-            : undefined,
+        TargetVersions: output.targetVersions != null ? de___listOf__string(output.targetVersions, context) : undefined,
     };
 };
-const deserializeAws_restJson1Configuration = (output, context) => {
+const de_Configuration = (output, context) => {
     return {
         Arn: __expectString(output.arn),
         CreationTime: output.creationTime != null ? __expectNonNull(__parseRfc3339DateTimeWithOffset(output.creationTime)) : undefined,
         Description: __expectString(output.description),
-        KafkaVersions: output.kafkaVersions != null
-            ? deserializeAws_restJson1__listOf__string(output.kafkaVersions, context)
-            : undefined,
-        LatestRevision: output.latestRevision != null
-            ? deserializeAws_restJson1ConfigurationRevision(output.latestRevision, context)
-            : undefined,
+        KafkaVersions: output.kafkaVersions != null ? de___listOf__string(output.kafkaVersions, context) : undefined,
+        LatestRevision: output.latestRevision != null ? de_ConfigurationRevision(output.latestRevision, context) : undefined,
         Name: __expectString(output.name),
         State: __expectString(output.state),
     };
 };
-const deserializeAws_restJson1ConfigurationInfo = (output, context) => {
+const de_ConfigurationInfo = (output, context) => {
     return {
         Arn: __expectString(output.arn),
         Revision: __expectLong(output.revision),
     };
 };
-const deserializeAws_restJson1ConfigurationRevision = (output, context) => {
+const de_ConfigurationRevision = (output, context) => {
     return {
         CreationTime: output.creationTime != null ? __expectNonNull(__parseRfc3339DateTimeWithOffset(output.creationTime)) : undefined,
         Description: __expectString(output.description),
         Revision: __expectLong(output.revision),
     };
 };
-const deserializeAws_restJson1ConnectivityInfo = (output, context) => {
+const de_ConnectivityInfo = (output, context) => {
     return {
-        PublicAccess: output.publicAccess != null ? deserializeAws_restJson1PublicAccess(output.publicAccess, context) : undefined,
+        PublicAccess: output.publicAccess != null ? de_PublicAccess(output.publicAccess, context) : undefined,
     };
 };
-const deserializeAws_restJson1EBSStorageInfo = (output, context) => {
+const de_EBSStorageInfo = (output, context) => {
     return {
         ProvisionedThroughput: output.provisionedThroughput != null
-            ? deserializeAws_restJson1ProvisionedThroughput(output.provisionedThroughput, context)
+            ? de_ProvisionedThroughput(output.provisionedThroughput, context)
             : undefined,
         VolumeSize: __expectInt32(output.volumeSize),
     };
 };
-const deserializeAws_restJson1EncryptionAtRest = (output, context) => {
+const de_EncryptionAtRest = (output, context) => {
     return {
         DataVolumeKMSKeyId: __expectString(output.dataVolumeKMSKeyId),
     };
 };
-const deserializeAws_restJson1EncryptionInfo = (output, context) => {
+const de_EncryptionInfo = (output, context) => {
     return {
-        EncryptionAtRest: output.encryptionAtRest != null
-            ? deserializeAws_restJson1EncryptionAtRest(output.encryptionAtRest, context)
-            : undefined,
-        EncryptionInTransit: output.encryptionInTransit != null
-            ? deserializeAws_restJson1EncryptionInTransit(output.encryptionInTransit, context)
-            : undefined,
+        EncryptionAtRest: output.encryptionAtRest != null ? de_EncryptionAtRest(output.encryptionAtRest, context) : undefined,
+        EncryptionInTransit: output.encryptionInTransit != null ? de_EncryptionInTransit(output.encryptionInTransit, context) : undefined,
     };
 };
-const deserializeAws_restJson1EncryptionInTransit = (output, context) => {
+const de_EncryptionInTransit = (output, context) => {
     return {
         ClientBroker: __expectString(output.clientBroker),
         InCluster: __expectBoolean(output.inCluster),
     };
 };
-const deserializeAws_restJson1ErrorInfo = (output, context) => {
+const de_ErrorInfo = (output, context) => {
     return {
         ErrorCode: __expectString(output.errorCode),
         ErrorString: __expectString(output.errorString),
     };
 };
-const deserializeAws_restJson1Firehose = (output, context) => {
+const de_Firehose = (output, context) => {
     return {
         DeliveryStream: __expectString(output.deliveryStream),
         Enabled: __expectBoolean(output.enabled),
     };
 };
-const deserializeAws_restJson1Iam = (output, context) => {
+const de_Iam = (output, context) => {
     return {
         Enabled: __expectBoolean(output.enabled),
     };
 };
-const deserializeAws_restJson1JmxExporter = (output, context) => {
+const de_JmxExporter = (output, context) => {
     return {
         EnabledInBroker: __expectBoolean(output.enabledInBroker),
     };
 };
-const deserializeAws_restJson1JmxExporterInfo = (output, context) => {
+const de_JmxExporterInfo = (output, context) => {
     return {
         EnabledInBroker: __expectBoolean(output.enabledInBroker),
     };
 };
-const deserializeAws_restJson1KafkaVersion = (output, context) => {
+const de_KafkaVersion = (output, context) => {
     return {
         Status: __expectString(output.status),
         Version: __expectString(output.version),
     };
 };
-const deserializeAws_restJson1LoggingInfo = (output, context) => {
+const de_LoggingInfo = (output, context) => {
     return {
-        BrokerLogs: output.brokerLogs != null ? deserializeAws_restJson1BrokerLogs(output.brokerLogs, context) : undefined,
+        BrokerLogs: output.brokerLogs != null ? de_BrokerLogs(output.brokerLogs, context) : undefined,
     };
 };
-const deserializeAws_restJson1MutableClusterInfo = (output, context) => {
+const de_MutableClusterInfo = (output, context) => {
     return {
         BrokerEBSVolumeInfo: output.brokerEBSVolumeInfo != null
-            ? deserializeAws_restJson1__listOfBrokerEBSVolumeInfo(output.brokerEBSVolumeInfo, context)
-            : undefined,
-        ClientAuthentication: output.clientAuthentication != null
-            ? deserializeAws_restJson1ClientAuthentication(output.clientAuthentication, context)
-            : undefined,
-        ConfigurationInfo: output.configurationInfo != null
-            ? deserializeAws_restJson1ConfigurationInfo(output.configurationInfo, context)
-            : undefined,
-        ConnectivityInfo: output.connectivityInfo != null
-            ? deserializeAws_restJson1ConnectivityInfo(output.connectivityInfo, context)
-            : undefined,
-        EncryptionInfo: output.encryptionInfo != null
-            ? deserializeAws_restJson1EncryptionInfo(output.encryptionInfo, context)
+            ? de___listOfBrokerEBSVolumeInfo(output.brokerEBSVolumeInfo, context)
             : undefined,
+        ClientAuthentication: output.clientAuthentication != null ? de_ClientAuthentication(output.clientAuthentication, context) : undefined,
+        ConfigurationInfo: output.configurationInfo != null ? de_ConfigurationInfo(output.configurationInfo, context) : undefined,
+        ConnectivityInfo: output.connectivityInfo != null ? de_ConnectivityInfo(output.connectivityInfo, context) : undefined,
+        EncryptionInfo: output.encryptionInfo != null ? de_EncryptionInfo(output.encryptionInfo, context) : undefined,
         EnhancedMonitoring: __expectString(output.enhancedMonitoring),
         InstanceType: __expectString(output.instanceType),
         KafkaVersion: __expectString(output.kafkaVersion),
-        LoggingInfo: output.loggingInfo != null ? deserializeAws_restJson1LoggingInfo(output.loggingInfo, context) : undefined,
+        LoggingInfo: output.loggingInfo != null ? de_LoggingInfo(output.loggingInfo, context) : undefined,
         NumberOfBrokerNodes: __expectInt32(output.numberOfBrokerNodes),
-        OpenMonitoring: output.openMonitoring != null
-            ? deserializeAws_restJson1OpenMonitoring(output.openMonitoring, context)
-            : undefined,
+        OpenMonitoring: output.openMonitoring != null ? de_OpenMonitoring(output.openMonitoring, context) : undefined,
         StorageMode: __expectString(output.storageMode),
     };
 };
-const deserializeAws_restJson1NodeExporter = (output, context) => {
+const de_NodeExporter = (output, context) => {
     return {
         EnabledInBroker: __expectBoolean(output.enabledInBroker),
     };
 };
-const deserializeAws_restJson1NodeExporterInfo = (output, context) => {
+const de_NodeExporterInfo = (output, context) => {
     return {
         EnabledInBroker: __expectBoolean(output.enabledInBroker),
     };
 };
-const deserializeAws_restJson1NodeInfo = (output, context) => {
+const de_NodeInfo = (output, context) => {
     return {
         AddedToClusterTime: __expectString(output.addedToClusterTime),
-        BrokerNodeInfo: output.brokerNodeInfo != null
-            ? deserializeAws_restJson1BrokerNodeInfo(output.brokerNodeInfo, context)
-            : undefined,
+        BrokerNodeInfo: output.brokerNodeInfo != null ? de_BrokerNodeInfo(output.brokerNodeInfo, context) : undefined,
         InstanceType: __expectString(output.instanceType),
         NodeARN: __expectString(output.nodeARN),
         NodeType: __expectString(output.nodeType),
-        ZookeeperNodeInfo: output.zookeeperNodeInfo != null
-            ? deserializeAws_restJson1ZookeeperNodeInfo(output.zookeeperNodeInfo, context)
-            : undefined,
+        ZookeeperNodeInfo: output.zookeeperNodeInfo != null ? de_ZookeeperNodeInfo(output.zookeeperNodeInfo, context) : undefined,
     };
 };
-const deserializeAws_restJson1OpenMonitoring = (output, context) => {
+const de_OpenMonitoring = (output, context) => {
     return {
-        Prometheus: output.prometheus != null ? deserializeAws_restJson1Prometheus(output.prometheus, context) : undefined,
+        Prometheus: output.prometheus != null ? de_Prometheus(output.prometheus, context) : undefined,
     };
 };
-const deserializeAws_restJson1OpenMonitoringInfo = (output, context) => {
+const de_OpenMonitoringInfo = (output, context) => {
     return {
-        Prometheus: output.prometheus != null ? deserializeAws_restJson1PrometheusInfo(output.prometheus, context) : undefined,
+        Prometheus: output.prometheus != null ? de_PrometheusInfo(output.prometheus, context) : undefined,
     };
 };
-const deserializeAws_restJson1Prometheus = (output, context) => {
+const de_Prometheus = (output, context) => {
     return {
-        JmxExporter: output.jmxExporter != null ? deserializeAws_restJson1JmxExporter(output.jmxExporter, context) : undefined,
-        NodeExporter: output.nodeExporter != null ? deserializeAws_restJson1NodeExporter(output.nodeExporter, context) : undefined,
+        JmxExporter: output.jmxExporter != null ? de_JmxExporter(output.jmxExporter, context) : undefined,
+        NodeExporter: output.nodeExporter != null ? de_NodeExporter(output.nodeExporter, context) : undefined,
     };
 };
-const deserializeAws_restJson1PrometheusInfo = (output, context) => {
+const de_PrometheusInfo = (output, context) => {
     return {
-        JmxExporter: output.jmxExporter != null ? deserializeAws_restJson1JmxExporterInfo(output.jmxExporter, context) : undefined,
-        NodeExporter: output.nodeExporter != null ? deserializeAws_restJson1NodeExporterInfo(output.nodeExporter, context) : undefined,
+        JmxExporter: output.jmxExporter != null ? de_JmxExporterInfo(output.jmxExporter, context) : undefined,
+        NodeExporter: output.nodeExporter != null ? de_NodeExporterInfo(output.nodeExporter, context) : undefined,
     };
 };
-const deserializeAws_restJson1Provisioned = (output, context) => {
+const de_Provisioned = (output, context) => {
     return {
-        BrokerNodeGroupInfo: output.brokerNodeGroupInfo != null
-            ? deserializeAws_restJson1BrokerNodeGroupInfo(output.brokerNodeGroupInfo, context)
-            : undefined,
-        ClientAuthentication: output.clientAuthentication != null
-            ? deserializeAws_restJson1ClientAuthentication(output.clientAuthentication, context)
-            : undefined,
+        BrokerNodeGroupInfo: output.brokerNodeGroupInfo != null ? de_BrokerNodeGroupInfo(output.brokerNodeGroupInfo, context) : undefined,
+        ClientAuthentication: output.clientAuthentication != null ? de_ClientAuthentication(output.clientAuthentication, context) : undefined,
         CurrentBrokerSoftwareInfo: output.currentBrokerSoftwareInfo != null
-            ? deserializeAws_restJson1BrokerSoftwareInfo(output.currentBrokerSoftwareInfo, context)
-            : undefined,
-        EncryptionInfo: output.encryptionInfo != null
-            ? deserializeAws_restJson1EncryptionInfo(output.encryptionInfo, context)
+            ? de_BrokerSoftwareInfo(output.currentBrokerSoftwareInfo, context)
             : undefined,
+        EncryptionInfo: output.encryptionInfo != null ? de_EncryptionInfo(output.encryptionInfo, context) : undefined,
         EnhancedMonitoring: __expectString(output.enhancedMonitoring),
-        LoggingInfo: output.loggingInfo != null ? deserializeAws_restJson1LoggingInfo(output.loggingInfo, context) : undefined,
+        LoggingInfo: output.loggingInfo != null ? de_LoggingInfo(output.loggingInfo, context) : undefined,
         NumberOfBrokerNodes: __expectInt32(output.numberOfBrokerNodes),
-        OpenMonitoring: output.openMonitoring != null
-            ? deserializeAws_restJson1OpenMonitoringInfo(output.openMonitoring, context)
-            : undefined,
+        OpenMonitoring: output.openMonitoring != null ? de_OpenMonitoringInfo(output.openMonitoring, context) : undefined,
         StorageMode: __expectString(output.storageMode),
         ZookeeperConnectString: __expectString(output.zookeeperConnectString),
         ZookeeperConnectStringTls: __expectString(output.zookeeperConnectStringTls),
     };
 };
-const deserializeAws_restJson1ProvisionedThroughput = (output, context) => {
+const de_ProvisionedThroughput = (output, context) => {
     return {
         Enabled: __expectBoolean(output.enabled),
         VolumeThroughput: __expectInt32(output.volumeThroughput),
     };
 };
-const deserializeAws_restJson1PublicAccess = (output, context) => {
+const de_PublicAccess = (output, context) => {
     return {
         Type: __expectString(output.type),
     };
 };
-const deserializeAws_restJson1S3 = (output, context) => {
+const de_S3 = (output, context) => {
     return {
         Bucket: __expectString(output.bucket),
         Enabled: __expectBoolean(output.enabled),
         Prefix: __expectString(output.prefix),
     };
 };
-const deserializeAws_restJson1Sasl = (output, context) => {
+const de_Sasl = (output, context) => {
     return {
-        Iam: output.iam != null ? deserializeAws_restJson1Iam(output.iam, context) : undefined,
-        Scram: output.scram != null ? deserializeAws_restJson1Scram(output.scram, context) : undefined,
+        Iam: output.iam != null ? de_Iam(output.iam, context) : undefined,
+        Scram: output.scram != null ? de_Scram(output.scram, context) : undefined,
     };
 };
-const deserializeAws_restJson1Scram = (output, context) => {
+const de_Scram = (output, context) => {
     return {
         Enabled: __expectBoolean(output.enabled),
     };
 };
-const deserializeAws_restJson1Serverless = (output, context) => {
+const de_Serverless = (output, context) => {
     return {
         ClientAuthentication: output.clientAuthentication != null
-            ? deserializeAws_restJson1ServerlessClientAuthentication(output.clientAuthentication, context)
+            ? de_ServerlessClientAuthentication(output.clientAuthentication, context)
             : undefined,
-        VpcConfigs: output.vpcConfigs != null ? deserializeAws_restJson1__listOfVpcConfig(output.vpcConfigs, context) : undefined,
+        VpcConfigs: output.vpcConfigs != null ? de___listOfVpcConfig(output.vpcConfigs, context) : undefined,
     };
 };
-const deserializeAws_restJson1ServerlessClientAuthentication = (output, context) => {
+const de_ServerlessClientAuthentication = (output, context) => {
     return {
-        Sasl: output.sasl != null ? deserializeAws_restJson1ServerlessSasl(output.sasl, context) : undefined,
+        Sasl: output.sasl != null ? de_ServerlessSasl(output.sasl, context) : undefined,
     };
 };
-const deserializeAws_restJson1ServerlessSasl = (output, context) => {
+const de_ServerlessSasl = (output, context) => {
     return {
-        Iam: output.iam != null ? deserializeAws_restJson1Iam(output.iam, context) : undefined,
+        Iam: output.iam != null ? de_Iam(output.iam, context) : undefined,
     };
 };
-const deserializeAws_restJson1StateInfo = (output, context) => {
+const de_StateInfo = (output, context) => {
     return {
         Code: __expectString(output.code),
         Message: __expectString(output.message),
     };
 };
-const deserializeAws_restJson1StorageInfo = (output, context) => {
+const de_StorageInfo = (output, context) => {
     return {
-        EbsStorageInfo: output.ebsStorageInfo != null
-            ? deserializeAws_restJson1EBSStorageInfo(output.ebsStorageInfo, context)
-            : undefined,
+        EbsStorageInfo: output.ebsStorageInfo != null ? de_EBSStorageInfo(output.ebsStorageInfo, context) : undefined,
     };
 };
-const deserializeAws_restJson1Tls = (output, context) => {
+const de_Tls = (output, context) => {
     return {
         CertificateAuthorityArnList: output.certificateAuthorityArnList != null
-            ? deserializeAws_restJson1__listOf__string(output.certificateAuthorityArnList, context)
+            ? de___listOf__string(output.certificateAuthorityArnList, context)
             : undefined,
         Enabled: __expectBoolean(output.enabled),
     };
 };
-const deserializeAws_restJson1Unauthenticated = (output, context) => {
+const de_Unauthenticated = (output, context) => {
     return {
         Enabled: __expectBoolean(output.enabled),
     };
 };
-const deserializeAws_restJson1UnprocessedScramSecret = (output, context) => {
+const de_UnprocessedScramSecret = (output, context) => {
     return {
         ErrorCode: __expectString(output.errorCode),
         ErrorMessage: __expectString(output.errorMessage),
         SecretArn: __expectString(output.secretArn),
     };
 };
-const deserializeAws_restJson1VpcConfig = (output, context) => {
+const de_VpcConfig = (output, context) => {
     return {
-        SecurityGroupIds: output.securityGroupIds != null
-            ? deserializeAws_restJson1__listOf__string(output.securityGroupIds, context)
-            : undefined,
-        SubnetIds: output.subnetIds != null ? deserializeAws_restJson1__listOf__string(output.subnetIds, context) : undefined,
+        SecurityGroupIds: output.securityGroupIds != null ? de___listOf__string(output.securityGroupIds, context) : undefined,
+        SubnetIds: output.subnetIds != null ? de___listOf__string(output.subnetIds, context) : undefined,
     };
 };
-const deserializeAws_restJson1ZookeeperNodeInfo = (output, context) => {
+const de_ZookeeperNodeInfo = (output, context) => {
     return {
         AttachedENIId: __expectString(output.attachedENIId),
         ClientVpcIpAddress: __expectString(output.clientVpcIpAddress),
-        Endpoints: output.endpoints != null ? deserializeAws_restJson1__listOf__string(output.endpoints, context) : undefined,
+        Endpoints: output.endpoints != null ? de___listOf__string(output.endpoints, context) : undefined,
         ZookeeperId: __limitedParseDouble(output.zookeeperId),
         ZookeeperVersion: __expectString(output.zookeeperVersion),
     };