@aws-sdk/client-elasticsearch-service 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, expectNumber as __expectNumber, expectObject as __expectObject, expectString as __expectString, limitedParseDouble as __limitedParseDouble, map as __map, parseEpochTimestamp as __parseEpochTimestamp, resolvedPath as __resolvedPath, throwDefaultError, } from "@aws-sdk/smithy-client";
 import { ElasticsearchServiceServiceException as __BaseException } from "../models/ElasticsearchServiceServiceException";
 import { AccessDeniedException, BaseException, ConflictException, DisabledOperationException, InternalException, InvalidPaginationTokenException, InvalidTypeException, LimitExceededException, ResourceAlreadyExistsException, ResourceNotFoundException, ValidationException, } from "../models/models_0";
-export const serializeAws_restJson1AcceptInboundCrossClusterSearchConnectionCommand = async (input, context) => {
+export const se_AcceptInboundCrossClusterSearchConnectionCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
@@ -19,7 +19,7 @@ export const serializeAws_restJson1AcceptInboundCrossClusterSearchConnectionComm
         body,
     });
 };
-export const serializeAws_restJson1AddTagsCommand = async (input, context) => {
+export const se_AddTagsCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -28,7 +28,7 @@ export const serializeAws_restJson1AddTagsCommand = async (input, context) => {
     let body;
     body = JSON.stringify({
         ...(input.ARN != null && { ARN: input.ARN }),
-        ...(input.TagList != null && { TagList: serializeAws_restJson1TagList(input.TagList, context) }),
+        ...(input.TagList != null && { TagList: se_TagList(input.TagList, context) }),
     });
     return new __HttpRequest({
         protocol,
@@ -40,7 +40,7 @@ export const serializeAws_restJson1AddTagsCommand = async (input, context) => {
         body,
     });
 };
-export const serializeAws_restJson1AssociatePackageCommand = async (input, context) => {
+export const se_AssociatePackageCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
@@ -58,7 +58,7 @@ export const serializeAws_restJson1AssociatePackageCommand = async (input, conte
         body,
     });
 };
-export const serializeAws_restJson1AuthorizeVpcEndpointAccessCommand = async (input, context) => {
+export const se_AuthorizeVpcEndpointAccessCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -80,7 +80,7 @@ export const serializeAws_restJson1AuthorizeVpcEndpointAccessCommand = async (in
         body,
     });
 };
-export const serializeAws_restJson1CancelElasticsearchServiceSoftwareUpdateCommand = async (input, context) => {
+export const se_CancelElasticsearchServiceSoftwareUpdateCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -101,7 +101,7 @@ export const serializeAws_restJson1CancelElasticsearchServiceSoftwareUpdateComma
         body,
     });
 };
-export const serializeAws_restJson1CreateElasticsearchDomainCommand = async (input, context) => {
+export const se_CreateElasticsearchDomainCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -110,41 +110,33 @@ export const serializeAws_restJson1CreateElasticsearchDomainCommand = async (inp
     let body;
     body = JSON.stringify({
         ...(input.AccessPolicies != null && { AccessPolicies: input.AccessPolicies }),
-        ...(input.AdvancedOptions != null && {
-            AdvancedOptions: serializeAws_restJson1AdvancedOptions(input.AdvancedOptions, context),
-        }),
+        ...(input.AdvancedOptions != null && { AdvancedOptions: se_AdvancedOptions(input.AdvancedOptions, context) }),
         ...(input.AdvancedSecurityOptions != null && {
-            AdvancedSecurityOptions: serializeAws_restJson1AdvancedSecurityOptionsInput(input.AdvancedSecurityOptions, context),
-        }),
-        ...(input.AutoTuneOptions != null && {
-            AutoTuneOptions: serializeAws_restJson1AutoTuneOptionsInput(input.AutoTuneOptions, context),
-        }),
-        ...(input.CognitoOptions != null && {
-            CognitoOptions: serializeAws_restJson1CognitoOptions(input.CognitoOptions, context),
+            AdvancedSecurityOptions: se_AdvancedSecurityOptionsInput(input.AdvancedSecurityOptions, context),
         }),
+        ...(input.AutoTuneOptions != null && { AutoTuneOptions: se_AutoTuneOptionsInput(input.AutoTuneOptions, context) }),
+        ...(input.CognitoOptions != null && { CognitoOptions: se_CognitoOptions(input.CognitoOptions, context) }),
         ...(input.DomainEndpointOptions != null && {
-            DomainEndpointOptions: serializeAws_restJson1DomainEndpointOptions(input.DomainEndpointOptions, context),
+            DomainEndpointOptions: se_DomainEndpointOptions(input.DomainEndpointOptions, context),
         }),
         ...(input.DomainName != null && { DomainName: input.DomainName }),
-        ...(input.EBSOptions != null && { EBSOptions: serializeAws_restJson1EBSOptions(input.EBSOptions, context) }),
+        ...(input.EBSOptions != null && { EBSOptions: se_EBSOptions(input.EBSOptions, context) }),
         ...(input.ElasticsearchClusterConfig != null && {
-            ElasticsearchClusterConfig: serializeAws_restJson1ElasticsearchClusterConfig(input.ElasticsearchClusterConfig, context),
+            ElasticsearchClusterConfig: se_ElasticsearchClusterConfig(input.ElasticsearchClusterConfig, context),
         }),
         ...(input.ElasticsearchVersion != null && { ElasticsearchVersion: input.ElasticsearchVersion }),
         ...(input.EncryptionAtRestOptions != null && {
-            EncryptionAtRestOptions: serializeAws_restJson1EncryptionAtRestOptions(input.EncryptionAtRestOptions, context),
+            EncryptionAtRestOptions: se_EncryptionAtRestOptions(input.EncryptionAtRestOptions, context),
         }),
         ...(input.LogPublishingOptions != null && {
-            LogPublishingOptions: serializeAws_restJson1LogPublishingOptions(input.LogPublishingOptions, context),
+            LogPublishingOptions: se_LogPublishingOptions(input.LogPublishingOptions, context),
         }),
         ...(input.NodeToNodeEncryptionOptions != null && {
-            NodeToNodeEncryptionOptions: serializeAws_restJson1NodeToNodeEncryptionOptions(input.NodeToNodeEncryptionOptions, context),
+            NodeToNodeEncryptionOptions: se_NodeToNodeEncryptionOptions(input.NodeToNodeEncryptionOptions, context),
         }),
-        ...(input.SnapshotOptions != null && {
-            SnapshotOptions: serializeAws_restJson1SnapshotOptions(input.SnapshotOptions, context),
-        }),
-        ...(input.TagList != null && { TagList: serializeAws_restJson1TagList(input.TagList, context) }),
-        ...(input.VPCOptions != null && { VPCOptions: serializeAws_restJson1VPCOptions(input.VPCOptions, context) }),
+        ...(input.SnapshotOptions != null && { SnapshotOptions: se_SnapshotOptions(input.SnapshotOptions, context) }),
+        ...(input.TagList != null && { TagList: se_TagList(input.TagList, context) }),
+        ...(input.VPCOptions != null && { VPCOptions: se_VPCOptions(input.VPCOptions, context) }),
     });
     return new __HttpRequest({
         protocol,
@@ -156,7 +148,7 @@ export const serializeAws_restJson1CreateElasticsearchDomainCommand = async (inp
         body,
     });
 };
-export const serializeAws_restJson1CreateOutboundCrossClusterSearchConnectionCommand = async (input, context) => {
+export const se_CreateOutboundCrossClusterSearchConnectionCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -166,11 +158,9 @@ export const serializeAws_restJson1CreateOutboundCrossClusterSearchConnectionCom
     body = JSON.stringify({
         ...(input.ConnectionAlias != null && { ConnectionAlias: input.ConnectionAlias }),
         ...(input.DestinationDomainInfo != null && {
-            DestinationDomainInfo: serializeAws_restJson1DomainInformation(input.DestinationDomainInfo, context),
-        }),
-        ...(input.SourceDomainInfo != null && {
-            SourceDomainInfo: serializeAws_restJson1DomainInformation(input.SourceDomainInfo, context),
+            DestinationDomainInfo: se_DomainInformation(input.DestinationDomainInfo, context),
         }),
+        ...(input.SourceDomainInfo != null && { SourceDomainInfo: se_DomainInformation(input.SourceDomainInfo, context) }),
     });
     return new __HttpRequest({
         protocol,
@@ -182,7 +172,7 @@ export const serializeAws_restJson1CreateOutboundCrossClusterSearchConnectionCom
         body,
     });
 };
-export const serializeAws_restJson1CreatePackageCommand = async (input, context) => {
+export const se_CreatePackageCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -192,9 +182,7 @@ export const serializeAws_restJson1CreatePackageCommand = async (input, context)
     body = JSON.stringify({
         ...(input.PackageDescription != null && { PackageDescription: input.PackageDescription }),
         ...(input.PackageName != null && { PackageName: input.PackageName }),
-        ...(input.PackageSource != null && {
-            PackageSource: serializeAws_restJson1PackageSource(input.PackageSource, context),
-        }),
+        ...(input.PackageSource != null && { PackageSource: se_PackageSource(input.PackageSource, context) }),
         ...(input.PackageType != null && { PackageType: input.PackageType }),
     });
     return new __HttpRequest({
@@ -207,7 +195,7 @@ export const serializeAws_restJson1CreatePackageCommand = async (input, context)
         body,
     });
 };
-export const serializeAws_restJson1CreateVpcEndpointCommand = async (input, context) => {
+export const se_CreateVpcEndpointCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -217,7 +205,7 @@ export const serializeAws_restJson1CreateVpcEndpointCommand = async (input, cont
     body = JSON.stringify({
         ...(input.ClientToken != null && { ClientToken: input.ClientToken }),
         ...(input.DomainArn != null && { DomainArn: input.DomainArn }),
-        ...(input.VpcOptions != null && { VpcOptions: serializeAws_restJson1VPCOptions(input.VpcOptions, context) }),
+        ...(input.VpcOptions != null && { VpcOptions: se_VPCOptions(input.VpcOptions, context) }),
     });
     return new __HttpRequest({
         protocol,
@@ -229,7 +217,7 @@ export const serializeAws_restJson1CreateVpcEndpointCommand = async (input, cont
         body,
     });
 };
-export const serializeAws_restJson1DeleteElasticsearchDomainCommand = async (input, context) => {
+export const se_DeleteElasticsearchDomainCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/2015-01-01/es/domain/{DomainName}";
@@ -245,7 +233,7 @@ export const serializeAws_restJson1DeleteElasticsearchDomainCommand = async (inp
         body,
     });
 };
-export const serializeAws_restJson1DeleteElasticsearchServiceRoleCommand = async (input, context) => {
+export const se_DeleteElasticsearchServiceRoleCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -263,7 +251,7 @@ export const serializeAws_restJson1DeleteElasticsearchServiceRoleCommand = async
         body,
     });
 };
-export const serializeAws_restJson1DeleteInboundCrossClusterSearchConnectionCommand = async (input, context) => {
+export const se_DeleteInboundCrossClusterSearchConnectionCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
@@ -280,7 +268,7 @@ export const serializeAws_restJson1DeleteInboundCrossClusterSearchConnectionComm
         body,
     });
 };
-export const serializeAws_restJson1DeleteOutboundCrossClusterSearchConnectionCommand = async (input, context) => {
+export const se_DeleteOutboundCrossClusterSearchConnectionCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
@@ -297,7 +285,7 @@ export const serializeAws_restJson1DeleteOutboundCrossClusterSearchConnectionCom
         body,
     });
 };
-export const serializeAws_restJson1DeletePackageCommand = async (input, context) => {
+export const se_DeletePackageCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/2015-01-01/packages/{PackageID}";
@@ -313,7 +301,7 @@ export const serializeAws_restJson1DeletePackageCommand = async (input, context)
         body,
     });
 };
-export const serializeAws_restJson1DeleteVpcEndpointCommand = async (input, context) => {
+export const se_DeleteVpcEndpointCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
@@ -330,7 +318,7 @@ export const serializeAws_restJson1DeleteVpcEndpointCommand = async (input, cont
         body,
     });
 };
-export const serializeAws_restJson1DescribeDomainAutoTunesCommand = async (input, context) => {
+export const se_DescribeDomainAutoTunesCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -353,7 +341,7 @@ export const serializeAws_restJson1DescribeDomainAutoTunesCommand = async (input
         body,
     });
 };
-export const serializeAws_restJson1DescribeDomainChangeProgressCommand = async (input, context) => {
+export const se_DescribeDomainChangeProgressCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
@@ -374,7 +362,7 @@ export const serializeAws_restJson1DescribeDomainChangeProgressCommand = async (
         body,
     });
 };
-export const serializeAws_restJson1DescribeElasticsearchDomainCommand = async (input, context) => {
+export const se_DescribeElasticsearchDomainCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/2015-01-01/es/domain/{DomainName}";
@@ -390,7 +378,7 @@ export const serializeAws_restJson1DescribeElasticsearchDomainCommand = async (i
         body,
     });
 };
-export const serializeAws_restJson1DescribeElasticsearchDomainConfigCommand = async (input, context) => {
+export const se_DescribeElasticsearchDomainConfigCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/2015-01-01/es/domain/{DomainName}/config";
@@ -406,7 +394,7 @@ export const serializeAws_restJson1DescribeElasticsearchDomainConfigCommand = as
         body,
     });
 };
-export const serializeAws_restJson1DescribeElasticsearchDomainsCommand = async (input, context) => {
+export const se_DescribeElasticsearchDomainsCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -414,7 +402,7 @@ export const serializeAws_restJson1DescribeElasticsearchDomainsCommand = async (
     const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/2015-01-01/es/domain-info";
     let body;
     body = JSON.stringify({
-        ...(input.DomainNames != null && { DomainNames: serializeAws_restJson1DomainNameList(input.DomainNames, context) }),
+        ...(input.DomainNames != null && { DomainNames: se_DomainNameList(input.DomainNames, context) }),
     });
     return new __HttpRequest({
         protocol,
@@ -426,7 +414,7 @@ export const serializeAws_restJson1DescribeElasticsearchDomainsCommand = async (
         body,
     });
 };
-export const serializeAws_restJson1DescribeElasticsearchInstanceTypeLimitsCommand = async (input, context) => {
+export const se_DescribeElasticsearchInstanceTypeLimitsCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
@@ -448,7 +436,7 @@ export const serializeAws_restJson1DescribeElasticsearchInstanceTypeLimitsComman
         body,
     });
 };
-export const serializeAws_restJson1DescribeInboundCrossClusterSearchConnectionsCommand = async (input, context) => {
+export const se_DescribeInboundCrossClusterSearchConnectionsCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -457,7 +445,7 @@ export const serializeAws_restJson1DescribeInboundCrossClusterSearchConnectionsC
         "/2015-01-01/es/ccs/inboundConnection/search";
     let body;
     body = JSON.stringify({
-        ...(input.Filters != null && { Filters: serializeAws_restJson1FilterList(input.Filters, context) }),
+        ...(input.Filters != null && { Filters: se_FilterList(input.Filters, context) }),
         ...(input.MaxResults != null && { MaxResults: input.MaxResults }),
         ...(input.NextToken != null && { NextToken: input.NextToken }),
     });
@@ -471,7 +459,7 @@ export const serializeAws_restJson1DescribeInboundCrossClusterSearchConnectionsC
         body,
     });
 };
-export const serializeAws_restJson1DescribeOutboundCrossClusterSearchConnectionsCommand = async (input, context) => {
+export const se_DescribeOutboundCrossClusterSearchConnectionsCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -480,7 +468,7 @@ export const serializeAws_restJson1DescribeOutboundCrossClusterSearchConnections
         "/2015-01-01/es/ccs/outboundConnection/search";
     let body;
     body = JSON.stringify({
-        ...(input.Filters != null && { Filters: serializeAws_restJson1FilterList(input.Filters, context) }),
+        ...(input.Filters != null && { Filters: se_FilterList(input.Filters, context) }),
         ...(input.MaxResults != null && { MaxResults: input.MaxResults }),
         ...(input.NextToken != null && { NextToken: input.NextToken }),
     });
@@ -494,7 +482,7 @@ export const serializeAws_restJson1DescribeOutboundCrossClusterSearchConnections
         body,
     });
 };
-export const serializeAws_restJson1DescribePackagesCommand = async (input, context) => {
+export const se_DescribePackagesCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -502,7 +490,7 @@ export const serializeAws_restJson1DescribePackagesCommand = async (input, conte
     const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/2015-01-01/packages/describe";
     let body;
     body = JSON.stringify({
-        ...(input.Filters != null && { Filters: serializeAws_restJson1DescribePackagesFilterList(input.Filters, context) }),
+        ...(input.Filters != null && { Filters: se_DescribePackagesFilterList(input.Filters, context) }),
         ...(input.MaxResults != null && { MaxResults: input.MaxResults }),
         ...(input.NextToken != null && { NextToken: input.NextToken }),
     });
@@ -516,7 +504,7 @@ export const serializeAws_restJson1DescribePackagesCommand = async (input, conte
         body,
     });
 };
-export const serializeAws_restJson1DescribeReservedElasticsearchInstanceOfferingsCommand = async (input, context) => {
+export const se_DescribeReservedElasticsearchInstanceOfferingsCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/2015-01-01/es/reservedInstanceOfferings";
@@ -537,7 +525,7 @@ export const serializeAws_restJson1DescribeReservedElasticsearchInstanceOffering
         body,
     });
 };
-export const serializeAws_restJson1DescribeReservedElasticsearchInstancesCommand = async (input, context) => {
+export const se_DescribeReservedElasticsearchInstancesCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/2015-01-01/es/reservedInstances";
@@ -558,7 +546,7 @@ export const serializeAws_restJson1DescribeReservedElasticsearchInstancesCommand
         body,
     });
 };
-export const serializeAws_restJson1DescribeVpcEndpointsCommand = async (input, context) => {
+export const se_DescribeVpcEndpointsCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -566,9 +554,7 @@ export const serializeAws_restJson1DescribeVpcEndpointsCommand = async (input, c
     const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/2015-01-01/es/vpcEndpoints/describe";
     let body;
     body = JSON.stringify({
-        ...(input.VpcEndpointIds != null && {
-            VpcEndpointIds: serializeAws_restJson1VpcEndpointIdList(input.VpcEndpointIds, context),
-        }),
+        ...(input.VpcEndpointIds != null && { VpcEndpointIds: se_VpcEndpointIdList(input.VpcEndpointIds, context) }),
     });
     return new __HttpRequest({
         protocol,
@@ -580,7 +566,7 @@ export const serializeAws_restJson1DescribeVpcEndpointsCommand = async (input, c
         body,
     });
 };
-export const serializeAws_restJson1DissociatePackageCommand = async (input, context) => {
+export const se_DissociatePackageCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
@@ -598,7 +584,7 @@ export const serializeAws_restJson1DissociatePackageCommand = async (input, cont
         body,
     });
 };
-export const serializeAws_restJson1GetCompatibleElasticsearchVersionsCommand = async (input, context) => {
+export const se_GetCompatibleElasticsearchVersionsCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/2015-01-01/es/compatibleVersions";
@@ -617,7 +603,7 @@ export const serializeAws_restJson1GetCompatibleElasticsearchVersionsCommand = a
         body,
     });
 };
-export const serializeAws_restJson1GetPackageVersionHistoryCommand = async (input, context) => {
+export const se_GetPackageVersionHistoryCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/2015-01-01/packages/{PackageID}/history";
@@ -638,7 +624,7 @@ export const serializeAws_restJson1GetPackageVersionHistoryCommand = async (inpu
         body,
     });
 };
-export const serializeAws_restJson1GetUpgradeHistoryCommand = async (input, context) => {
+export const se_GetUpgradeHistoryCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
@@ -660,7 +646,7 @@ export const serializeAws_restJson1GetUpgradeHistoryCommand = async (input, cont
         body,
     });
 };
-export const serializeAws_restJson1GetUpgradeStatusCommand = async (input, context) => {
+export const se_GetUpgradeStatusCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
@@ -677,7 +663,7 @@ export const serializeAws_restJson1GetUpgradeStatusCommand = async (input, conte
         body,
     });
 };
-export const serializeAws_restJson1ListDomainNamesCommand = async (input, context) => {
+export const se_ListDomainNamesCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/2015-01-01/domain";
@@ -696,7 +682,7 @@ export const serializeAws_restJson1ListDomainNamesCommand = async (input, contex
         body,
     });
 };
-export const serializeAws_restJson1ListDomainsForPackageCommand = async (input, context) => {
+export const se_ListDomainsForPackageCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/2015-01-01/packages/{PackageID}/domains";
@@ -717,7 +703,7 @@ export const serializeAws_restJson1ListDomainsForPackageCommand = async (input,
         body,
     });
 };
-export const serializeAws_restJson1ListElasticsearchInstanceTypesCommand = async (input, context) => {
+export const se_ListElasticsearchInstanceTypesCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
@@ -740,7 +726,7 @@ export const serializeAws_restJson1ListElasticsearchInstanceTypesCommand = async
         body,
     });
 };
-export const serializeAws_restJson1ListElasticsearchVersionsCommand = async (input, context) => {
+export const se_ListElasticsearchVersionsCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/2015-01-01/es/versions";
@@ -760,7 +746,7 @@ export const serializeAws_restJson1ListElasticsearchVersionsCommand = async (inp
         body,
     });
 };
-export const serializeAws_restJson1ListPackagesForDomainCommand = async (input, context) => {
+export const se_ListPackagesForDomainCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/2015-01-01/domain/{DomainName}/packages";
@@ -781,7 +767,7 @@ export const serializeAws_restJson1ListPackagesForDomainCommand = async (input,
         body,
     });
 };
-export const serializeAws_restJson1ListTagsCommand = async (input, context) => {
+export const se_ListTagsCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/2015-01-01/tags";
@@ -800,7 +786,7 @@ export const serializeAws_restJson1ListTagsCommand = async (input, context) => {
         body,
     });
 };
-export const serializeAws_restJson1ListVpcEndpointAccessCommand = async (input, context) => {
+export const se_ListVpcEndpointAccessCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
@@ -821,7 +807,7 @@ export const serializeAws_restJson1ListVpcEndpointAccessCommand = async (input,
         body,
     });
 };
-export const serializeAws_restJson1ListVpcEndpointsCommand = async (input, context) => {
+export const se_ListVpcEndpointsCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/2015-01-01/es/vpcEndpoints";
@@ -840,7 +826,7 @@ export const serializeAws_restJson1ListVpcEndpointsCommand = async (input, conte
         body,
     });
 };
-export const serializeAws_restJson1ListVpcEndpointsForDomainCommand = async (input, context) => {
+export const se_ListVpcEndpointsForDomainCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
@@ -861,7 +847,7 @@ export const serializeAws_restJson1ListVpcEndpointsForDomainCommand = async (inp
         body,
     });
 };
-export const serializeAws_restJson1PurchaseReservedElasticsearchInstanceOfferingCommand = async (input, context) => {
+export const se_PurchaseReservedElasticsearchInstanceOfferingCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -886,7 +872,7 @@ export const serializeAws_restJson1PurchaseReservedElasticsearchInstanceOffering
         body,
     });
 };
-export const serializeAws_restJson1RejectInboundCrossClusterSearchConnectionCommand = async (input, context) => {
+export const se_RejectInboundCrossClusterSearchConnectionCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
@@ -903,7 +889,7 @@ export const serializeAws_restJson1RejectInboundCrossClusterSearchConnectionComm
         body,
     });
 };
-export const serializeAws_restJson1RemoveTagsCommand = async (input, context) => {
+export const se_RemoveTagsCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -912,7 +898,7 @@ export const serializeAws_restJson1RemoveTagsCommand = async (input, context) =>
     let body;
     body = JSON.stringify({
         ...(input.ARN != null && { ARN: input.ARN }),
-        ...(input.TagKeys != null && { TagKeys: serializeAws_restJson1StringList(input.TagKeys, context) }),
+        ...(input.TagKeys != null && { TagKeys: se_StringList(input.TagKeys, context) }),
     });
     return new __HttpRequest({
         protocol,
@@ -924,7 +910,7 @@ export const serializeAws_restJson1RemoveTagsCommand = async (input, context) =>
         body,
     });
 };
-export const serializeAws_restJson1RevokeVpcEndpointAccessCommand = async (input, context) => {
+export const se_RevokeVpcEndpointAccessCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -946,7 +932,7 @@ export const serializeAws_restJson1RevokeVpcEndpointAccessCommand = async (input
         body,
     });
 };
-export const serializeAws_restJson1StartElasticsearchServiceSoftwareUpdateCommand = async (input, context) => {
+export const se_StartElasticsearchServiceSoftwareUpdateCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -967,7 +953,7 @@ export const serializeAws_restJson1StartElasticsearchServiceSoftwareUpdateComman
         body,
     });
 };
-export const serializeAws_restJson1UpdateElasticsearchDomainConfigCommand = async (input, context) => {
+export const se_UpdateElasticsearchDomainConfigCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -977,39 +963,31 @@ export const serializeAws_restJson1UpdateElasticsearchDomainConfigCommand = asyn
     let body;
     body = JSON.stringify({
         ...(input.AccessPolicies != null && { AccessPolicies: input.AccessPolicies }),
-        ...(input.AdvancedOptions != null && {
-            AdvancedOptions: serializeAws_restJson1AdvancedOptions(input.AdvancedOptions, context),
-        }),
+        ...(input.AdvancedOptions != null && { AdvancedOptions: se_AdvancedOptions(input.AdvancedOptions, context) }),
         ...(input.AdvancedSecurityOptions != null && {
-            AdvancedSecurityOptions: serializeAws_restJson1AdvancedSecurityOptionsInput(input.AdvancedSecurityOptions, context),
-        }),
-        ...(input.AutoTuneOptions != null && {
-            AutoTuneOptions: serializeAws_restJson1AutoTuneOptions(input.AutoTuneOptions, context),
-        }),
-        ...(input.CognitoOptions != null && {
-            CognitoOptions: serializeAws_restJson1CognitoOptions(input.CognitoOptions, context),
+            AdvancedSecurityOptions: se_AdvancedSecurityOptionsInput(input.AdvancedSecurityOptions, context),
         }),
+        ...(input.AutoTuneOptions != null && { AutoTuneOptions: se_AutoTuneOptions(input.AutoTuneOptions, context) }),
+        ...(input.CognitoOptions != null && { CognitoOptions: se_CognitoOptions(input.CognitoOptions, context) }),
         ...(input.DomainEndpointOptions != null && {
-            DomainEndpointOptions: serializeAws_restJson1DomainEndpointOptions(input.DomainEndpointOptions, context),
+            DomainEndpointOptions: se_DomainEndpointOptions(input.DomainEndpointOptions, context),
         }),
         ...(input.DryRun != null && { DryRun: input.DryRun }),
-        ...(input.EBSOptions != null && { EBSOptions: serializeAws_restJson1EBSOptions(input.EBSOptions, context) }),
+        ...(input.EBSOptions != null && { EBSOptions: se_EBSOptions(input.EBSOptions, context) }),
         ...(input.ElasticsearchClusterConfig != null && {
-            ElasticsearchClusterConfig: serializeAws_restJson1ElasticsearchClusterConfig(input.ElasticsearchClusterConfig, context),
+            ElasticsearchClusterConfig: se_ElasticsearchClusterConfig(input.ElasticsearchClusterConfig, context),
         }),
         ...(input.EncryptionAtRestOptions != null && {
-            EncryptionAtRestOptions: serializeAws_restJson1EncryptionAtRestOptions(input.EncryptionAtRestOptions, context),
+            EncryptionAtRestOptions: se_EncryptionAtRestOptions(input.EncryptionAtRestOptions, context),
         }),
         ...(input.LogPublishingOptions != null && {
-            LogPublishingOptions: serializeAws_restJson1LogPublishingOptions(input.LogPublishingOptions, context),
+            LogPublishingOptions: se_LogPublishingOptions(input.LogPublishingOptions, context),
         }),
         ...(input.NodeToNodeEncryptionOptions != null && {
-            NodeToNodeEncryptionOptions: serializeAws_restJson1NodeToNodeEncryptionOptions(input.NodeToNodeEncryptionOptions, context),
-        }),
-        ...(input.SnapshotOptions != null && {
-            SnapshotOptions: serializeAws_restJson1SnapshotOptions(input.SnapshotOptions, context),
+            NodeToNodeEncryptionOptions: se_NodeToNodeEncryptionOptions(input.NodeToNodeEncryptionOptions, context),
         }),
-        ...(input.VPCOptions != null && { VPCOptions: serializeAws_restJson1VPCOptions(input.VPCOptions, context) }),
+        ...(input.SnapshotOptions != null && { SnapshotOptions: se_SnapshotOptions(input.SnapshotOptions, context) }),
+        ...(input.VPCOptions != null && { VPCOptions: se_VPCOptions(input.VPCOptions, context) }),
     });
     return new __HttpRequest({
         protocol,
@@ -1021,7 +999,7 @@ export const serializeAws_restJson1UpdateElasticsearchDomainConfigCommand = asyn
         body,
     });
 };
-export const serializeAws_restJson1UpdatePackageCommand = async (input, context) => {
+export const se_UpdatePackageCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -1032,9 +1010,7 @@ export const serializeAws_restJson1UpdatePackageCommand = async (input, context)
         ...(input.CommitMessage != null && { CommitMessage: input.CommitMessage }),
         ...(input.PackageDescription != null && { PackageDescription: input.PackageDescription }),
         ...(input.PackageID != null && { PackageID: input.PackageID }),
-        ...(input.PackageSource != null && {
-            PackageSource: serializeAws_restJson1PackageSource(input.PackageSource, context),
-        }),
+        ...(input.PackageSource != null && { PackageSource: se_PackageSource(input.PackageSource, context) }),
     });
     return new __HttpRequest({
         protocol,
@@ -1046,7 +1022,7 @@ export const serializeAws_restJson1UpdatePackageCommand = async (input, context)
         body,
     });
 };
-export const serializeAws_restJson1UpdateVpcEndpointCommand = async (input, context) => {
+export const se_UpdateVpcEndpointCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -1055,7 +1031,7 @@ export const serializeAws_restJson1UpdateVpcEndpointCommand = async (input, cont
     let body;
     body = JSON.stringify({
         ...(input.VpcEndpointId != null && { VpcEndpointId: input.VpcEndpointId }),
-        ...(input.VpcOptions != null && { VpcOptions: serializeAws_restJson1VPCOptions(input.VpcOptions, context) }),
+        ...(input.VpcOptions != null && { VpcOptions: se_VPCOptions(input.VpcOptions, context) }),
     });
     return new __HttpRequest({
         protocol,
@@ -1067,7 +1043,7 @@ export const serializeAws_restJson1UpdateVpcEndpointCommand = async (input, cont
         body,
     });
 };
-export const serializeAws_restJson1UpgradeElasticsearchDomainCommand = async (input, context) => {
+export const se_UpgradeElasticsearchDomainCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -1089,20 +1065,20 @@ export const serializeAws_restJson1UpgradeElasticsearchDomainCommand = async (in
         body,
     });
 };
-export const deserializeAws_restJson1AcceptInboundCrossClusterSearchConnectionCommand = async (output, context) => {
+export const de_AcceptInboundCrossClusterSearchConnectionCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1AcceptInboundCrossClusterSearchConnectionCommandError(output, context);
+        return de_AcceptInboundCrossClusterSearchConnectionCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.CrossClusterSearchConnection != null) {
-        contents.CrossClusterSearchConnection = deserializeAws_restJson1InboundCrossClusterSearchConnection(data.CrossClusterSearchConnection, context);
+        contents.CrossClusterSearchConnection = de_InboundCrossClusterSearchConnection(data.CrossClusterSearchConnection, context);
     }
     return contents;
 };
-const deserializeAws_restJson1AcceptInboundCrossClusterSearchConnectionCommandError = async (output, context) => {
+const de_AcceptInboundCrossClusterSearchConnectionCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1111,13 +1087,13 @@ const deserializeAws_restJson1AcceptInboundCrossClusterSearchConnectionCommandEr
     switch (errorCode) {
         case "DisabledOperationException":
         case "com.amazonaws.elasticsearchservice#DisabledOperationException":
-            throw await deserializeAws_restJson1DisabledOperationExceptionResponse(parsedOutput, context);
+            throw await de_DisabledOperationExceptionRes(parsedOutput, context);
         case "LimitExceededException":
         case "com.amazonaws.elasticsearchservice#LimitExceededException":
-            throw await deserializeAws_restJson1LimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.elasticsearchservice#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1128,9 +1104,9 @@ const deserializeAws_restJson1AcceptInboundCrossClusterSearchConnectionCommandEr
             });
     }
 };
-export const deserializeAws_restJson1AddTagsCommand = async (output, context) => {
+export const de_AddTagsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1AddTagsCommandError(output, context);
+        return de_AddTagsCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1138,7 +1114,7 @@ export const deserializeAws_restJson1AddTagsCommand = async (output, context) =>
     await collectBody(output.body, context);
     return contents;
 };
-const deserializeAws_restJson1AddTagsCommandError = async (output, context) => {
+const de_AddTagsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1147,16 +1123,16 @@ const deserializeAws_restJson1AddTagsCommandError = async (output, context) => {
     switch (errorCode) {
         case "BaseException":
         case "com.amazonaws.elasticsearchservice#BaseException":
-            throw await deserializeAws_restJson1BaseExceptionResponse(parsedOutput, context);
+            throw await de_BaseExceptionRes(parsedOutput, context);
         case "InternalException":
         case "com.amazonaws.elasticsearchservice#InternalException":
-            throw await deserializeAws_restJson1InternalExceptionResponse(parsedOutput, context);
+            throw await de_InternalExceptionRes(parsedOutput, context);
         case "LimitExceededException":
         case "com.amazonaws.elasticsearchservice#LimitExceededException":
-            throw await deserializeAws_restJson1LimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.elasticsearchservice#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1167,20 +1143,20 @@ const deserializeAws_restJson1AddTagsCommandError = async (output, context) => {
             });
     }
 };
-export const deserializeAws_restJson1AssociatePackageCommand = async (output, context) => {
+export const de_AssociatePackageCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1AssociatePackageCommandError(output, context);
+        return de_AssociatePackageCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.DomainPackageDetails != null) {
-        contents.DomainPackageDetails = deserializeAws_restJson1DomainPackageDetails(data.DomainPackageDetails, context);
+        contents.DomainPackageDetails = de_DomainPackageDetails(data.DomainPackageDetails, context);
     }
     return contents;
 };
-const deserializeAws_restJson1AssociatePackageCommandError = async (output, context) => {
+const de_AssociatePackageCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1189,22 +1165,22 @@ const deserializeAws_restJson1AssociatePackageCommandError = async (output, cont
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.elasticsearchservice#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "BaseException":
         case "com.amazonaws.elasticsearchservice#BaseException":
-            throw await deserializeAws_restJson1BaseExceptionResponse(parsedOutput, context);
+            throw await de_BaseExceptionRes(parsedOutput, context);
         case "ConflictException":
         case "com.amazonaws.elasticsearchservice#ConflictException":
-            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalException":
         case "com.amazonaws.elasticsearchservice#InternalException":
-            throw await deserializeAws_restJson1InternalExceptionResponse(parsedOutput, context);
+            throw await de_InternalExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.elasticsearchservice#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.elasticsearchservice#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1215,20 +1191,20 @@ const deserializeAws_restJson1AssociatePackageCommandError = async (output, cont
             });
     }
 };
-export const deserializeAws_restJson1AuthorizeVpcEndpointAccessCommand = async (output, context) => {
+export const de_AuthorizeVpcEndpointAccessCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1AuthorizeVpcEndpointAccessCommandError(output, context);
+        return de_AuthorizeVpcEndpointAccessCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.AuthorizedPrincipal != null) {
-        contents.AuthorizedPrincipal = deserializeAws_restJson1AuthorizedPrincipal(data.AuthorizedPrincipal, context);
+        contents.AuthorizedPrincipal = de_AuthorizedPrincipal(data.AuthorizedPrincipal, context);
     }
     return contents;
 };
-const deserializeAws_restJson1AuthorizeVpcEndpointAccessCommandError = async (output, context) => {
+const de_AuthorizeVpcEndpointAccessCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1237,22 +1213,22 @@ const deserializeAws_restJson1AuthorizeVpcEndpointAccessCommandError = async (ou
     switch (errorCode) {
         case "BaseException":
         case "com.amazonaws.elasticsearchservice#BaseException":
-            throw await deserializeAws_restJson1BaseExceptionResponse(parsedOutput, context);
+            throw await de_BaseExceptionRes(parsedOutput, context);
         case "DisabledOperationException":
         case "com.amazonaws.elasticsearchservice#DisabledOperationException":
-            throw await deserializeAws_restJson1DisabledOperationExceptionResponse(parsedOutput, context);
+            throw await de_DisabledOperationExceptionRes(parsedOutput, context);
         case "InternalException":
         case "com.amazonaws.elasticsearchservice#InternalException":
-            throw await deserializeAws_restJson1InternalExceptionResponse(parsedOutput, context);
+            throw await de_InternalExceptionRes(parsedOutput, context);
         case "LimitExceededException":
         case "com.amazonaws.elasticsearchservice#LimitExceededException":
-            throw await deserializeAws_restJson1LimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.elasticsearchservice#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.elasticsearchservice#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1263,20 +1239,20 @@ const deserializeAws_restJson1AuthorizeVpcEndpointAccessCommandError = async (ou
             });
     }
 };
-export const deserializeAws_restJson1CancelElasticsearchServiceSoftwareUpdateCommand = async (output, context) => {
+export const de_CancelElasticsearchServiceSoftwareUpdateCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1CancelElasticsearchServiceSoftwareUpdateCommandError(output, context);
+        return de_CancelElasticsearchServiceSoftwareUpdateCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.ServiceSoftwareOptions != null) {
-        contents.ServiceSoftwareOptions = deserializeAws_restJson1ServiceSoftwareOptions(data.ServiceSoftwareOptions, context);
+        contents.ServiceSoftwareOptions = de_ServiceSoftwareOptions(data.ServiceSoftwareOptions, context);
     }
     return contents;
 };
-const deserializeAws_restJson1CancelElasticsearchServiceSoftwareUpdateCommandError = async (output, context) => {
+const de_CancelElasticsearchServiceSoftwareUpdateCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1285,16 +1261,16 @@ const deserializeAws_restJson1CancelElasticsearchServiceSoftwareUpdateCommandErr
     switch (errorCode) {
         case "BaseException":
         case "com.amazonaws.elasticsearchservice#BaseException":
-            throw await deserializeAws_restJson1BaseExceptionResponse(parsedOutput, context);
+            throw await de_BaseExceptionRes(parsedOutput, context);
         case "InternalException":
         case "com.amazonaws.elasticsearchservice#InternalException":
-            throw await deserializeAws_restJson1InternalExceptionResponse(parsedOutput, context);
+            throw await de_InternalExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.elasticsearchservice#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.elasticsearchservice#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1305,20 +1281,20 @@ const deserializeAws_restJson1CancelElasticsearchServiceSoftwareUpdateCommandErr
             });
     }
 };
-export const deserializeAws_restJson1CreateElasticsearchDomainCommand = async (output, context) => {
+export const de_CreateElasticsearchDomainCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1CreateElasticsearchDomainCommandError(output, context);
+        return de_CreateElasticsearchDomainCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.DomainStatus != null) {
-        contents.DomainStatus = deserializeAws_restJson1ElasticsearchDomainStatus(data.DomainStatus, context);
+        contents.DomainStatus = de_ElasticsearchDomainStatus(data.DomainStatus, context);
     }
     return contents;
 };
-const deserializeAws_restJson1CreateElasticsearchDomainCommandError = async (output, context) => {
+const de_CreateElasticsearchDomainCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1327,25 +1303,25 @@ const deserializeAws_restJson1CreateElasticsearchDomainCommandError = async (out
     switch (errorCode) {
         case "BaseException":
         case "com.amazonaws.elasticsearchservice#BaseException":
-            throw await deserializeAws_restJson1BaseExceptionResponse(parsedOutput, context);
+            throw await de_BaseExceptionRes(parsedOutput, context);
         case "DisabledOperationException":
         case "com.amazonaws.elasticsearchservice#DisabledOperationException":
-            throw await deserializeAws_restJson1DisabledOperationExceptionResponse(parsedOutput, context);
+            throw await de_DisabledOperationExceptionRes(parsedOutput, context);
         case "InternalException":
         case "com.amazonaws.elasticsearchservice#InternalException":
-            throw await deserializeAws_restJson1InternalExceptionResponse(parsedOutput, context);
+            throw await de_InternalExceptionRes(parsedOutput, context);
         case "InvalidTypeException":
         case "com.amazonaws.elasticsearchservice#InvalidTypeException":
-            throw await deserializeAws_restJson1InvalidTypeExceptionResponse(parsedOutput, context);
+            throw await de_InvalidTypeExceptionRes(parsedOutput, context);
         case "LimitExceededException":
         case "com.amazonaws.elasticsearchservice#LimitExceededException":
-            throw await deserializeAws_restJson1LimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         case "ResourceAlreadyExistsException":
         case "com.amazonaws.elasticsearchservice#ResourceAlreadyExistsException":
-            throw await deserializeAws_restJson1ResourceAlreadyExistsExceptionResponse(parsedOutput, context);
+            throw await de_ResourceAlreadyExistsExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.elasticsearchservice#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1356,9 +1332,9 @@ const deserializeAws_restJson1CreateElasticsearchDomainCommandError = async (out
             });
     }
 };
-export const deserializeAws_restJson1CreateOutboundCrossClusterSearchConnectionCommand = async (output, context) => {
+export const de_CreateOutboundCrossClusterSearchConnectionCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1CreateOutboundCrossClusterSearchConnectionCommandError(output, context);
+        return de_CreateOutboundCrossClusterSearchConnectionCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1368,20 +1344,20 @@ export const deserializeAws_restJson1CreateOutboundCrossClusterSearchConnectionC
         contents.ConnectionAlias = __expectString(data.ConnectionAlias);
     }
     if (data.ConnectionStatus != null) {
-        contents.ConnectionStatus = deserializeAws_restJson1OutboundCrossClusterSearchConnectionStatus(data.ConnectionStatus, context);
+        contents.ConnectionStatus = de_OutboundCrossClusterSearchConnectionStatus(data.ConnectionStatus, context);
     }
     if (data.CrossClusterSearchConnectionId != null) {
         contents.CrossClusterSearchConnectionId = __expectString(data.CrossClusterSearchConnectionId);
     }
     if (data.DestinationDomainInfo != null) {
-        contents.DestinationDomainInfo = deserializeAws_restJson1DomainInformation(data.DestinationDomainInfo, context);
+        contents.DestinationDomainInfo = de_DomainInformation(data.DestinationDomainInfo, context);
     }
     if (data.SourceDomainInfo != null) {
-        contents.SourceDomainInfo = deserializeAws_restJson1DomainInformation(data.SourceDomainInfo, context);
+        contents.SourceDomainInfo = de_DomainInformation(data.SourceDomainInfo, context);
     }
     return contents;
 };
-const deserializeAws_restJson1CreateOutboundCrossClusterSearchConnectionCommandError = async (output, context) => {
+const de_CreateOutboundCrossClusterSearchConnectionCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1390,16 +1366,16 @@ const deserializeAws_restJson1CreateOutboundCrossClusterSearchConnectionCommandE
     switch (errorCode) {
         case "DisabledOperationException":
         case "com.amazonaws.elasticsearchservice#DisabledOperationException":
-            throw await deserializeAws_restJson1DisabledOperationExceptionResponse(parsedOutput, context);
+            throw await de_DisabledOperationExceptionRes(parsedOutput, context);
         case "InternalException":
         case "com.amazonaws.elasticsearchservice#InternalException":
-            throw await deserializeAws_restJson1InternalExceptionResponse(parsedOutput, context);
+            throw await de_InternalExceptionRes(parsedOutput, context);
         case "LimitExceededException":
         case "com.amazonaws.elasticsearchservice#LimitExceededException":
-            throw await deserializeAws_restJson1LimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         case "ResourceAlreadyExistsException":
         case "com.amazonaws.elasticsearchservice#ResourceAlreadyExistsException":
-            throw await deserializeAws_restJson1ResourceAlreadyExistsExceptionResponse(parsedOutput, context);
+            throw await de_ResourceAlreadyExistsExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1410,20 +1386,20 @@ const deserializeAws_restJson1CreateOutboundCrossClusterSearchConnectionCommandE
             });
     }
 };
-export const deserializeAws_restJson1CreatePackageCommand = async (output, context) => {
+export const de_CreatePackageCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1CreatePackageCommandError(output, context);
+        return de_CreatePackageCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.PackageDetails != null) {
-        contents.PackageDetails = deserializeAws_restJson1PackageDetails(data.PackageDetails, context);
+        contents.PackageDetails = de_PackageDetails(data.PackageDetails, context);
     }
     return contents;
 };
-const deserializeAws_restJson1CreatePackageCommandError = async (output, context) => {
+const de_CreatePackageCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1432,25 +1408,25 @@ const deserializeAws_restJson1CreatePackageCommandError = async (output, context
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.elasticsearchservice#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "BaseException":
         case "com.amazonaws.elasticsearchservice#BaseException":
-            throw await deserializeAws_restJson1BaseExceptionResponse(parsedOutput, context);
+            throw await de_BaseExceptionRes(parsedOutput, context);
         case "InternalException":
         case "com.amazonaws.elasticsearchservice#InternalException":
-            throw await deserializeAws_restJson1InternalExceptionResponse(parsedOutput, context);
+            throw await de_InternalExceptionRes(parsedOutput, context);
         case "InvalidTypeException":
         case "com.amazonaws.elasticsearchservice#InvalidTypeException":
-            throw await deserializeAws_restJson1InvalidTypeExceptionResponse(parsedOutput, context);
+            throw await de_InvalidTypeExceptionRes(parsedOutput, context);
         case "LimitExceededException":
         case "com.amazonaws.elasticsearchservice#LimitExceededException":
-            throw await deserializeAws_restJson1LimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         case "ResourceAlreadyExistsException":
         case "com.amazonaws.elasticsearchservice#ResourceAlreadyExistsException":
-            throw await deserializeAws_restJson1ResourceAlreadyExistsExceptionResponse(parsedOutput, context);
+            throw await de_ResourceAlreadyExistsExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.elasticsearchservice#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1461,20 +1437,20 @@ const deserializeAws_restJson1CreatePackageCommandError = async (output, context
             });
     }
 };
-export const deserializeAws_restJson1CreateVpcEndpointCommand = async (output, context) => {
+export const de_CreateVpcEndpointCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1CreateVpcEndpointCommandError(output, context);
+        return de_CreateVpcEndpointCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.VpcEndpoint != null) {
-        contents.VpcEndpoint = deserializeAws_restJson1VpcEndpoint(data.VpcEndpoint, context);
+        contents.VpcEndpoint = de_VpcEndpoint(data.VpcEndpoint, context);
     }
     return contents;
 };
-const deserializeAws_restJson1CreateVpcEndpointCommandError = async (output, context) => {
+const de_CreateVpcEndpointCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1483,22 +1459,22 @@ const deserializeAws_restJson1CreateVpcEndpointCommandError = async (output, con
     switch (errorCode) {
         case "BaseException":
         case "com.amazonaws.elasticsearchservice#BaseException":
-            throw await deserializeAws_restJson1BaseExceptionResponse(parsedOutput, context);
+            throw await de_BaseExceptionRes(parsedOutput, context);
         case "ConflictException":
         case "com.amazonaws.elasticsearchservice#ConflictException":
-            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "DisabledOperationException":
         case "com.amazonaws.elasticsearchservice#DisabledOperationException":
-            throw await deserializeAws_restJson1DisabledOperationExceptionResponse(parsedOutput, context);
+            throw await de_DisabledOperationExceptionRes(parsedOutput, context);
         case "InternalException":
         case "com.amazonaws.elasticsearchservice#InternalException":
-            throw await deserializeAws_restJson1InternalExceptionResponse(parsedOutput, context);
+            throw await de_InternalExceptionRes(parsedOutput, context);
         case "LimitExceededException":
         case "com.amazonaws.elasticsearchservice#LimitExceededException":
-            throw await deserializeAws_restJson1LimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.elasticsearchservice#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1509,20 +1485,20 @@ const deserializeAws_restJson1CreateVpcEndpointCommandError = async (output, con
             });
     }
 };
-export const deserializeAws_restJson1DeleteElasticsearchDomainCommand = async (output, context) => {
+export const de_DeleteElasticsearchDomainCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1DeleteElasticsearchDomainCommandError(output, context);
+        return de_DeleteElasticsearchDomainCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.DomainStatus != null) {
-        contents.DomainStatus = deserializeAws_restJson1ElasticsearchDomainStatus(data.DomainStatus, context);
+        contents.DomainStatus = de_ElasticsearchDomainStatus(data.DomainStatus, context);
     }
     return contents;
 };
-const deserializeAws_restJson1DeleteElasticsearchDomainCommandError = async (output, context) => {
+const de_DeleteElasticsearchDomainCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1531,16 +1507,16 @@ const deserializeAws_restJson1DeleteElasticsearchDomainCommandError = async (out
     switch (errorCode) {
         case "BaseException":
         case "com.amazonaws.elasticsearchservice#BaseException":
-            throw await deserializeAws_restJson1BaseExceptionResponse(parsedOutput, context);
+            throw await de_BaseExceptionRes(parsedOutput, context);
         case "InternalException":
         case "com.amazonaws.elasticsearchservice#InternalException":
-            throw await deserializeAws_restJson1InternalExceptionResponse(parsedOutput, context);
+            throw await de_InternalExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.elasticsearchservice#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.elasticsearchservice#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1551,9 +1527,9 @@ const deserializeAws_restJson1DeleteElasticsearchDomainCommandError = async (out
             });
     }
 };
-export const deserializeAws_restJson1DeleteElasticsearchServiceRoleCommand = async (output, context) => {
+export const de_DeleteElasticsearchServiceRoleCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1DeleteElasticsearchServiceRoleCommandError(output, context);
+        return de_DeleteElasticsearchServiceRoleCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1561,7 +1537,7 @@ export const deserializeAws_restJson1DeleteElasticsearchServiceRoleCommand = asy
     await collectBody(output.body, context);
     return contents;
 };
-const deserializeAws_restJson1DeleteElasticsearchServiceRoleCommandError = async (output, context) => {
+const de_DeleteElasticsearchServiceRoleCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1570,13 +1546,13 @@ const deserializeAws_restJson1DeleteElasticsearchServiceRoleCommandError = async
     switch (errorCode) {
         case "BaseException":
         case "com.amazonaws.elasticsearchservice#BaseException":
-            throw await deserializeAws_restJson1BaseExceptionResponse(parsedOutput, context);
+            throw await de_BaseExceptionRes(parsedOutput, context);
         case "InternalException":
         case "com.amazonaws.elasticsearchservice#InternalException":
-            throw await deserializeAws_restJson1InternalExceptionResponse(parsedOutput, context);
+            throw await de_InternalExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.elasticsearchservice#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1587,20 +1563,20 @@ const deserializeAws_restJson1DeleteElasticsearchServiceRoleCommandError = async
             });
     }
 };
-export const deserializeAws_restJson1DeleteInboundCrossClusterSearchConnectionCommand = async (output, context) => {
+export const de_DeleteInboundCrossClusterSearchConnectionCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1DeleteInboundCrossClusterSearchConnectionCommandError(output, context);
+        return de_DeleteInboundCrossClusterSearchConnectionCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.CrossClusterSearchConnection != null) {
-        contents.CrossClusterSearchConnection = deserializeAws_restJson1InboundCrossClusterSearchConnection(data.CrossClusterSearchConnection, context);
+        contents.CrossClusterSearchConnection = de_InboundCrossClusterSearchConnection(data.CrossClusterSearchConnection, context);
     }
     return contents;
 };
-const deserializeAws_restJson1DeleteInboundCrossClusterSearchConnectionCommandError = async (output, context) => {
+const de_DeleteInboundCrossClusterSearchConnectionCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1609,10 +1585,10 @@ const deserializeAws_restJson1DeleteInboundCrossClusterSearchConnectionCommandEr
     switch (errorCode) {
         case "DisabledOperationException":
         case "com.amazonaws.elasticsearchservice#DisabledOperationException":
-            throw await deserializeAws_restJson1DisabledOperationExceptionResponse(parsedOutput, context);
+            throw await de_DisabledOperationExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.elasticsearchservice#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1623,20 +1599,20 @@ const deserializeAws_restJson1DeleteInboundCrossClusterSearchConnectionCommandEr
             });
     }
 };
-export const deserializeAws_restJson1DeleteOutboundCrossClusterSearchConnectionCommand = async (output, context) => {
+export const de_DeleteOutboundCrossClusterSearchConnectionCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1DeleteOutboundCrossClusterSearchConnectionCommandError(output, context);
+        return de_DeleteOutboundCrossClusterSearchConnectionCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.CrossClusterSearchConnection != null) {
-        contents.CrossClusterSearchConnection = deserializeAws_restJson1OutboundCrossClusterSearchConnection(data.CrossClusterSearchConnection, context);
+        contents.CrossClusterSearchConnection = de_OutboundCrossClusterSearchConnection(data.CrossClusterSearchConnection, context);
     }
     return contents;
 };
-const deserializeAws_restJson1DeleteOutboundCrossClusterSearchConnectionCommandError = async (output, context) => {
+const de_DeleteOutboundCrossClusterSearchConnectionCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1645,10 +1621,10 @@ const deserializeAws_restJson1DeleteOutboundCrossClusterSearchConnectionCommandE
     switch (errorCode) {
         case "DisabledOperationException":
         case "com.amazonaws.elasticsearchservice#DisabledOperationException":
-            throw await deserializeAws_restJson1DisabledOperationExceptionResponse(parsedOutput, context);
+            throw await de_DisabledOperationExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.elasticsearchservice#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1659,20 +1635,20 @@ const deserializeAws_restJson1DeleteOutboundCrossClusterSearchConnectionCommandE
             });
     }
 };
-export const deserializeAws_restJson1DeletePackageCommand = async (output, context) => {
+export const de_DeletePackageCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1DeletePackageCommandError(output, context);
+        return de_DeletePackageCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.PackageDetails != null) {
-        contents.PackageDetails = deserializeAws_restJson1PackageDetails(data.PackageDetails, context);
+        contents.PackageDetails = de_PackageDetails(data.PackageDetails, context);
     }
     return contents;
 };
-const deserializeAws_restJson1DeletePackageCommandError = async (output, context) => {
+const de_DeletePackageCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1681,22 +1657,22 @@ const deserializeAws_restJson1DeletePackageCommandError = async (output, context
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.elasticsearchservice#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "BaseException":
         case "com.amazonaws.elasticsearchservice#BaseException":
-            throw await deserializeAws_restJson1BaseExceptionResponse(parsedOutput, context);
+            throw await de_BaseExceptionRes(parsedOutput, context);
         case "ConflictException":
         case "com.amazonaws.elasticsearchservice#ConflictException":
-            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalException":
         case "com.amazonaws.elasticsearchservice#InternalException":
-            throw await deserializeAws_restJson1InternalExceptionResponse(parsedOutput, context);
+            throw await de_InternalExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.elasticsearchservice#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.elasticsearchservice#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1707,20 +1683,20 @@ const deserializeAws_restJson1DeletePackageCommandError = async (output, context
             });
     }
 };
-export const deserializeAws_restJson1DeleteVpcEndpointCommand = async (output, context) => {
+export const de_DeleteVpcEndpointCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1DeleteVpcEndpointCommandError(output, context);
+        return de_DeleteVpcEndpointCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.VpcEndpointSummary != null) {
-        contents.VpcEndpointSummary = deserializeAws_restJson1VpcEndpointSummary(data.VpcEndpointSummary, context);
+        contents.VpcEndpointSummary = de_VpcEndpointSummary(data.VpcEndpointSummary, context);
     }
     return contents;
 };
-const deserializeAws_restJson1DeleteVpcEndpointCommandError = async (output, context) => {
+const de_DeleteVpcEndpointCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1729,16 +1705,16 @@ const deserializeAws_restJson1DeleteVpcEndpointCommandError = async (output, con
     switch (errorCode) {
         case "BaseException":
         case "com.amazonaws.elasticsearchservice#BaseException":
-            throw await deserializeAws_restJson1BaseExceptionResponse(parsedOutput, context);
+            throw await de_BaseExceptionRes(parsedOutput, context);
         case "DisabledOperationException":
         case "com.amazonaws.elasticsearchservice#DisabledOperationException":
-            throw await deserializeAws_restJson1DisabledOperationExceptionResponse(parsedOutput, context);
+            throw await de_DisabledOperationExceptionRes(parsedOutput, context);
         case "InternalException":
         case "com.amazonaws.elasticsearchservice#InternalException":
-            throw await deserializeAws_restJson1InternalExceptionResponse(parsedOutput, context);
+            throw await de_InternalExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.elasticsearchservice#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1749,23 +1725,23 @@ const deserializeAws_restJson1DeleteVpcEndpointCommandError = async (output, con
             });
     }
 };
-export const deserializeAws_restJson1DescribeDomainAutoTunesCommand = async (output, context) => {
+export const de_DescribeDomainAutoTunesCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1DescribeDomainAutoTunesCommandError(output, context);
+        return de_DescribeDomainAutoTunesCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.AutoTunes != null) {
-        contents.AutoTunes = deserializeAws_restJson1AutoTuneList(data.AutoTunes, context);
+        contents.AutoTunes = de_AutoTuneList(data.AutoTunes, context);
     }
     if (data.NextToken != null) {
         contents.NextToken = __expectString(data.NextToken);
     }
     return contents;
 };
-const deserializeAws_restJson1DescribeDomainAutoTunesCommandError = async (output, context) => {
+const de_DescribeDomainAutoTunesCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1774,16 +1750,16 @@ const deserializeAws_restJson1DescribeDomainAutoTunesCommandError = async (outpu
     switch (errorCode) {
         case "BaseException":
         case "com.amazonaws.elasticsearchservice#BaseException":
-            throw await deserializeAws_restJson1BaseExceptionResponse(parsedOutput, context);
+            throw await de_BaseExceptionRes(parsedOutput, context);
         case "InternalException":
         case "com.amazonaws.elasticsearchservice#InternalException":
-            throw await deserializeAws_restJson1InternalExceptionResponse(parsedOutput, context);
+            throw await de_InternalExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.elasticsearchservice#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.elasticsearchservice#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1794,20 +1770,20 @@ const deserializeAws_restJson1DescribeDomainAutoTunesCommandError = async (outpu
             });
     }
 };
-export const deserializeAws_restJson1DescribeDomainChangeProgressCommand = async (output, context) => {
+export const de_DescribeDomainChangeProgressCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1DescribeDomainChangeProgressCommandError(output, context);
+        return de_DescribeDomainChangeProgressCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.ChangeProgressStatus != null) {
-        contents.ChangeProgressStatus = deserializeAws_restJson1ChangeProgressStatusDetails(data.ChangeProgressStatus, context);
+        contents.ChangeProgressStatus = de_ChangeProgressStatusDetails(data.ChangeProgressStatus, context);
     }
     return contents;
 };
-const deserializeAws_restJson1DescribeDomainChangeProgressCommandError = async (output, context) => {
+const de_DescribeDomainChangeProgressCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1816,16 +1792,16 @@ const deserializeAws_restJson1DescribeDomainChangeProgressCommandError = async (
     switch (errorCode) {
         case "BaseException":
         case "com.amazonaws.elasticsearchservice#BaseException":
-            throw await deserializeAws_restJson1BaseExceptionResponse(parsedOutput, context);
+            throw await de_BaseExceptionRes(parsedOutput, context);
         case "InternalException":
         case "com.amazonaws.elasticsearchservice#InternalException":
-            throw await deserializeAws_restJson1InternalExceptionResponse(parsedOutput, context);
+            throw await de_InternalExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.elasticsearchservice#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.elasticsearchservice#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1836,20 +1812,20 @@ const deserializeAws_restJson1DescribeDomainChangeProgressCommandError = async (
             });
     }
 };
-export const deserializeAws_restJson1DescribeElasticsearchDomainCommand = async (output, context) => {
+export const de_DescribeElasticsearchDomainCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1DescribeElasticsearchDomainCommandError(output, context);
+        return de_DescribeElasticsearchDomainCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.DomainStatus != null) {
-        contents.DomainStatus = deserializeAws_restJson1ElasticsearchDomainStatus(data.DomainStatus, context);
+        contents.DomainStatus = de_ElasticsearchDomainStatus(data.DomainStatus, context);
     }
     return contents;
 };
-const deserializeAws_restJson1DescribeElasticsearchDomainCommandError = async (output, context) => {
+const de_DescribeElasticsearchDomainCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1858,16 +1834,16 @@ const deserializeAws_restJson1DescribeElasticsearchDomainCommandError = async (o
     switch (errorCode) {
         case "BaseException":
         case "com.amazonaws.elasticsearchservice#BaseException":
-            throw await deserializeAws_restJson1BaseExceptionResponse(parsedOutput, context);
+            throw await de_BaseExceptionRes(parsedOutput, context);
         case "InternalException":
         case "com.amazonaws.elasticsearchservice#InternalException":
-            throw await deserializeAws_restJson1InternalExceptionResponse(parsedOutput, context);
+            throw await de_InternalExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.elasticsearchservice#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.elasticsearchservice#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1878,20 +1854,20 @@ const deserializeAws_restJson1DescribeElasticsearchDomainCommandError = async (o
             });
     }
 };
-export const deserializeAws_restJson1DescribeElasticsearchDomainConfigCommand = async (output, context) => {
+export const de_DescribeElasticsearchDomainConfigCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1DescribeElasticsearchDomainConfigCommandError(output, context);
+        return de_DescribeElasticsearchDomainConfigCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.DomainConfig != null) {
-        contents.DomainConfig = deserializeAws_restJson1ElasticsearchDomainConfig(data.DomainConfig, context);
+        contents.DomainConfig = de_ElasticsearchDomainConfig(data.DomainConfig, context);
     }
     return contents;
 };
-const deserializeAws_restJson1DescribeElasticsearchDomainConfigCommandError = async (output, context) => {
+const de_DescribeElasticsearchDomainConfigCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1900,16 +1876,16 @@ const deserializeAws_restJson1DescribeElasticsearchDomainConfigCommandError = as
     switch (errorCode) {
         case "BaseException":
         case "com.amazonaws.elasticsearchservice#BaseException":
-            throw await deserializeAws_restJson1BaseExceptionResponse(parsedOutput, context);
+            throw await de_BaseExceptionRes(parsedOutput, context);
         case "InternalException":
         case "com.amazonaws.elasticsearchservice#InternalException":
-            throw await deserializeAws_restJson1InternalExceptionResponse(parsedOutput, context);
+            throw await de_InternalExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.elasticsearchservice#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.elasticsearchservice#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1920,20 +1896,20 @@ const deserializeAws_restJson1DescribeElasticsearchDomainConfigCommandError = as
             });
     }
 };
-export const deserializeAws_restJson1DescribeElasticsearchDomainsCommand = async (output, context) => {
+export const de_DescribeElasticsearchDomainsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1DescribeElasticsearchDomainsCommandError(output, context);
+        return de_DescribeElasticsearchDomainsCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.DomainStatusList != null) {
-        contents.DomainStatusList = deserializeAws_restJson1ElasticsearchDomainStatusList(data.DomainStatusList, context);
+        contents.DomainStatusList = de_ElasticsearchDomainStatusList(data.DomainStatusList, context);
     }
     return contents;
 };
-const deserializeAws_restJson1DescribeElasticsearchDomainsCommandError = async (output, context) => {
+const de_DescribeElasticsearchDomainsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1942,13 +1918,13 @@ const deserializeAws_restJson1DescribeElasticsearchDomainsCommandError = async (
     switch (errorCode) {
         case "BaseException":
         case "com.amazonaws.elasticsearchservice#BaseException":
-            throw await deserializeAws_restJson1BaseExceptionResponse(parsedOutput, context);
+            throw await de_BaseExceptionRes(parsedOutput, context);
         case "InternalException":
         case "com.amazonaws.elasticsearchservice#InternalException":
-            throw await deserializeAws_restJson1InternalExceptionResponse(parsedOutput, context);
+            throw await de_InternalExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.elasticsearchservice#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1959,20 +1935,20 @@ const deserializeAws_restJson1DescribeElasticsearchDomainsCommandError = async (
             });
     }
 };
-export const deserializeAws_restJson1DescribeElasticsearchInstanceTypeLimitsCommand = async (output, context) => {
+export const de_DescribeElasticsearchInstanceTypeLimitsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1DescribeElasticsearchInstanceTypeLimitsCommandError(output, context);
+        return de_DescribeElasticsearchInstanceTypeLimitsCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.LimitsByRole != null) {
-        contents.LimitsByRole = deserializeAws_restJson1LimitsByRole(data.LimitsByRole, context);
+        contents.LimitsByRole = de_LimitsByRole(data.LimitsByRole, context);
     }
     return contents;
 };
-const deserializeAws_restJson1DescribeElasticsearchInstanceTypeLimitsCommandError = async (output, context) => {
+const de_DescribeElasticsearchInstanceTypeLimitsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1981,22 +1957,22 @@ const deserializeAws_restJson1DescribeElasticsearchInstanceTypeLimitsCommandErro
     switch (errorCode) {
         case "BaseException":
         case "com.amazonaws.elasticsearchservice#BaseException":
-            throw await deserializeAws_restJson1BaseExceptionResponse(parsedOutput, context);
+            throw await de_BaseExceptionRes(parsedOutput, context);
         case "InternalException":
         case "com.amazonaws.elasticsearchservice#InternalException":
-            throw await deserializeAws_restJson1InternalExceptionResponse(parsedOutput, context);
+            throw await de_InternalExceptionRes(parsedOutput, context);
         case "InvalidTypeException":
         case "com.amazonaws.elasticsearchservice#InvalidTypeException":
-            throw await deserializeAws_restJson1InvalidTypeExceptionResponse(parsedOutput, context);
+            throw await de_InvalidTypeExceptionRes(parsedOutput, context);
         case "LimitExceededException":
         case "com.amazonaws.elasticsearchservice#LimitExceededException":
-            throw await deserializeAws_restJson1LimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.elasticsearchservice#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.elasticsearchservice#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2007,23 +1983,23 @@ const deserializeAws_restJson1DescribeElasticsearchInstanceTypeLimitsCommandErro
             });
     }
 };
-export const deserializeAws_restJson1DescribeInboundCrossClusterSearchConnectionsCommand = async (output, context) => {
+export const de_DescribeInboundCrossClusterSearchConnectionsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1DescribeInboundCrossClusterSearchConnectionsCommandError(output, context);
+        return de_DescribeInboundCrossClusterSearchConnectionsCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.CrossClusterSearchConnections != null) {
-        contents.CrossClusterSearchConnections = deserializeAws_restJson1InboundCrossClusterSearchConnections(data.CrossClusterSearchConnections, context);
+        contents.CrossClusterSearchConnections = de_InboundCrossClusterSearchConnections(data.CrossClusterSearchConnections, context);
     }
     if (data.NextToken != null) {
         contents.NextToken = __expectString(data.NextToken);
     }
     return contents;
 };
-const deserializeAws_restJson1DescribeInboundCrossClusterSearchConnectionsCommandError = async (output, context) => {
+const de_DescribeInboundCrossClusterSearchConnectionsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2032,10 +2008,10 @@ const deserializeAws_restJson1DescribeInboundCrossClusterSearchConnectionsComman
     switch (errorCode) {
         case "DisabledOperationException":
         case "com.amazonaws.elasticsearchservice#DisabledOperationException":
-            throw await deserializeAws_restJson1DisabledOperationExceptionResponse(parsedOutput, context);
+            throw await de_DisabledOperationExceptionRes(parsedOutput, context);
         case "InvalidPaginationTokenException":
         case "com.amazonaws.elasticsearchservice#InvalidPaginationTokenException":
-            throw await deserializeAws_restJson1InvalidPaginationTokenExceptionResponse(parsedOutput, context);
+            throw await de_InvalidPaginationTokenExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2046,23 +2022,23 @@ const deserializeAws_restJson1DescribeInboundCrossClusterSearchConnectionsComman
             });
     }
 };
-export const deserializeAws_restJson1DescribeOutboundCrossClusterSearchConnectionsCommand = async (output, context) => {
+export const de_DescribeOutboundCrossClusterSearchConnectionsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1DescribeOutboundCrossClusterSearchConnectionsCommandError(output, context);
+        return de_DescribeOutboundCrossClusterSearchConnectionsCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.CrossClusterSearchConnections != null) {
-        contents.CrossClusterSearchConnections = deserializeAws_restJson1OutboundCrossClusterSearchConnections(data.CrossClusterSearchConnections, context);
+        contents.CrossClusterSearchConnections = de_OutboundCrossClusterSearchConnections(data.CrossClusterSearchConnections, context);
     }
     if (data.NextToken != null) {
         contents.NextToken = __expectString(data.NextToken);
     }
     return contents;
 };
-const deserializeAws_restJson1DescribeOutboundCrossClusterSearchConnectionsCommandError = async (output, context) => {
+const de_DescribeOutboundCrossClusterSearchConnectionsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2071,10 +2047,10 @@ const deserializeAws_restJson1DescribeOutboundCrossClusterSearchConnectionsComma
     switch (errorCode) {
         case "DisabledOperationException":
         case "com.amazonaws.elasticsearchservice#DisabledOperationException":
-            throw await deserializeAws_restJson1DisabledOperationExceptionResponse(parsedOutput, context);
+            throw await de_DisabledOperationExceptionRes(parsedOutput, context);
         case "InvalidPaginationTokenException":
         case "com.amazonaws.elasticsearchservice#InvalidPaginationTokenException":
-            throw await deserializeAws_restJson1InvalidPaginationTokenExceptionResponse(parsedOutput, context);
+            throw await de_InvalidPaginationTokenExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2085,9 +2061,9 @@ const deserializeAws_restJson1DescribeOutboundCrossClusterSearchConnectionsComma
             });
     }
 };
-export const deserializeAws_restJson1DescribePackagesCommand = async (output, context) => {
+export const de_DescribePackagesCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1DescribePackagesCommandError(output, context);
+        return de_DescribePackagesCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -2097,11 +2073,11 @@ export const deserializeAws_restJson1DescribePackagesCommand = async (output, co
         contents.NextToken = __expectString(data.NextToken);
     }
     if (data.PackageDetailsList != null) {
-        contents.PackageDetailsList = deserializeAws_restJson1PackageDetailsList(data.PackageDetailsList, context);
+        contents.PackageDetailsList = de_PackageDetailsList(data.PackageDetailsList, context);
     }
     return contents;
 };
-const deserializeAws_restJson1DescribePackagesCommandError = async (output, context) => {
+const de_DescribePackagesCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2110,19 +2086,19 @@ const deserializeAws_restJson1DescribePackagesCommandError = async (output, cont
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.elasticsearchservice#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "BaseException":
         case "com.amazonaws.elasticsearchservice#BaseException":
-            throw await deserializeAws_restJson1BaseExceptionResponse(parsedOutput, context);
+            throw await de_BaseExceptionRes(parsedOutput, context);
         case "InternalException":
         case "com.amazonaws.elasticsearchservice#InternalException":
-            throw await deserializeAws_restJson1InternalExceptionResponse(parsedOutput, context);
+            throw await de_InternalExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.elasticsearchservice#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.elasticsearchservice#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2133,9 +2109,9 @@ const deserializeAws_restJson1DescribePackagesCommandError = async (output, cont
             });
     }
 };
-export const deserializeAws_restJson1DescribeReservedElasticsearchInstanceOfferingsCommand = async (output, context) => {
+export const de_DescribeReservedElasticsearchInstanceOfferingsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1DescribeReservedElasticsearchInstanceOfferingsCommandError(output, context);
+        return de_DescribeReservedElasticsearchInstanceOfferingsCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -2145,11 +2121,11 @@ export const deserializeAws_restJson1DescribeReservedElasticsearchInstanceOfferi
         contents.NextToken = __expectString(data.NextToken);
     }
     if (data.ReservedElasticsearchInstanceOfferings != null) {
-        contents.ReservedElasticsearchInstanceOfferings = deserializeAws_restJson1ReservedElasticsearchInstanceOfferingList(data.ReservedElasticsearchInstanceOfferings, context);
+        contents.ReservedElasticsearchInstanceOfferings = de_ReservedElasticsearchInstanceOfferingList(data.ReservedElasticsearchInstanceOfferings, context);
     }
     return contents;
 };
-const deserializeAws_restJson1DescribeReservedElasticsearchInstanceOfferingsCommandError = async (output, context) => {
+const de_DescribeReservedElasticsearchInstanceOfferingsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2158,16 +2134,16 @@ const deserializeAws_restJson1DescribeReservedElasticsearchInstanceOfferingsComm
     switch (errorCode) {
         case "DisabledOperationException":
         case "com.amazonaws.elasticsearchservice#DisabledOperationException":
-            throw await deserializeAws_restJson1DisabledOperationExceptionResponse(parsedOutput, context);
+            throw await de_DisabledOperationExceptionRes(parsedOutput, context);
         case "InternalException":
         case "com.amazonaws.elasticsearchservice#InternalException":
-            throw await deserializeAws_restJson1InternalExceptionResponse(parsedOutput, context);
+            throw await de_InternalExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.elasticsearchservice#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.elasticsearchservice#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2178,9 +2154,9 @@ const deserializeAws_restJson1DescribeReservedElasticsearchInstanceOfferingsComm
             });
     }
 };
-export const deserializeAws_restJson1DescribeReservedElasticsearchInstancesCommand = async (output, context) => {
+export const de_DescribeReservedElasticsearchInstancesCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1DescribeReservedElasticsearchInstancesCommandError(output, context);
+        return de_DescribeReservedElasticsearchInstancesCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -2190,11 +2166,11 @@ export const deserializeAws_restJson1DescribeReservedElasticsearchInstancesComma
         contents.NextToken = __expectString(data.NextToken);
     }
     if (data.ReservedElasticsearchInstances != null) {
-        contents.ReservedElasticsearchInstances = deserializeAws_restJson1ReservedElasticsearchInstanceList(data.ReservedElasticsearchInstances, context);
+        contents.ReservedElasticsearchInstances = de_ReservedElasticsearchInstanceList(data.ReservedElasticsearchInstances, context);
     }
     return contents;
 };
-const deserializeAws_restJson1DescribeReservedElasticsearchInstancesCommandError = async (output, context) => {
+const de_DescribeReservedElasticsearchInstancesCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2203,16 +2179,16 @@ const deserializeAws_restJson1DescribeReservedElasticsearchInstancesCommandError
     switch (errorCode) {
         case "DisabledOperationException":
         case "com.amazonaws.elasticsearchservice#DisabledOperationException":
-            throw await deserializeAws_restJson1DisabledOperationExceptionResponse(parsedOutput, context);
+            throw await de_DisabledOperationExceptionRes(parsedOutput, context);
         case "InternalException":
         case "com.amazonaws.elasticsearchservice#InternalException":
-            throw await deserializeAws_restJson1InternalExceptionResponse(parsedOutput, context);
+            throw await de_InternalExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.elasticsearchservice#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.elasticsearchservice#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2223,23 +2199,23 @@ const deserializeAws_restJson1DescribeReservedElasticsearchInstancesCommandError
             });
     }
 };
-export const deserializeAws_restJson1DescribeVpcEndpointsCommand = async (output, context) => {
+export const de_DescribeVpcEndpointsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1DescribeVpcEndpointsCommandError(output, context);
+        return de_DescribeVpcEndpointsCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.VpcEndpointErrors != null) {
-        contents.VpcEndpointErrors = deserializeAws_restJson1VpcEndpointErrorList(data.VpcEndpointErrors, context);
+        contents.VpcEndpointErrors = de_VpcEndpointErrorList(data.VpcEndpointErrors, context);
     }
     if (data.VpcEndpoints != null) {
-        contents.VpcEndpoints = deserializeAws_restJson1VpcEndpoints(data.VpcEndpoints, context);
+        contents.VpcEndpoints = de_VpcEndpoints(data.VpcEndpoints, context);
     }
     return contents;
 };
-const deserializeAws_restJson1DescribeVpcEndpointsCommandError = async (output, context) => {
+const de_DescribeVpcEndpointsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2248,16 +2224,16 @@ const deserializeAws_restJson1DescribeVpcEndpointsCommandError = async (output,
     switch (errorCode) {
         case "BaseException":
         case "com.amazonaws.elasticsearchservice#BaseException":
-            throw await deserializeAws_restJson1BaseExceptionResponse(parsedOutput, context);
+            throw await de_BaseExceptionRes(parsedOutput, context);
         case "DisabledOperationException":
         case "com.amazonaws.elasticsearchservice#DisabledOperationException":
-            throw await deserializeAws_restJson1DisabledOperationExceptionResponse(parsedOutput, context);
+            throw await de_DisabledOperationExceptionRes(parsedOutput, context);
         case "InternalException":
         case "com.amazonaws.elasticsearchservice#InternalException":
-            throw await deserializeAws_restJson1InternalExceptionResponse(parsedOutput, context);
+            throw await de_InternalExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.elasticsearchservice#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2268,20 +2244,20 @@ const deserializeAws_restJson1DescribeVpcEndpointsCommandError = async (output,
             });
     }
 };
-export const deserializeAws_restJson1DissociatePackageCommand = async (output, context) => {
+export const de_DissociatePackageCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1DissociatePackageCommandError(output, context);
+        return de_DissociatePackageCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.DomainPackageDetails != null) {
-        contents.DomainPackageDetails = deserializeAws_restJson1DomainPackageDetails(data.DomainPackageDetails, context);
+        contents.DomainPackageDetails = de_DomainPackageDetails(data.DomainPackageDetails, context);
     }
     return contents;
 };
-const deserializeAws_restJson1DissociatePackageCommandError = async (output, context) => {
+const de_DissociatePackageCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2290,22 +2266,22 @@ const deserializeAws_restJson1DissociatePackageCommandError = async (output, con
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.elasticsearchservice#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "BaseException":
         case "com.amazonaws.elasticsearchservice#BaseException":
-            throw await deserializeAws_restJson1BaseExceptionResponse(parsedOutput, context);
+            throw await de_BaseExceptionRes(parsedOutput, context);
         case "ConflictException":
         case "com.amazonaws.elasticsearchservice#ConflictException":
-            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalException":
         case "com.amazonaws.elasticsearchservice#InternalException":
-            throw await deserializeAws_restJson1InternalExceptionResponse(parsedOutput, context);
+            throw await de_InternalExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.elasticsearchservice#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.elasticsearchservice#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2316,20 +2292,20 @@ const deserializeAws_restJson1DissociatePackageCommandError = async (output, con
             });
     }
 };
-export const deserializeAws_restJson1GetCompatibleElasticsearchVersionsCommand = async (output, context) => {
+export const de_GetCompatibleElasticsearchVersionsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1GetCompatibleElasticsearchVersionsCommandError(output, context);
+        return de_GetCompatibleElasticsearchVersionsCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.CompatibleElasticsearchVersions != null) {
-        contents.CompatibleElasticsearchVersions = deserializeAws_restJson1CompatibleElasticsearchVersionsList(data.CompatibleElasticsearchVersions, context);
+        contents.CompatibleElasticsearchVersions = de_CompatibleElasticsearchVersionsList(data.CompatibleElasticsearchVersions, context);
     }
     return contents;
 };
-const deserializeAws_restJson1GetCompatibleElasticsearchVersionsCommandError = async (output, context) => {
+const de_GetCompatibleElasticsearchVersionsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2338,19 +2314,19 @@ const deserializeAws_restJson1GetCompatibleElasticsearchVersionsCommandError = a
     switch (errorCode) {
         case "BaseException":
         case "com.amazonaws.elasticsearchservice#BaseException":
-            throw await deserializeAws_restJson1BaseExceptionResponse(parsedOutput, context);
+            throw await de_BaseExceptionRes(parsedOutput, context);
         case "DisabledOperationException":
         case "com.amazonaws.elasticsearchservice#DisabledOperationException":
-            throw await deserializeAws_restJson1DisabledOperationExceptionResponse(parsedOutput, context);
+            throw await de_DisabledOperationExceptionRes(parsedOutput, context);
         case "InternalException":
         case "com.amazonaws.elasticsearchservice#InternalException":
-            throw await deserializeAws_restJson1InternalExceptionResponse(parsedOutput, context);
+            throw await de_InternalExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.elasticsearchservice#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.elasticsearchservice#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2361,9 +2337,9 @@ const deserializeAws_restJson1GetCompatibleElasticsearchVersionsCommandError = a
             });
     }
 };
-export const deserializeAws_restJson1GetPackageVersionHistoryCommand = async (output, context) => {
+export const de_GetPackageVersionHistoryCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1GetPackageVersionHistoryCommandError(output, context);
+        return de_GetPackageVersionHistoryCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -2376,11 +2352,11 @@ export const deserializeAws_restJson1GetPackageVersionHistoryCommand = async (ou
         contents.PackageID = __expectString(data.PackageID);
     }
     if (data.PackageVersionHistoryList != null) {
-        contents.PackageVersionHistoryList = deserializeAws_restJson1PackageVersionHistoryList(data.PackageVersionHistoryList, context);
+        contents.PackageVersionHistoryList = de_PackageVersionHistoryList(data.PackageVersionHistoryList, context);
     }
     return contents;
 };
-const deserializeAws_restJson1GetPackageVersionHistoryCommandError = async (output, context) => {
+const de_GetPackageVersionHistoryCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2389,19 +2365,19 @@ const deserializeAws_restJson1GetPackageVersionHistoryCommandError = async (outp
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.elasticsearchservice#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "BaseException":
         case "com.amazonaws.elasticsearchservice#BaseException":
-            throw await deserializeAws_restJson1BaseExceptionResponse(parsedOutput, context);
+            throw await de_BaseExceptionRes(parsedOutput, context);
         case "InternalException":
         case "com.amazonaws.elasticsearchservice#InternalException":
-            throw await deserializeAws_restJson1InternalExceptionResponse(parsedOutput, context);
+            throw await de_InternalExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.elasticsearchservice#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.elasticsearchservice#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2412,9 +2388,9 @@ const deserializeAws_restJson1GetPackageVersionHistoryCommandError = async (outp
             });
     }
 };
-export const deserializeAws_restJson1GetUpgradeHistoryCommand = async (output, context) => {
+export const de_GetUpgradeHistoryCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1GetUpgradeHistoryCommandError(output, context);
+        return de_GetUpgradeHistoryCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -2424,11 +2400,11 @@ export const deserializeAws_restJson1GetUpgradeHistoryCommand = async (output, c
         contents.NextToken = __expectString(data.NextToken);
     }
     if (data.UpgradeHistories != null) {
-        contents.UpgradeHistories = deserializeAws_restJson1UpgradeHistoryList(data.UpgradeHistories, context);
+        contents.UpgradeHistories = de_UpgradeHistoryList(data.UpgradeHistories, context);
     }
     return contents;
 };
-const deserializeAws_restJson1GetUpgradeHistoryCommandError = async (output, context) => {
+const de_GetUpgradeHistoryCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2437,19 +2413,19 @@ const deserializeAws_restJson1GetUpgradeHistoryCommandError = async (output, con
     switch (errorCode) {
         case "BaseException":
         case "com.amazonaws.elasticsearchservice#BaseException":
-            throw await deserializeAws_restJson1BaseExceptionResponse(parsedOutput, context);
+            throw await de_BaseExceptionRes(parsedOutput, context);
         case "DisabledOperationException":
         case "com.amazonaws.elasticsearchservice#DisabledOperationException":
-            throw await deserializeAws_restJson1DisabledOperationExceptionResponse(parsedOutput, context);
+            throw await de_DisabledOperationExceptionRes(parsedOutput, context);
         case "InternalException":
         case "com.amazonaws.elasticsearchservice#InternalException":
-            throw await deserializeAws_restJson1InternalExceptionResponse(parsedOutput, context);
+            throw await de_InternalExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.elasticsearchservice#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.elasticsearchservice#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2460,9 +2436,9 @@ const deserializeAws_restJson1GetUpgradeHistoryCommandError = async (output, con
             });
     }
 };
-export const deserializeAws_restJson1GetUpgradeStatusCommand = async (output, context) => {
+export const de_GetUpgradeStatusCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1GetUpgradeStatusCommandError(output, context);
+        return de_GetUpgradeStatusCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -2479,7 +2455,7 @@ export const deserializeAws_restJson1GetUpgradeStatusCommand = async (output, co
     }
     return contents;
 };
-const deserializeAws_restJson1GetUpgradeStatusCommandError = async (output, context) => {
+const de_GetUpgradeStatusCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2488,19 +2464,19 @@ const deserializeAws_restJson1GetUpgradeStatusCommandError = async (output, cont
     switch (errorCode) {
         case "BaseException":
         case "com.amazonaws.elasticsearchservice#BaseException":
-            throw await deserializeAws_restJson1BaseExceptionResponse(parsedOutput, context);
+            throw await de_BaseExceptionRes(parsedOutput, context);
         case "DisabledOperationException":
         case "com.amazonaws.elasticsearchservice#DisabledOperationException":
-            throw await deserializeAws_restJson1DisabledOperationExceptionResponse(parsedOutput, context);
+            throw await de_DisabledOperationExceptionRes(parsedOutput, context);
         case "InternalException":
         case "com.amazonaws.elasticsearchservice#InternalException":
-            throw await deserializeAws_restJson1InternalExceptionResponse(parsedOutput, context);
+            throw await de_InternalExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.elasticsearchservice#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.elasticsearchservice#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2511,20 +2487,20 @@ const deserializeAws_restJson1GetUpgradeStatusCommandError = async (output, cont
             });
     }
 };
-export const deserializeAws_restJson1ListDomainNamesCommand = async (output, context) => {
+export const de_ListDomainNamesCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1ListDomainNamesCommandError(output, context);
+        return de_ListDomainNamesCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.DomainNames != null) {
-        contents.DomainNames = deserializeAws_restJson1DomainInfoList(data.DomainNames, context);
+        contents.DomainNames = de_DomainInfoList(data.DomainNames, context);
     }
     return contents;
 };
-const deserializeAws_restJson1ListDomainNamesCommandError = async (output, context) => {
+const de_ListDomainNamesCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2533,10 +2509,10 @@ const deserializeAws_restJson1ListDomainNamesCommandError = async (output, conte
     switch (errorCode) {
         case "BaseException":
         case "com.amazonaws.elasticsearchservice#BaseException":
-            throw await deserializeAws_restJson1BaseExceptionResponse(parsedOutput, context);
+            throw await de_BaseExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.elasticsearchservice#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2547,23 +2523,23 @@ const deserializeAws_restJson1ListDomainNamesCommandError = async (output, conte
             });
     }
 };
-export const deserializeAws_restJson1ListDomainsForPackageCommand = async (output, context) => {
+export const de_ListDomainsForPackageCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1ListDomainsForPackageCommandError(output, context);
+        return de_ListDomainsForPackageCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.DomainPackageDetailsList != null) {
-        contents.DomainPackageDetailsList = deserializeAws_restJson1DomainPackageDetailsList(data.DomainPackageDetailsList, context);
+        contents.DomainPackageDetailsList = de_DomainPackageDetailsList(data.DomainPackageDetailsList, context);
     }
     if (data.NextToken != null) {
         contents.NextToken = __expectString(data.NextToken);
     }
     return contents;
 };
-const deserializeAws_restJson1ListDomainsForPackageCommandError = async (output, context) => {
+const de_ListDomainsForPackageCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2572,19 +2548,19 @@ const deserializeAws_restJson1ListDomainsForPackageCommandError = async (output,
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.elasticsearchservice#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "BaseException":
         case "com.amazonaws.elasticsearchservice#BaseException":
-            throw await deserializeAws_restJson1BaseExceptionResponse(parsedOutput, context);
+            throw await de_BaseExceptionRes(parsedOutput, context);
         case "InternalException":
         case "com.amazonaws.elasticsearchservice#InternalException":
-            throw await deserializeAws_restJson1InternalExceptionResponse(parsedOutput, context);
+            throw await de_InternalExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.elasticsearchservice#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.elasticsearchservice#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2595,23 +2571,23 @@ const deserializeAws_restJson1ListDomainsForPackageCommandError = async (output,
             });
     }
 };
-export const deserializeAws_restJson1ListElasticsearchInstanceTypesCommand = async (output, context) => {
+export const de_ListElasticsearchInstanceTypesCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1ListElasticsearchInstanceTypesCommandError(output, context);
+        return de_ListElasticsearchInstanceTypesCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.ElasticsearchInstanceTypes != null) {
-        contents.ElasticsearchInstanceTypes = deserializeAws_restJson1ElasticsearchInstanceTypeList(data.ElasticsearchInstanceTypes, context);
+        contents.ElasticsearchInstanceTypes = de_ElasticsearchInstanceTypeList(data.ElasticsearchInstanceTypes, context);
     }
     if (data.NextToken != null) {
         contents.NextToken = __expectString(data.NextToken);
     }
     return contents;
 };
-const deserializeAws_restJson1ListElasticsearchInstanceTypesCommandError = async (output, context) => {
+const de_ListElasticsearchInstanceTypesCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2620,16 +2596,16 @@ const deserializeAws_restJson1ListElasticsearchInstanceTypesCommandError = async
     switch (errorCode) {
         case "BaseException":
         case "com.amazonaws.elasticsearchservice#BaseException":
-            throw await deserializeAws_restJson1BaseExceptionResponse(parsedOutput, context);
+            throw await de_BaseExceptionRes(parsedOutput, context);
         case "InternalException":
         case "com.amazonaws.elasticsearchservice#InternalException":
-            throw await deserializeAws_restJson1InternalExceptionResponse(parsedOutput, context);
+            throw await de_InternalExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.elasticsearchservice#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.elasticsearchservice#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2640,23 +2616,23 @@ const deserializeAws_restJson1ListElasticsearchInstanceTypesCommandError = async
             });
     }
 };
-export const deserializeAws_restJson1ListElasticsearchVersionsCommand = async (output, context) => {
+export const de_ListElasticsearchVersionsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1ListElasticsearchVersionsCommandError(output, context);
+        return de_ListElasticsearchVersionsCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.ElasticsearchVersions != null) {
-        contents.ElasticsearchVersions = deserializeAws_restJson1ElasticsearchVersionList(data.ElasticsearchVersions, context);
+        contents.ElasticsearchVersions = de_ElasticsearchVersionList(data.ElasticsearchVersions, context);
     }
     if (data.NextToken != null) {
         contents.NextToken = __expectString(data.NextToken);
     }
     return contents;
 };
-const deserializeAws_restJson1ListElasticsearchVersionsCommandError = async (output, context) => {
+const de_ListElasticsearchVersionsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2665,16 +2641,16 @@ const deserializeAws_restJson1ListElasticsearchVersionsCommandError = async (out
     switch (errorCode) {
         case "BaseException":
         case "com.amazonaws.elasticsearchservice#BaseException":
-            throw await deserializeAws_restJson1BaseExceptionResponse(parsedOutput, context);
+            throw await de_BaseExceptionRes(parsedOutput, context);
         case "InternalException":
         case "com.amazonaws.elasticsearchservice#InternalException":
-            throw await deserializeAws_restJson1InternalExceptionResponse(parsedOutput, context);
+            throw await de_InternalExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.elasticsearchservice#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.elasticsearchservice#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2685,23 +2661,23 @@ const deserializeAws_restJson1ListElasticsearchVersionsCommandError = async (out
             });
     }
 };
-export const deserializeAws_restJson1ListPackagesForDomainCommand = async (output, context) => {
+export const de_ListPackagesForDomainCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1ListPackagesForDomainCommandError(output, context);
+        return de_ListPackagesForDomainCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.DomainPackageDetailsList != null) {
-        contents.DomainPackageDetailsList = deserializeAws_restJson1DomainPackageDetailsList(data.DomainPackageDetailsList, context);
+        contents.DomainPackageDetailsList = de_DomainPackageDetailsList(data.DomainPackageDetailsList, context);
     }
     if (data.NextToken != null) {
         contents.NextToken = __expectString(data.NextToken);
     }
     return contents;
 };
-const deserializeAws_restJson1ListPackagesForDomainCommandError = async (output, context) => {
+const de_ListPackagesForDomainCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2710,19 +2686,19 @@ const deserializeAws_restJson1ListPackagesForDomainCommandError = async (output,
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.elasticsearchservice#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "BaseException":
         case "com.amazonaws.elasticsearchservice#BaseException":
-            throw await deserializeAws_restJson1BaseExceptionResponse(parsedOutput, context);
+            throw await de_BaseExceptionRes(parsedOutput, context);
         case "InternalException":
         case "com.amazonaws.elasticsearchservice#InternalException":
-            throw await deserializeAws_restJson1InternalExceptionResponse(parsedOutput, context);
+            throw await de_InternalExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.elasticsearchservice#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.elasticsearchservice#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2733,20 +2709,20 @@ const deserializeAws_restJson1ListPackagesForDomainCommandError = async (output,
             });
     }
 };
-export const deserializeAws_restJson1ListTagsCommand = async (output, context) => {
+export const de_ListTagsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1ListTagsCommandError(output, context);
+        return de_ListTagsCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.TagList != null) {
-        contents.TagList = deserializeAws_restJson1TagList(data.TagList, context);
+        contents.TagList = de_TagList(data.TagList, context);
     }
     return contents;
 };
-const deserializeAws_restJson1ListTagsCommandError = async (output, context) => {
+const de_ListTagsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2755,16 +2731,16 @@ const deserializeAws_restJson1ListTagsCommandError = async (output, context) =>
     switch (errorCode) {
         case "BaseException":
         case "com.amazonaws.elasticsearchservice#BaseException":
-            throw await deserializeAws_restJson1BaseExceptionResponse(parsedOutput, context);
+            throw await de_BaseExceptionRes(parsedOutput, context);
         case "InternalException":
         case "com.amazonaws.elasticsearchservice#InternalException":
-            throw await deserializeAws_restJson1InternalExceptionResponse(parsedOutput, context);
+            throw await de_InternalExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.elasticsearchservice#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.elasticsearchservice#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2775,23 +2751,23 @@ const deserializeAws_restJson1ListTagsCommandError = async (output, context) =>
             });
     }
 };
-export const deserializeAws_restJson1ListVpcEndpointAccessCommand = async (output, context) => {
+export const de_ListVpcEndpointAccessCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1ListVpcEndpointAccessCommandError(output, context);
+        return de_ListVpcEndpointAccessCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.AuthorizedPrincipalList != null) {
-        contents.AuthorizedPrincipalList = deserializeAws_restJson1AuthorizedPrincipalList(data.AuthorizedPrincipalList, context);
+        contents.AuthorizedPrincipalList = de_AuthorizedPrincipalList(data.AuthorizedPrincipalList, context);
     }
     if (data.NextToken != null) {
         contents.NextToken = __expectString(data.NextToken);
     }
     return contents;
 };
-const deserializeAws_restJson1ListVpcEndpointAccessCommandError = async (output, context) => {
+const de_ListVpcEndpointAccessCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2800,16 +2776,16 @@ const deserializeAws_restJson1ListVpcEndpointAccessCommandError = async (output,
     switch (errorCode) {
         case "BaseException":
         case "com.amazonaws.elasticsearchservice#BaseException":
-            throw await deserializeAws_restJson1BaseExceptionResponse(parsedOutput, context);
+            throw await de_BaseExceptionRes(parsedOutput, context);
         case "DisabledOperationException":
         case "com.amazonaws.elasticsearchservice#DisabledOperationException":
-            throw await deserializeAws_restJson1DisabledOperationExceptionResponse(parsedOutput, context);
+            throw await de_DisabledOperationExceptionRes(parsedOutput, context);
         case "InternalException":
         case "com.amazonaws.elasticsearchservice#InternalException":
-            throw await deserializeAws_restJson1InternalExceptionResponse(parsedOutput, context);
+            throw await de_InternalExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.elasticsearchservice#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2820,9 +2796,9 @@ const deserializeAws_restJson1ListVpcEndpointAccessCommandError = async (output,
             });
     }
 };
-export const deserializeAws_restJson1ListVpcEndpointsCommand = async (output, context) => {
+export const de_ListVpcEndpointsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1ListVpcEndpointsCommandError(output, context);
+        return de_ListVpcEndpointsCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -2832,11 +2808,11 @@ export const deserializeAws_restJson1ListVpcEndpointsCommand = async (output, co
         contents.NextToken = __expectString(data.NextToken);
     }
     if (data.VpcEndpointSummaryList != null) {
-        contents.VpcEndpointSummaryList = deserializeAws_restJson1VpcEndpointSummaryList(data.VpcEndpointSummaryList, context);
+        contents.VpcEndpointSummaryList = de_VpcEndpointSummaryList(data.VpcEndpointSummaryList, context);
     }
     return contents;
 };
-const deserializeAws_restJson1ListVpcEndpointsCommandError = async (output, context) => {
+const de_ListVpcEndpointsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2845,13 +2821,13 @@ const deserializeAws_restJson1ListVpcEndpointsCommandError = async (output, cont
     switch (errorCode) {
         case "BaseException":
         case "com.amazonaws.elasticsearchservice#BaseException":
-            throw await deserializeAws_restJson1BaseExceptionResponse(parsedOutput, context);
+            throw await de_BaseExceptionRes(parsedOutput, context);
         case "DisabledOperationException":
         case "com.amazonaws.elasticsearchservice#DisabledOperationException":
-            throw await deserializeAws_restJson1DisabledOperationExceptionResponse(parsedOutput, context);
+            throw await de_DisabledOperationExceptionRes(parsedOutput, context);
         case "InternalException":
         case "com.amazonaws.elasticsearchservice#InternalException":
-            throw await deserializeAws_restJson1InternalExceptionResponse(parsedOutput, context);
+            throw await de_InternalExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2862,9 +2838,9 @@ const deserializeAws_restJson1ListVpcEndpointsCommandError = async (output, cont
             });
     }
 };
-export const deserializeAws_restJson1ListVpcEndpointsForDomainCommand = async (output, context) => {
+export const de_ListVpcEndpointsForDomainCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1ListVpcEndpointsForDomainCommandError(output, context);
+        return de_ListVpcEndpointsForDomainCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -2874,11 +2850,11 @@ export const deserializeAws_restJson1ListVpcEndpointsForDomainCommand = async (o
         contents.NextToken = __expectString(data.NextToken);
     }
     if (data.VpcEndpointSummaryList != null) {
-        contents.VpcEndpointSummaryList = deserializeAws_restJson1VpcEndpointSummaryList(data.VpcEndpointSummaryList, context);
+        contents.VpcEndpointSummaryList = de_VpcEndpointSummaryList(data.VpcEndpointSummaryList, context);
     }
     return contents;
 };
-const deserializeAws_restJson1ListVpcEndpointsForDomainCommandError = async (output, context) => {
+const de_ListVpcEndpointsForDomainCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2887,16 +2863,16 @@ const deserializeAws_restJson1ListVpcEndpointsForDomainCommandError = async (out
     switch (errorCode) {
         case "BaseException":
         case "com.amazonaws.elasticsearchservice#BaseException":
-            throw await deserializeAws_restJson1BaseExceptionResponse(parsedOutput, context);
+            throw await de_BaseExceptionRes(parsedOutput, context);
         case "DisabledOperationException":
         case "com.amazonaws.elasticsearchservice#DisabledOperationException":
-            throw await deserializeAws_restJson1DisabledOperationExceptionResponse(parsedOutput, context);
+            throw await de_DisabledOperationExceptionRes(parsedOutput, context);
         case "InternalException":
         case "com.amazonaws.elasticsearchservice#InternalException":
-            throw await deserializeAws_restJson1InternalExceptionResponse(parsedOutput, context);
+            throw await de_InternalExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.elasticsearchservice#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2907,9 +2883,9 @@ const deserializeAws_restJson1ListVpcEndpointsForDomainCommandError = async (out
             });
     }
 };
-export const deserializeAws_restJson1PurchaseReservedElasticsearchInstanceOfferingCommand = async (output, context) => {
+export const de_PurchaseReservedElasticsearchInstanceOfferingCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1PurchaseReservedElasticsearchInstanceOfferingCommandError(output, context);
+        return de_PurchaseReservedElasticsearchInstanceOfferingCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -2923,7 +2899,7 @@ export const deserializeAws_restJson1PurchaseReservedElasticsearchInstanceOfferi
     }
     return contents;
 };
-const deserializeAws_restJson1PurchaseReservedElasticsearchInstanceOfferingCommandError = async (output, context) => {
+const de_PurchaseReservedElasticsearchInstanceOfferingCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2932,22 +2908,22 @@ const deserializeAws_restJson1PurchaseReservedElasticsearchInstanceOfferingComma
     switch (errorCode) {
         case "DisabledOperationException":
         case "com.amazonaws.elasticsearchservice#DisabledOperationException":
-            throw await deserializeAws_restJson1DisabledOperationExceptionResponse(parsedOutput, context);
+            throw await de_DisabledOperationExceptionRes(parsedOutput, context);
         case "InternalException":
         case "com.amazonaws.elasticsearchservice#InternalException":
-            throw await deserializeAws_restJson1InternalExceptionResponse(parsedOutput, context);
+            throw await de_InternalExceptionRes(parsedOutput, context);
         case "LimitExceededException":
         case "com.amazonaws.elasticsearchservice#LimitExceededException":
-            throw await deserializeAws_restJson1LimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         case "ResourceAlreadyExistsException":
         case "com.amazonaws.elasticsearchservice#ResourceAlreadyExistsException":
-            throw await deserializeAws_restJson1ResourceAlreadyExistsExceptionResponse(parsedOutput, context);
+            throw await de_ResourceAlreadyExistsExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.elasticsearchservice#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.elasticsearchservice#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2958,20 +2934,20 @@ const deserializeAws_restJson1PurchaseReservedElasticsearchInstanceOfferingComma
             });
     }
 };
-export const deserializeAws_restJson1RejectInboundCrossClusterSearchConnectionCommand = async (output, context) => {
+export const de_RejectInboundCrossClusterSearchConnectionCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1RejectInboundCrossClusterSearchConnectionCommandError(output, context);
+        return de_RejectInboundCrossClusterSearchConnectionCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.CrossClusterSearchConnection != null) {
-        contents.CrossClusterSearchConnection = deserializeAws_restJson1InboundCrossClusterSearchConnection(data.CrossClusterSearchConnection, context);
+        contents.CrossClusterSearchConnection = de_InboundCrossClusterSearchConnection(data.CrossClusterSearchConnection, context);
     }
     return contents;
 };
-const deserializeAws_restJson1RejectInboundCrossClusterSearchConnectionCommandError = async (output, context) => {
+const de_RejectInboundCrossClusterSearchConnectionCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2980,10 +2956,10 @@ const deserializeAws_restJson1RejectInboundCrossClusterSearchConnectionCommandEr
     switch (errorCode) {
         case "DisabledOperationException":
         case "com.amazonaws.elasticsearchservice#DisabledOperationException":
-            throw await deserializeAws_restJson1DisabledOperationExceptionResponse(parsedOutput, context);
+            throw await de_DisabledOperationExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.elasticsearchservice#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2994,9 +2970,9 @@ const deserializeAws_restJson1RejectInboundCrossClusterSearchConnectionCommandEr
             });
     }
 };
-export const deserializeAws_restJson1RemoveTagsCommand = async (output, context) => {
+export const de_RemoveTagsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1RemoveTagsCommandError(output, context);
+        return de_RemoveTagsCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -3004,7 +2980,7 @@ export const deserializeAws_restJson1RemoveTagsCommand = async (output, context)
     await collectBody(output.body, context);
     return contents;
 };
-const deserializeAws_restJson1RemoveTagsCommandError = async (output, context) => {
+const de_RemoveTagsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -3013,13 +2989,13 @@ const deserializeAws_restJson1RemoveTagsCommandError = async (output, context) =
     switch (errorCode) {
         case "BaseException":
         case "com.amazonaws.elasticsearchservice#BaseException":
-            throw await deserializeAws_restJson1BaseExceptionResponse(parsedOutput, context);
+            throw await de_BaseExceptionRes(parsedOutput, context);
         case "InternalException":
         case "com.amazonaws.elasticsearchservice#InternalException":
-            throw await deserializeAws_restJson1InternalExceptionResponse(parsedOutput, context);
+            throw await de_InternalExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.elasticsearchservice#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -3030,9 +3006,9 @@ const deserializeAws_restJson1RemoveTagsCommandError = async (output, context) =
             });
     }
 };
-export const deserializeAws_restJson1RevokeVpcEndpointAccessCommand = async (output, context) => {
+export const de_RevokeVpcEndpointAccessCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1RevokeVpcEndpointAccessCommandError(output, context);
+        return de_RevokeVpcEndpointAccessCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -3040,7 +3016,7 @@ export const deserializeAws_restJson1RevokeVpcEndpointAccessCommand = async (out
     await collectBody(output.body, context);
     return contents;
 };
-const deserializeAws_restJson1RevokeVpcEndpointAccessCommandError = async (output, context) => {
+const de_RevokeVpcEndpointAccessCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -3049,19 +3025,19 @@ const deserializeAws_restJson1RevokeVpcEndpointAccessCommandError = async (outpu
     switch (errorCode) {
         case "BaseException":
         case "com.amazonaws.elasticsearchservice#BaseException":
-            throw await deserializeAws_restJson1BaseExceptionResponse(parsedOutput, context);
+            throw await de_BaseExceptionRes(parsedOutput, context);
         case "DisabledOperationException":
         case "com.amazonaws.elasticsearchservice#DisabledOperationException":
-            throw await deserializeAws_restJson1DisabledOperationExceptionResponse(parsedOutput, context);
+            throw await de_DisabledOperationExceptionRes(parsedOutput, context);
         case "InternalException":
         case "com.amazonaws.elasticsearchservice#InternalException":
-            throw await deserializeAws_restJson1InternalExceptionResponse(parsedOutput, context);
+            throw await de_InternalExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.elasticsearchservice#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.elasticsearchservice#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -3072,20 +3048,20 @@ const deserializeAws_restJson1RevokeVpcEndpointAccessCommandError = async (outpu
             });
     }
 };
-export const deserializeAws_restJson1StartElasticsearchServiceSoftwareUpdateCommand = async (output, context) => {
+export const de_StartElasticsearchServiceSoftwareUpdateCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1StartElasticsearchServiceSoftwareUpdateCommandError(output, context);
+        return de_StartElasticsearchServiceSoftwareUpdateCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.ServiceSoftwareOptions != null) {
-        contents.ServiceSoftwareOptions = deserializeAws_restJson1ServiceSoftwareOptions(data.ServiceSoftwareOptions, context);
+        contents.ServiceSoftwareOptions = de_ServiceSoftwareOptions(data.ServiceSoftwareOptions, context);
     }
     return contents;
 };
-const deserializeAws_restJson1StartElasticsearchServiceSoftwareUpdateCommandError = async (output, context) => {
+const de_StartElasticsearchServiceSoftwareUpdateCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -3094,16 +3070,16 @@ const deserializeAws_restJson1StartElasticsearchServiceSoftwareUpdateCommandErro
     switch (errorCode) {
         case "BaseException":
         case "com.amazonaws.elasticsearchservice#BaseException":
-            throw await deserializeAws_restJson1BaseExceptionResponse(parsedOutput, context);
+            throw await de_BaseExceptionRes(parsedOutput, context);
         case "InternalException":
         case "com.amazonaws.elasticsearchservice#InternalException":
-            throw await deserializeAws_restJson1InternalExceptionResponse(parsedOutput, context);
+            throw await de_InternalExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.elasticsearchservice#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.elasticsearchservice#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -3114,23 +3090,23 @@ const deserializeAws_restJson1StartElasticsearchServiceSoftwareUpdateCommandErro
             });
     }
 };
-export const deserializeAws_restJson1UpdateElasticsearchDomainConfigCommand = async (output, context) => {
+export const de_UpdateElasticsearchDomainConfigCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1UpdateElasticsearchDomainConfigCommandError(output, context);
+        return de_UpdateElasticsearchDomainConfigCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.DomainConfig != null) {
-        contents.DomainConfig = deserializeAws_restJson1ElasticsearchDomainConfig(data.DomainConfig, context);
+        contents.DomainConfig = de_ElasticsearchDomainConfig(data.DomainConfig, context);
     }
     if (data.DryRunResults != null) {
-        contents.DryRunResults = deserializeAws_restJson1DryRunResults(data.DryRunResults, context);
+        contents.DryRunResults = de_DryRunResults(data.DryRunResults, context);
     }
     return contents;
 };
-const deserializeAws_restJson1UpdateElasticsearchDomainConfigCommandError = async (output, context) => {
+const de_UpdateElasticsearchDomainConfigCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -3139,22 +3115,22 @@ const deserializeAws_restJson1UpdateElasticsearchDomainConfigCommandError = asyn
     switch (errorCode) {
         case "BaseException":
         case "com.amazonaws.elasticsearchservice#BaseException":
-            throw await deserializeAws_restJson1BaseExceptionResponse(parsedOutput, context);
+            throw await de_BaseExceptionRes(parsedOutput, context);
         case "InternalException":
         case "com.amazonaws.elasticsearchservice#InternalException":
-            throw await deserializeAws_restJson1InternalExceptionResponse(parsedOutput, context);
+            throw await de_InternalExceptionRes(parsedOutput, context);
         case "InvalidTypeException":
         case "com.amazonaws.elasticsearchservice#InvalidTypeException":
-            throw await deserializeAws_restJson1InvalidTypeExceptionResponse(parsedOutput, context);
+            throw await de_InvalidTypeExceptionRes(parsedOutput, context);
         case "LimitExceededException":
         case "com.amazonaws.elasticsearchservice#LimitExceededException":
-            throw await deserializeAws_restJson1LimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.elasticsearchservice#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.elasticsearchservice#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -3165,20 +3141,20 @@ const deserializeAws_restJson1UpdateElasticsearchDomainConfigCommandError = asyn
             });
     }
 };
-export const deserializeAws_restJson1UpdatePackageCommand = async (output, context) => {
+export const de_UpdatePackageCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1UpdatePackageCommandError(output, context);
+        return de_UpdatePackageCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.PackageDetails != null) {
-        contents.PackageDetails = deserializeAws_restJson1PackageDetails(data.PackageDetails, context);
+        contents.PackageDetails = de_PackageDetails(data.PackageDetails, context);
     }
     return contents;
 };
-const deserializeAws_restJson1UpdatePackageCommandError = async (output, context) => {
+const de_UpdatePackageCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -3187,22 +3163,22 @@ const deserializeAws_restJson1UpdatePackageCommandError = async (output, context
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.elasticsearchservice#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "BaseException":
         case "com.amazonaws.elasticsearchservice#BaseException":
-            throw await deserializeAws_restJson1BaseExceptionResponse(parsedOutput, context);
+            throw await de_BaseExceptionRes(parsedOutput, context);
         case "InternalException":
         case "com.amazonaws.elasticsearchservice#InternalException":
-            throw await deserializeAws_restJson1InternalExceptionResponse(parsedOutput, context);
+            throw await de_InternalExceptionRes(parsedOutput, context);
         case "LimitExceededException":
         case "com.amazonaws.elasticsearchservice#LimitExceededException":
-            throw await deserializeAws_restJson1LimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.elasticsearchservice#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.elasticsearchservice#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -3213,20 +3189,20 @@ const deserializeAws_restJson1UpdatePackageCommandError = async (output, context
             });
     }
 };
-export const deserializeAws_restJson1UpdateVpcEndpointCommand = async (output, context) => {
+export const de_UpdateVpcEndpointCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1UpdateVpcEndpointCommandError(output, context);
+        return de_UpdateVpcEndpointCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.VpcEndpoint != null) {
-        contents.VpcEndpoint = deserializeAws_restJson1VpcEndpoint(data.VpcEndpoint, context);
+        contents.VpcEndpoint = de_VpcEndpoint(data.VpcEndpoint, context);
     }
     return contents;
 };
-const deserializeAws_restJson1UpdateVpcEndpointCommandError = async (output, context) => {
+const de_UpdateVpcEndpointCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -3235,22 +3211,22 @@ const deserializeAws_restJson1UpdateVpcEndpointCommandError = async (output, con
     switch (errorCode) {
         case "BaseException":
         case "com.amazonaws.elasticsearchservice#BaseException":
-            throw await deserializeAws_restJson1BaseExceptionResponse(parsedOutput, context);
+            throw await de_BaseExceptionRes(parsedOutput, context);
         case "ConflictException":
         case "com.amazonaws.elasticsearchservice#ConflictException":
-            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "DisabledOperationException":
         case "com.amazonaws.elasticsearchservice#DisabledOperationException":
-            throw await deserializeAws_restJson1DisabledOperationExceptionResponse(parsedOutput, context);
+            throw await de_DisabledOperationExceptionRes(parsedOutput, context);
         case "InternalException":
         case "com.amazonaws.elasticsearchservice#InternalException":
-            throw await deserializeAws_restJson1InternalExceptionResponse(parsedOutput, context);
+            throw await de_InternalExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.elasticsearchservice#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.elasticsearchservice#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -3261,16 +3237,16 @@ const deserializeAws_restJson1UpdateVpcEndpointCommandError = async (output, con
             });
     }
 };
-export const deserializeAws_restJson1UpgradeElasticsearchDomainCommand = async (output, context) => {
+export const de_UpgradeElasticsearchDomainCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1UpgradeElasticsearchDomainCommandError(output, context);
+        return de_UpgradeElasticsearchDomainCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.ChangeProgressDetails != null) {
-        contents.ChangeProgressDetails = deserializeAws_restJson1ChangeProgressDetails(data.ChangeProgressDetails, context);
+        contents.ChangeProgressDetails = de_ChangeProgressDetails(data.ChangeProgressDetails, context);
     }
     if (data.DomainName != null) {
         contents.DomainName = __expectString(data.DomainName);
@@ -3283,7 +3259,7 @@ export const deserializeAws_restJson1UpgradeElasticsearchDomainCommand = async (
     }
     return contents;
 };
-const deserializeAws_restJson1UpgradeElasticsearchDomainCommandError = async (output, context) => {
+const de_UpgradeElasticsearchDomainCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -3292,22 +3268,22 @@ const deserializeAws_restJson1UpgradeElasticsearchDomainCommandError = async (ou
     switch (errorCode) {
         case "BaseException":
         case "com.amazonaws.elasticsearchservice#BaseException":
-            throw await deserializeAws_restJson1BaseExceptionResponse(parsedOutput, context);
+            throw await de_BaseExceptionRes(parsedOutput, context);
         case "DisabledOperationException":
         case "com.amazonaws.elasticsearchservice#DisabledOperationException":
-            throw await deserializeAws_restJson1DisabledOperationExceptionResponse(parsedOutput, context);
+            throw await de_DisabledOperationExceptionRes(parsedOutput, context);
         case "InternalException":
         case "com.amazonaws.elasticsearchservice#InternalException":
-            throw await deserializeAws_restJson1InternalExceptionResponse(parsedOutput, context);
+            throw await de_InternalExceptionRes(parsedOutput, context);
         case "ResourceAlreadyExistsException":
         case "com.amazonaws.elasticsearchservice#ResourceAlreadyExistsException":
-            throw await deserializeAws_restJson1ResourceAlreadyExistsExceptionResponse(parsedOutput, context);
+            throw await de_ResourceAlreadyExistsExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.elasticsearchservice#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.elasticsearchservice#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -3319,7 +3295,7 @@ const deserializeAws_restJson1UpgradeElasticsearchDomainCommandError = async (ou
     }
 };
 const map = __map;
-const deserializeAws_restJson1AccessDeniedExceptionResponse = async (parsedOutput, context) => {
+const de_AccessDeniedExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     if (data.message != null) {
@@ -3331,7 +3307,7 @@ const deserializeAws_restJson1AccessDeniedExceptionResponse = async (parsedOutpu
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const deserializeAws_restJson1BaseExceptionResponse = async (parsedOutput, context) => {
+const de_BaseExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     if (data.message != null) {
@@ -3343,7 +3319,7 @@ const deserializeAws_restJson1BaseExceptionResponse = async (parsedOutput, conte
     });
     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.message != null) {
@@ -3355,7 +3331,7 @@ const deserializeAws_restJson1ConflictExceptionResponse = async (parsedOutput, c
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const deserializeAws_restJson1DisabledOperationExceptionResponse = async (parsedOutput, context) => {
+const de_DisabledOperationExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     if (data.message != null) {
@@ -3367,7 +3343,7 @@ const deserializeAws_restJson1DisabledOperationExceptionResponse = async (parsed
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const deserializeAws_restJson1InternalExceptionResponse = async (parsedOutput, context) => {
+const de_InternalExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     if (data.message != null) {
@@ -3379,7 +3355,7 @@ const deserializeAws_restJson1InternalExceptionResponse = async (parsedOutput, c
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const deserializeAws_restJson1InvalidPaginationTokenExceptionResponse = async (parsedOutput, context) => {
+const de_InvalidPaginationTokenExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     if (data.message != null) {
@@ -3391,7 +3367,7 @@ const deserializeAws_restJson1InvalidPaginationTokenExceptionResponse = async (p
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const deserializeAws_restJson1InvalidTypeExceptionResponse = async (parsedOutput, context) => {
+const de_InvalidTypeExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     if (data.message != null) {
@@ -3403,7 +3379,7 @@ const deserializeAws_restJson1InvalidTypeExceptionResponse = async (parsedOutput
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const deserializeAws_restJson1LimitExceededExceptionResponse = async (parsedOutput, context) => {
+const de_LimitExceededExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     if (data.message != null) {
@@ -3415,7 +3391,7 @@ const deserializeAws_restJson1LimitExceededExceptionResponse = async (parsedOutp
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const deserializeAws_restJson1ResourceAlreadyExistsExceptionResponse = async (parsedOutput, context) => {
+const de_ResourceAlreadyExistsExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     if (data.message != null) {
@@ -3427,7 +3403,7 @@ const deserializeAws_restJson1ResourceAlreadyExistsExceptionResponse = async (pa
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const deserializeAws_restJson1ResourceNotFoundExceptionResponse = async (parsedOutput, context) => {
+const de_ResourceNotFoundExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     if (data.message != null) {
@@ -3439,7 +3415,7 @@ const deserializeAws_restJson1ResourceNotFoundExceptionResponse = async (parsedO
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const deserializeAws_restJson1ValidationExceptionResponse = async (parsedOutput, context) => {
+const de_ValidationExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     if (data.message != null) {
@@ -3451,7 +3427,7 @@ const deserializeAws_restJson1ValidationExceptionResponse = async (parsedOutput,
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const serializeAws_restJson1AdvancedOptions = (input, context) => {
+const se_AdvancedOptions = (input, context) => {
     return Object.entries(input).reduce((acc, [key, value]) => {
         if (value === null) {
             return acc;
@@ -3460,7 +3436,7 @@ const serializeAws_restJson1AdvancedOptions = (input, context) => {
         return acc;
     }, {});
 };
-const serializeAws_restJson1AdvancedSecurityOptionsInput = (input, context) => {
+const se_AdvancedSecurityOptionsInput = (input, context) => {
     return {
         ...(input.AnonymousAuthEnabled != null && { AnonymousAuthEnabled: input.AnonymousAuthEnabled }),
         ...(input.Enabled != null && { Enabled: input.Enabled }),
@@ -3468,47 +3444,45 @@ const serializeAws_restJson1AdvancedSecurityOptionsInput = (input, context) => {
             InternalUserDatabaseEnabled: input.InternalUserDatabaseEnabled,
         }),
         ...(input.MasterUserOptions != null && {
-            MasterUserOptions: serializeAws_restJson1MasterUserOptions(input.MasterUserOptions, context),
-        }),
-        ...(input.SAMLOptions != null && {
-            SAMLOptions: serializeAws_restJson1SAMLOptionsInput(input.SAMLOptions, context),
+            MasterUserOptions: se_MasterUserOptions(input.MasterUserOptions, context),
         }),
+        ...(input.SAMLOptions != null && { SAMLOptions: se_SAMLOptionsInput(input.SAMLOptions, context) }),
     };
 };
-const serializeAws_restJson1AutoTuneMaintenanceSchedule = (input, context) => {
+const se_AutoTuneMaintenanceSchedule = (input, context) => {
     return {
         ...(input.CronExpressionForRecurrence != null && {
             CronExpressionForRecurrence: input.CronExpressionForRecurrence,
         }),
-        ...(input.Duration != null && { Duration: serializeAws_restJson1Duration(input.Duration, context) }),
+        ...(input.Duration != null && { Duration: se_Duration(input.Duration, context) }),
         ...(input.StartAt != null && { StartAt: Math.round(input.StartAt.getTime() / 1000) }),
     };
 };
-const serializeAws_restJson1AutoTuneMaintenanceScheduleList = (input, context) => {
+const se_AutoTuneMaintenanceScheduleList = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
-        return serializeAws_restJson1AutoTuneMaintenanceSchedule(entry, context);
+        return se_AutoTuneMaintenanceSchedule(entry, context);
     });
 };
-const serializeAws_restJson1AutoTuneOptions = (input, context) => {
+const se_AutoTuneOptions = (input, context) => {
     return {
         ...(input.DesiredState != null && { DesiredState: input.DesiredState }),
         ...(input.MaintenanceSchedules != null && {
-            MaintenanceSchedules: serializeAws_restJson1AutoTuneMaintenanceScheduleList(input.MaintenanceSchedules, context),
+            MaintenanceSchedules: se_AutoTuneMaintenanceScheduleList(input.MaintenanceSchedules, context),
         }),
         ...(input.RollbackOnDisable != null && { RollbackOnDisable: input.RollbackOnDisable }),
     };
 };
-const serializeAws_restJson1AutoTuneOptionsInput = (input, context) => {
+const se_AutoTuneOptionsInput = (input, context) => {
     return {
         ...(input.DesiredState != null && { DesiredState: input.DesiredState }),
         ...(input.MaintenanceSchedules != null && {
-            MaintenanceSchedules: serializeAws_restJson1AutoTuneMaintenanceScheduleList(input.MaintenanceSchedules, context),
+            MaintenanceSchedules: se_AutoTuneMaintenanceScheduleList(input.MaintenanceSchedules, context),
         }),
     };
 };
-const serializeAws_restJson1CognitoOptions = (input, context) => {
+const se_CognitoOptions = (input, context) => {
     return {
         ...(input.Enabled != null && { Enabled: input.Enabled }),
         ...(input.IdentityPoolId != null && { IdentityPoolId: input.IdentityPoolId }),
@@ -3516,32 +3490,32 @@ const serializeAws_restJson1CognitoOptions = (input, context) => {
         ...(input.UserPoolId != null && { UserPoolId: input.UserPoolId }),
     };
 };
-const serializeAws_restJson1ColdStorageOptions = (input, context) => {
+const se_ColdStorageOptions = (input, context) => {
     return {
         ...(input.Enabled != null && { Enabled: input.Enabled }),
     };
 };
-const serializeAws_restJson1DescribePackagesFilter = (input, context) => {
+const se_DescribePackagesFilter = (input, context) => {
     return {
         ...(input.Name != null && { Name: input.Name }),
-        ...(input.Value != null && { Value: serializeAws_restJson1DescribePackagesFilterValues(input.Value, context) }),
+        ...(input.Value != null && { Value: se_DescribePackagesFilterValues(input.Value, context) }),
     };
 };
-const serializeAws_restJson1DescribePackagesFilterList = (input, context) => {
+const se_DescribePackagesFilterList = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
-        return serializeAws_restJson1DescribePackagesFilter(entry, context);
+        return se_DescribePackagesFilter(entry, context);
     });
 };
-const serializeAws_restJson1DescribePackagesFilterValues = (input, context) => {
+const se_DescribePackagesFilterValues = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
         return entry;
     });
 };
-const serializeAws_restJson1DomainEndpointOptions = (input, context) => {
+const se_DomainEndpointOptions = (input, context) => {
     return {
         ...(input.CustomEndpoint != null && { CustomEndpoint: input.CustomEndpoint }),
         ...(input.CustomEndpointCertificateArn != null && {
@@ -3552,27 +3526,27 @@ const serializeAws_restJson1DomainEndpointOptions = (input, context) => {
         ...(input.TLSSecurityPolicy != null && { TLSSecurityPolicy: input.TLSSecurityPolicy }),
     };
 };
-const serializeAws_restJson1DomainInformation = (input, context) => {
+const se_DomainInformation = (input, context) => {
     return {
         ...(input.DomainName != null && { DomainName: input.DomainName }),
         ...(input.OwnerId != null && { OwnerId: input.OwnerId }),
         ...(input.Region != null && { Region: input.Region }),
     };
 };
-const serializeAws_restJson1DomainNameList = (input, context) => {
+const se_DomainNameList = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
         return entry;
     });
 };
-const serializeAws_restJson1Duration = (input, context) => {
+const se_Duration = (input, context) => {
     return {
         ...(input.Unit != null && { Unit: input.Unit }),
         ...(input.Value != null && { Value: input.Value }),
     };
 };
-const serializeAws_restJson1EBSOptions = (input, context) => {
+const se_EBSOptions = (input, context) => {
     return {
         ...(input.EBSEnabled != null && { EBSEnabled: input.EBSEnabled }),
         ...(input.Iops != null && { Iops: input.Iops }),
@@ -3581,10 +3555,10 @@ const serializeAws_restJson1EBSOptions = (input, context) => {
         ...(input.VolumeType != null && { VolumeType: input.VolumeType }),
     };
 };
-const serializeAws_restJson1ElasticsearchClusterConfig = (input, context) => {
+const se_ElasticsearchClusterConfig = (input, context) => {
     return {
         ...(input.ColdStorageOptions != null && {
-            ColdStorageOptions: serializeAws_restJson1ColdStorageOptions(input.ColdStorageOptions, context),
+            ColdStorageOptions: se_ColdStorageOptions(input.ColdStorageOptions, context),
         }),
         ...(input.DedicatedMasterCount != null && { DedicatedMasterCount: input.DedicatedMasterCount }),
         ...(input.DedicatedMasterEnabled != null && { DedicatedMasterEnabled: input.DedicatedMasterEnabled }),
@@ -3595,73 +3569,73 @@ const serializeAws_restJson1ElasticsearchClusterConfig = (input, context) => {
         ...(input.WarmEnabled != null && { WarmEnabled: input.WarmEnabled }),
         ...(input.WarmType != null && { WarmType: input.WarmType }),
         ...(input.ZoneAwarenessConfig != null && {
-            ZoneAwarenessConfig: serializeAws_restJson1ZoneAwarenessConfig(input.ZoneAwarenessConfig, context),
+            ZoneAwarenessConfig: se_ZoneAwarenessConfig(input.ZoneAwarenessConfig, context),
         }),
         ...(input.ZoneAwarenessEnabled != null && { ZoneAwarenessEnabled: input.ZoneAwarenessEnabled }),
     };
 };
-const serializeAws_restJson1EncryptionAtRestOptions = (input, context) => {
+const se_EncryptionAtRestOptions = (input, context) => {
     return {
         ...(input.Enabled != null && { Enabled: input.Enabled }),
         ...(input.KmsKeyId != null && { KmsKeyId: input.KmsKeyId }),
     };
 };
-const serializeAws_restJson1Filter = (input, context) => {
+const se_Filter = (input, context) => {
     return {
         ...(input.Name != null && { Name: input.Name }),
-        ...(input.Values != null && { Values: serializeAws_restJson1ValueStringList(input.Values, context) }),
+        ...(input.Values != null && { Values: se_ValueStringList(input.Values, context) }),
     };
 };
-const serializeAws_restJson1FilterList = (input, context) => {
+const se_FilterList = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
-        return serializeAws_restJson1Filter(entry, context);
+        return se_Filter(entry, context);
     });
 };
-const serializeAws_restJson1LogPublishingOption = (input, context) => {
+const se_LogPublishingOption = (input, context) => {
     return {
         ...(input.CloudWatchLogsLogGroupArn != null && { CloudWatchLogsLogGroupArn: input.CloudWatchLogsLogGroupArn }),
         ...(input.Enabled != null && { Enabled: input.Enabled }),
     };
 };
-const serializeAws_restJson1LogPublishingOptions = (input, context) => {
+const se_LogPublishingOptions = (input, context) => {
     return Object.entries(input).reduce((acc, [key, value]) => {
         if (value === null) {
             return acc;
         }
-        acc[key] = serializeAws_restJson1LogPublishingOption(value, context);
+        acc[key] = se_LogPublishingOption(value, context);
         return acc;
     }, {});
 };
-const serializeAws_restJson1MasterUserOptions = (input, context) => {
+const se_MasterUserOptions = (input, context) => {
     return {
         ...(input.MasterUserARN != null && { MasterUserARN: input.MasterUserARN }),
         ...(input.MasterUserName != null && { MasterUserName: input.MasterUserName }),
         ...(input.MasterUserPassword != null && { MasterUserPassword: input.MasterUserPassword }),
     };
 };
-const serializeAws_restJson1NodeToNodeEncryptionOptions = (input, context) => {
+const se_NodeToNodeEncryptionOptions = (input, context) => {
     return {
         ...(input.Enabled != null && { Enabled: input.Enabled }),
     };
 };
-const serializeAws_restJson1PackageSource = (input, context) => {
+const se_PackageSource = (input, context) => {
     return {
         ...(input.S3BucketName != null && { S3BucketName: input.S3BucketName }),
         ...(input.S3Key != null && { S3Key: input.S3Key }),
     };
 };
-const serializeAws_restJson1SAMLIdp = (input, context) => {
+const se_SAMLIdp = (input, context) => {
     return {
         ...(input.EntityId != null && { EntityId: input.EntityId }),
         ...(input.MetadataContent != null && { MetadataContent: input.MetadataContent }),
     };
 };
-const serializeAws_restJson1SAMLOptionsInput = (input, context) => {
+const se_SAMLOptionsInput = (input, context) => {
     return {
         ...(input.Enabled != null && { Enabled: input.Enabled }),
-        ...(input.Idp != null && { Idp: serializeAws_restJson1SAMLIdp(input.Idp, context) }),
+        ...(input.Idp != null && { Idp: se_SAMLIdp(input.Idp, context) }),
         ...(input.MasterBackendRole != null && { MasterBackendRole: input.MasterBackendRole }),
         ...(input.MasterUserName != null && { MasterUserName: input.MasterUserName }),
         ...(input.RolesKey != null && { RolesKey: input.RolesKey }),
@@ -3669,82 +3643,80 @@ const serializeAws_restJson1SAMLOptionsInput = (input, context) => {
         ...(input.SubjectKey != null && { SubjectKey: input.SubjectKey }),
     };
 };
-const serializeAws_restJson1SnapshotOptions = (input, context) => {
+const se_SnapshotOptions = (input, context) => {
     return {
         ...(input.AutomatedSnapshotStartHour != null && { AutomatedSnapshotStartHour: input.AutomatedSnapshotStartHour }),
     };
 };
-const serializeAws_restJson1StringList = (input, context) => {
+const se_StringList = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
         return entry;
     });
 };
-const serializeAws_restJson1Tag = (input, context) => {
+const se_Tag = (input, context) => {
     return {
         ...(input.Key != null && { Key: input.Key }),
         ...(input.Value != null && { Value: input.Value }),
     };
 };
-const serializeAws_restJson1TagList = (input, context) => {
+const se_TagList = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
-        return serializeAws_restJson1Tag(entry, context);
+        return se_Tag(entry, context);
     });
 };
-const serializeAws_restJson1ValueStringList = (input, context) => {
+const se_ValueStringList = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
         return entry;
     });
 };
-const serializeAws_restJson1VpcEndpointIdList = (input, context) => {
+const se_VpcEndpointIdList = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
         return entry;
     });
 };
-const serializeAws_restJson1VPCOptions = (input, context) => {
+const se_VPCOptions = (input, context) => {
     return {
-        ...(input.SecurityGroupIds != null && {
-            SecurityGroupIds: serializeAws_restJson1StringList(input.SecurityGroupIds, context),
-        }),
-        ...(input.SubnetIds != null && { SubnetIds: serializeAws_restJson1StringList(input.SubnetIds, context) }),
+        ...(input.SecurityGroupIds != null && { SecurityGroupIds: se_StringList(input.SecurityGroupIds, context) }),
+        ...(input.SubnetIds != null && { SubnetIds: se_StringList(input.SubnetIds, context) }),
     };
 };
-const serializeAws_restJson1ZoneAwarenessConfig = (input, context) => {
+const se_ZoneAwarenessConfig = (input, context) => {
     return {
         ...(input.AvailabilityZoneCount != null && { AvailabilityZoneCount: input.AvailabilityZoneCount }),
     };
 };
-const deserializeAws_restJson1AccessPoliciesStatus = (output, context) => {
+const de_AccessPoliciesStatus = (output, context) => {
     return {
         Options: __expectString(output.Options),
-        Status: output.Status != null ? deserializeAws_restJson1OptionStatus(output.Status, context) : undefined,
+        Status: output.Status != null ? de_OptionStatus(output.Status, context) : undefined,
     };
 };
-const deserializeAws_restJson1AdditionalLimit = (output, context) => {
+const de_AdditionalLimit = (output, context) => {
     return {
         LimitName: __expectString(output.LimitName),
-        LimitValues: output.LimitValues != null ? deserializeAws_restJson1LimitValueList(output.LimitValues, context) : undefined,
+        LimitValues: output.LimitValues != null ? de_LimitValueList(output.LimitValues, context) : undefined,
     };
 };
-const deserializeAws_restJson1AdditionalLimitList = (output, context) => {
+const de_AdditionalLimitList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1AdditionalLimit(entry, context);
+        return de_AdditionalLimit(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1AdvancedOptions = (output, context) => {
+const de_AdvancedOptions = (output, context) => {
     return Object.entries(output).reduce((acc, [key, value]) => {
         if (value === null) {
             return acc;
@@ -3753,13 +3725,13 @@ const deserializeAws_restJson1AdvancedOptions = (output, context) => {
         return acc;
     }, {});
 };
-const deserializeAws_restJson1AdvancedOptionsStatus = (output, context) => {
+const de_AdvancedOptionsStatus = (output, context) => {
     return {
-        Options: output.Options != null ? deserializeAws_restJson1AdvancedOptions(output.Options, context) : undefined,
-        Status: output.Status != null ? deserializeAws_restJson1OptionStatus(output.Status, context) : undefined,
+        Options: output.Options != null ? de_AdvancedOptions(output.Options, context) : undefined,
+        Status: output.Status != null ? de_OptionStatus(output.Status, context) : undefined,
     };
 };
-const deserializeAws_restJson1AdvancedSecurityOptions = (output, context) => {
+const de_AdvancedSecurityOptions = (output, context) => {
     return {
         AnonymousAuthDisableDate: output.AnonymousAuthDisableDate != null
             ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.AnonymousAuthDisableDate)))
@@ -3767,98 +3739,96 @@ const deserializeAws_restJson1AdvancedSecurityOptions = (output, context) => {
         AnonymousAuthEnabled: __expectBoolean(output.AnonymousAuthEnabled),
         Enabled: __expectBoolean(output.Enabled),
         InternalUserDatabaseEnabled: __expectBoolean(output.InternalUserDatabaseEnabled),
-        SAMLOptions: output.SAMLOptions != null ? deserializeAws_restJson1SAMLOptionsOutput(output.SAMLOptions, context) : undefined,
+        SAMLOptions: output.SAMLOptions != null ? de_SAMLOptionsOutput(output.SAMLOptions, context) : undefined,
     };
 };
-const deserializeAws_restJson1AdvancedSecurityOptionsStatus = (output, context) => {
+const de_AdvancedSecurityOptionsStatus = (output, context) => {
     return {
-        Options: output.Options != null ? deserializeAws_restJson1AdvancedSecurityOptions(output.Options, context) : undefined,
-        Status: output.Status != null ? deserializeAws_restJson1OptionStatus(output.Status, context) : undefined,
+        Options: output.Options != null ? de_AdvancedSecurityOptions(output.Options, context) : undefined,
+        Status: output.Status != null ? de_OptionStatus(output.Status, context) : undefined,
     };
 };
-const deserializeAws_restJson1AuthorizedPrincipal = (output, context) => {
+const de_AuthorizedPrincipal = (output, context) => {
     return {
         Principal: __expectString(output.Principal),
         PrincipalType: __expectString(output.PrincipalType),
     };
 };
-const deserializeAws_restJson1AuthorizedPrincipalList = (output, context) => {
+const de_AuthorizedPrincipalList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1AuthorizedPrincipal(entry, context);
+        return de_AuthorizedPrincipal(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1AutoTune = (output, context) => {
+const de_AutoTune = (output, context) => {
     return {
-        AutoTuneDetails: output.AutoTuneDetails != null
-            ? deserializeAws_restJson1AutoTuneDetails(output.AutoTuneDetails, context)
-            : undefined,
+        AutoTuneDetails: output.AutoTuneDetails != null ? de_AutoTuneDetails(output.AutoTuneDetails, context) : undefined,
         AutoTuneType: __expectString(output.AutoTuneType),
     };
 };
-const deserializeAws_restJson1AutoTuneDetails = (output, context) => {
+const de_AutoTuneDetails = (output, context) => {
     return {
         ScheduledAutoTuneDetails: output.ScheduledAutoTuneDetails != null
-            ? deserializeAws_restJson1ScheduledAutoTuneDetails(output.ScheduledAutoTuneDetails, context)
+            ? de_ScheduledAutoTuneDetails(output.ScheduledAutoTuneDetails, context)
             : undefined,
     };
 };
-const deserializeAws_restJson1AutoTuneList = (output, context) => {
+const de_AutoTuneList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1AutoTune(entry, context);
+        return de_AutoTune(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1AutoTuneMaintenanceSchedule = (output, context) => {
+const de_AutoTuneMaintenanceSchedule = (output, context) => {
     return {
         CronExpressionForRecurrence: __expectString(output.CronExpressionForRecurrence),
-        Duration: output.Duration != null ? deserializeAws_restJson1Duration(output.Duration, context) : undefined,
+        Duration: output.Duration != null ? de_Duration(output.Duration, context) : undefined,
         StartAt: output.StartAt != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.StartAt))) : undefined,
     };
 };
-const deserializeAws_restJson1AutoTuneMaintenanceScheduleList = (output, context) => {
+const de_AutoTuneMaintenanceScheduleList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1AutoTuneMaintenanceSchedule(entry, context);
+        return de_AutoTuneMaintenanceSchedule(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1AutoTuneOptions = (output, context) => {
+const de_AutoTuneOptions = (output, context) => {
     return {
         DesiredState: __expectString(output.DesiredState),
         MaintenanceSchedules: output.MaintenanceSchedules != null
-            ? deserializeAws_restJson1AutoTuneMaintenanceScheduleList(output.MaintenanceSchedules, context)
+            ? de_AutoTuneMaintenanceScheduleList(output.MaintenanceSchedules, context)
             : undefined,
         RollbackOnDisable: __expectString(output.RollbackOnDisable),
     };
 };
-const deserializeAws_restJson1AutoTuneOptionsOutput = (output, context) => {
+const de_AutoTuneOptionsOutput = (output, context) => {
     return {
         ErrorMessage: __expectString(output.ErrorMessage),
         State: __expectString(output.State),
     };
 };
-const deserializeAws_restJson1AutoTuneOptionsStatus = (output, context) => {
+const de_AutoTuneOptionsStatus = (output, context) => {
     return {
-        Options: output.Options != null ? deserializeAws_restJson1AutoTuneOptions(output.Options, context) : undefined,
-        Status: output.Status != null ? deserializeAws_restJson1AutoTuneStatus(output.Status, context) : undefined,
+        Options: output.Options != null ? de_AutoTuneOptions(output.Options, context) : undefined,
+        Status: output.Status != null ? de_AutoTuneStatus(output.Status, context) : undefined,
     };
 };
-const deserializeAws_restJson1AutoTuneStatus = (output, context) => {
+const de_AutoTuneStatus = (output, context) => {
     return {
         CreationDate: output.CreationDate != null
             ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.CreationDate)))
@@ -3870,13 +3840,13 @@ const deserializeAws_restJson1AutoTuneStatus = (output, context) => {
         UpdateVersion: __expectInt32(output.UpdateVersion),
     };
 };
-const deserializeAws_restJson1ChangeProgressDetails = (output, context) => {
+const de_ChangeProgressDetails = (output, context) => {
     return {
         ChangeId: __expectString(output.ChangeId),
         Message: __expectString(output.Message),
     };
 };
-const deserializeAws_restJson1ChangeProgressStage = (output, context) => {
+const de_ChangeProgressStage = (output, context) => {
     return {
         Description: __expectString(output.Description),
         LastUpdated: output.LastUpdated != null
@@ -3886,35 +3856,31 @@ const deserializeAws_restJson1ChangeProgressStage = (output, context) => {
         Status: __expectString(output.Status),
     };
 };
-const deserializeAws_restJson1ChangeProgressStageList = (output, context) => {
+const de_ChangeProgressStageList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1ChangeProgressStage(entry, context);
+        return de_ChangeProgressStage(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1ChangeProgressStatusDetails = (output, context) => {
+const de_ChangeProgressStatusDetails = (output, context) => {
     return {
         ChangeId: __expectString(output.ChangeId),
         ChangeProgressStages: output.ChangeProgressStages != null
-            ? deserializeAws_restJson1ChangeProgressStageList(output.ChangeProgressStages, context)
-            : undefined,
-        CompletedProperties: output.CompletedProperties != null
-            ? deserializeAws_restJson1StringList(output.CompletedProperties, context)
-            : undefined,
-        PendingProperties: output.PendingProperties != null
-            ? deserializeAws_restJson1StringList(output.PendingProperties, context)
+            ? de_ChangeProgressStageList(output.ChangeProgressStages, context)
             : undefined,
+        CompletedProperties: output.CompletedProperties != null ? de_StringList(output.CompletedProperties, context) : undefined,
+        PendingProperties: output.PendingProperties != null ? de_StringList(output.PendingProperties, context) : undefined,
         StartTime: output.StartTime != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.StartTime))) : undefined,
         Status: __expectString(output.Status),
         TotalNumberOfStages: __expectInt32(output.TotalNumberOfStages),
     };
 };
-const deserializeAws_restJson1CognitoOptions = (output, context) => {
+const de_CognitoOptions = (output, context) => {
     return {
         Enabled: __expectBoolean(output.Enabled),
         IdentityPoolId: __expectString(output.IdentityPoolId),
@@ -3922,37 +3888,35 @@ const deserializeAws_restJson1CognitoOptions = (output, context) => {
         UserPoolId: __expectString(output.UserPoolId),
     };
 };
-const deserializeAws_restJson1CognitoOptionsStatus = (output, context) => {
+const de_CognitoOptionsStatus = (output, context) => {
     return {
-        Options: output.Options != null ? deserializeAws_restJson1CognitoOptions(output.Options, context) : undefined,
-        Status: output.Status != null ? deserializeAws_restJson1OptionStatus(output.Status, context) : undefined,
+        Options: output.Options != null ? de_CognitoOptions(output.Options, context) : undefined,
+        Status: output.Status != null ? de_OptionStatus(output.Status, context) : undefined,
     };
 };
-const deserializeAws_restJson1ColdStorageOptions = (output, context) => {
+const de_ColdStorageOptions = (output, context) => {
     return {
         Enabled: __expectBoolean(output.Enabled),
     };
 };
-const deserializeAws_restJson1CompatibleElasticsearchVersionsList = (output, context) => {
+const de_CompatibleElasticsearchVersionsList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1CompatibleVersionsMap(entry, context);
+        return de_CompatibleVersionsMap(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1CompatibleVersionsMap = (output, context) => {
+const de_CompatibleVersionsMap = (output, context) => {
     return {
         SourceVersion: __expectString(output.SourceVersion),
-        TargetVersions: output.TargetVersions != null
-            ? deserializeAws_restJson1ElasticsearchVersionList(output.TargetVersions, context)
-            : undefined,
+        TargetVersions: output.TargetVersions != null ? de_ElasticsearchVersionList(output.TargetVersions, context) : undefined,
     };
 };
-const deserializeAws_restJson1DomainEndpointOptions = (output, context) => {
+const de_DomainEndpointOptions = (output, context) => {
     return {
         CustomEndpoint: __expectString(output.CustomEndpoint),
         CustomEndpointCertificateArn: __expectString(output.CustomEndpointCertificateArn),
@@ -3961,41 +3925,41 @@ const deserializeAws_restJson1DomainEndpointOptions = (output, context) => {
         TLSSecurityPolicy: __expectString(output.TLSSecurityPolicy),
     };
 };
-const deserializeAws_restJson1DomainEndpointOptionsStatus = (output, context) => {
+const de_DomainEndpointOptionsStatus = (output, context) => {
     return {
-        Options: output.Options != null ? deserializeAws_restJson1DomainEndpointOptions(output.Options, context) : undefined,
-        Status: output.Status != null ? deserializeAws_restJson1OptionStatus(output.Status, context) : undefined,
+        Options: output.Options != null ? de_DomainEndpointOptions(output.Options, context) : undefined,
+        Status: output.Status != null ? de_OptionStatus(output.Status, context) : undefined,
     };
 };
-const deserializeAws_restJson1DomainInfo = (output, context) => {
+const de_DomainInfo = (output, context) => {
     return {
         DomainName: __expectString(output.DomainName),
         EngineType: __expectString(output.EngineType),
     };
 };
-const deserializeAws_restJson1DomainInfoList = (output, context) => {
+const de_DomainInfoList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1DomainInfo(entry, context);
+        return de_DomainInfo(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1DomainInformation = (output, context) => {
+const de_DomainInformation = (output, context) => {
     return {
         DomainName: __expectString(output.DomainName),
         OwnerId: __expectString(output.OwnerId),
         Region: __expectString(output.Region),
     };
 };
-const deserializeAws_restJson1DomainPackageDetails = (output, context) => {
+const de_DomainPackageDetails = (output, context) => {
     return {
         DomainName: __expectString(output.DomainName),
         DomainPackageStatus: __expectString(output.DomainPackageStatus),
-        ErrorDetails: output.ErrorDetails != null ? deserializeAws_restJson1ErrorDetails(output.ErrorDetails, context) : undefined,
+        ErrorDetails: output.ErrorDetails != null ? de_ErrorDetails(output.ErrorDetails, context) : undefined,
         LastUpdated: output.LastUpdated != null
             ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.LastUpdated)))
             : undefined,
@@ -4006,30 +3970,30 @@ const deserializeAws_restJson1DomainPackageDetails = (output, context) => {
         ReferencePath: __expectString(output.ReferencePath),
     };
 };
-const deserializeAws_restJson1DomainPackageDetailsList = (output, context) => {
+const de_DomainPackageDetailsList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1DomainPackageDetails(entry, context);
+        return de_DomainPackageDetails(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1DryRunResults = (output, context) => {
+const de_DryRunResults = (output, context) => {
     return {
         DeploymentType: __expectString(output.DeploymentType),
         Message: __expectString(output.Message),
     };
 };
-const deserializeAws_restJson1Duration = (output, context) => {
+const de_Duration = (output, context) => {
     return {
         Unit: __expectString(output.Unit),
         Value: __expectLong(output.Value),
     };
 };
-const deserializeAws_restJson1EBSOptions = (output, context) => {
+const de_EBSOptions = (output, context) => {
     return {
         EBSEnabled: __expectBoolean(output.EBSEnabled),
         Iops: __expectInt32(output.Iops),
@@ -4038,17 +4002,15 @@ const deserializeAws_restJson1EBSOptions = (output, context) => {
         VolumeType: __expectString(output.VolumeType),
     };
 };
-const deserializeAws_restJson1EBSOptionsStatus = (output, context) => {
+const de_EBSOptionsStatus = (output, context) => {
     return {
-        Options: output.Options != null ? deserializeAws_restJson1EBSOptions(output.Options, context) : undefined,
-        Status: output.Status != null ? deserializeAws_restJson1OptionStatus(output.Status, context) : undefined,
+        Options: output.Options != null ? de_EBSOptions(output.Options, context) : undefined,
+        Status: output.Status != null ? de_OptionStatus(output.Status, context) : undefined,
     };
 };
-const deserializeAws_restJson1ElasticsearchClusterConfig = (output, context) => {
+const de_ElasticsearchClusterConfig = (output, context) => {
     return {
-        ColdStorageOptions: output.ColdStorageOptions != null
-            ? deserializeAws_restJson1ColdStorageOptions(output.ColdStorageOptions, context)
-            : undefined,
+        ColdStorageOptions: output.ColdStorageOptions != null ? de_ColdStorageOptions(output.ColdStorageOptions, context) : undefined,
         DedicatedMasterCount: __expectInt32(output.DedicatedMasterCount),
         DedicatedMasterEnabled: __expectBoolean(output.DedicatedMasterEnabled),
         DedicatedMasterType: __expectString(output.DedicatedMasterType),
@@ -4057,128 +4019,106 @@ const deserializeAws_restJson1ElasticsearchClusterConfig = (output, context) =>
         WarmCount: __expectInt32(output.WarmCount),
         WarmEnabled: __expectBoolean(output.WarmEnabled),
         WarmType: __expectString(output.WarmType),
-        ZoneAwarenessConfig: output.ZoneAwarenessConfig != null
-            ? deserializeAws_restJson1ZoneAwarenessConfig(output.ZoneAwarenessConfig, context)
-            : undefined,
+        ZoneAwarenessConfig: output.ZoneAwarenessConfig != null ? de_ZoneAwarenessConfig(output.ZoneAwarenessConfig, context) : undefined,
         ZoneAwarenessEnabled: __expectBoolean(output.ZoneAwarenessEnabled),
     };
 };
-const deserializeAws_restJson1ElasticsearchClusterConfigStatus = (output, context) => {
+const de_ElasticsearchClusterConfigStatus = (output, context) => {
     return {
-        Options: output.Options != null ? deserializeAws_restJson1ElasticsearchClusterConfig(output.Options, context) : undefined,
-        Status: output.Status != null ? deserializeAws_restJson1OptionStatus(output.Status, context) : undefined,
+        Options: output.Options != null ? de_ElasticsearchClusterConfig(output.Options, context) : undefined,
+        Status: output.Status != null ? de_OptionStatus(output.Status, context) : undefined,
     };
 };
-const deserializeAws_restJson1ElasticsearchDomainConfig = (output, context) => {
+const de_ElasticsearchDomainConfig = (output, context) => {
     return {
-        AccessPolicies: output.AccessPolicies != null
-            ? deserializeAws_restJson1AccessPoliciesStatus(output.AccessPolicies, context)
-            : undefined,
-        AdvancedOptions: output.AdvancedOptions != null
-            ? deserializeAws_restJson1AdvancedOptionsStatus(output.AdvancedOptions, context)
-            : undefined,
+        AccessPolicies: output.AccessPolicies != null ? de_AccessPoliciesStatus(output.AccessPolicies, context) : undefined,
+        AdvancedOptions: output.AdvancedOptions != null ? de_AdvancedOptionsStatus(output.AdvancedOptions, context) : undefined,
         AdvancedSecurityOptions: output.AdvancedSecurityOptions != null
-            ? deserializeAws_restJson1AdvancedSecurityOptionsStatus(output.AdvancedSecurityOptions, context)
-            : undefined,
-        AutoTuneOptions: output.AutoTuneOptions != null
-            ? deserializeAws_restJson1AutoTuneOptionsStatus(output.AutoTuneOptions, context)
+            ? de_AdvancedSecurityOptionsStatus(output.AdvancedSecurityOptions, context)
             : undefined,
+        AutoTuneOptions: output.AutoTuneOptions != null ? de_AutoTuneOptionsStatus(output.AutoTuneOptions, context) : undefined,
         ChangeProgressDetails: output.ChangeProgressDetails != null
-            ? deserializeAws_restJson1ChangeProgressDetails(output.ChangeProgressDetails, context)
-            : undefined,
-        CognitoOptions: output.CognitoOptions != null
-            ? deserializeAws_restJson1CognitoOptionsStatus(output.CognitoOptions, context)
+            ? de_ChangeProgressDetails(output.ChangeProgressDetails, context)
             : undefined,
+        CognitoOptions: output.CognitoOptions != null ? de_CognitoOptionsStatus(output.CognitoOptions, context) : undefined,
         DomainEndpointOptions: output.DomainEndpointOptions != null
-            ? deserializeAws_restJson1DomainEndpointOptionsStatus(output.DomainEndpointOptions, context)
+            ? de_DomainEndpointOptionsStatus(output.DomainEndpointOptions, context)
             : undefined,
-        EBSOptions: output.EBSOptions != null ? deserializeAws_restJson1EBSOptionsStatus(output.EBSOptions, context) : undefined,
+        EBSOptions: output.EBSOptions != null ? de_EBSOptionsStatus(output.EBSOptions, context) : undefined,
         ElasticsearchClusterConfig: output.ElasticsearchClusterConfig != null
-            ? deserializeAws_restJson1ElasticsearchClusterConfigStatus(output.ElasticsearchClusterConfig, context)
+            ? de_ElasticsearchClusterConfigStatus(output.ElasticsearchClusterConfig, context)
             : undefined,
         ElasticsearchVersion: output.ElasticsearchVersion != null
-            ? deserializeAws_restJson1ElasticsearchVersionStatus(output.ElasticsearchVersion, context)
+            ? de_ElasticsearchVersionStatus(output.ElasticsearchVersion, context)
             : undefined,
         EncryptionAtRestOptions: output.EncryptionAtRestOptions != null
-            ? deserializeAws_restJson1EncryptionAtRestOptionsStatus(output.EncryptionAtRestOptions, context)
+            ? de_EncryptionAtRestOptionsStatus(output.EncryptionAtRestOptions, context)
             : undefined,
         LogPublishingOptions: output.LogPublishingOptions != null
-            ? deserializeAws_restJson1LogPublishingOptionsStatus(output.LogPublishingOptions, context)
+            ? de_LogPublishingOptionsStatus(output.LogPublishingOptions, context)
             : undefined,
         NodeToNodeEncryptionOptions: output.NodeToNodeEncryptionOptions != null
-            ? deserializeAws_restJson1NodeToNodeEncryptionOptionsStatus(output.NodeToNodeEncryptionOptions, context)
-            : undefined,
-        SnapshotOptions: output.SnapshotOptions != null
-            ? deserializeAws_restJson1SnapshotOptionsStatus(output.SnapshotOptions, context)
+            ? de_NodeToNodeEncryptionOptionsStatus(output.NodeToNodeEncryptionOptions, context)
             : undefined,
-        VPCOptions: output.VPCOptions != null ? deserializeAws_restJson1VPCDerivedInfoStatus(output.VPCOptions, context) : undefined,
+        SnapshotOptions: output.SnapshotOptions != null ? de_SnapshotOptionsStatus(output.SnapshotOptions, context) : undefined,
+        VPCOptions: output.VPCOptions != null ? de_VPCDerivedInfoStatus(output.VPCOptions, context) : undefined,
     };
 };
-const deserializeAws_restJson1ElasticsearchDomainStatus = (output, context) => {
+const de_ElasticsearchDomainStatus = (output, context) => {
     return {
         ARN: __expectString(output.ARN),
         AccessPolicies: __expectString(output.AccessPolicies),
-        AdvancedOptions: output.AdvancedOptions != null
-            ? deserializeAws_restJson1AdvancedOptions(output.AdvancedOptions, context)
-            : undefined,
+        AdvancedOptions: output.AdvancedOptions != null ? de_AdvancedOptions(output.AdvancedOptions, context) : undefined,
         AdvancedSecurityOptions: output.AdvancedSecurityOptions != null
-            ? deserializeAws_restJson1AdvancedSecurityOptions(output.AdvancedSecurityOptions, context)
-            : undefined,
-        AutoTuneOptions: output.AutoTuneOptions != null
-            ? deserializeAws_restJson1AutoTuneOptionsOutput(output.AutoTuneOptions, context)
+            ? de_AdvancedSecurityOptions(output.AdvancedSecurityOptions, context)
             : undefined,
+        AutoTuneOptions: output.AutoTuneOptions != null ? de_AutoTuneOptionsOutput(output.AutoTuneOptions, context) : undefined,
         ChangeProgressDetails: output.ChangeProgressDetails != null
-            ? deserializeAws_restJson1ChangeProgressDetails(output.ChangeProgressDetails, context)
-            : undefined,
-        CognitoOptions: output.CognitoOptions != null
-            ? deserializeAws_restJson1CognitoOptions(output.CognitoOptions, context)
+            ? de_ChangeProgressDetails(output.ChangeProgressDetails, context)
             : undefined,
+        CognitoOptions: output.CognitoOptions != null ? de_CognitoOptions(output.CognitoOptions, context) : undefined,
         Created: __expectBoolean(output.Created),
         Deleted: __expectBoolean(output.Deleted),
         DomainEndpointOptions: output.DomainEndpointOptions != null
-            ? deserializeAws_restJson1DomainEndpointOptions(output.DomainEndpointOptions, context)
+            ? de_DomainEndpointOptions(output.DomainEndpointOptions, context)
             : undefined,
         DomainId: __expectString(output.DomainId),
         DomainName: __expectString(output.DomainName),
-        EBSOptions: output.EBSOptions != null ? deserializeAws_restJson1EBSOptions(output.EBSOptions, context) : undefined,
+        EBSOptions: output.EBSOptions != null ? de_EBSOptions(output.EBSOptions, context) : undefined,
         ElasticsearchClusterConfig: output.ElasticsearchClusterConfig != null
-            ? deserializeAws_restJson1ElasticsearchClusterConfig(output.ElasticsearchClusterConfig, context)
+            ? de_ElasticsearchClusterConfig(output.ElasticsearchClusterConfig, context)
             : undefined,
         ElasticsearchVersion: __expectString(output.ElasticsearchVersion),
         EncryptionAtRestOptions: output.EncryptionAtRestOptions != null
-            ? deserializeAws_restJson1EncryptionAtRestOptions(output.EncryptionAtRestOptions, context)
+            ? de_EncryptionAtRestOptions(output.EncryptionAtRestOptions, context)
             : undefined,
         Endpoint: __expectString(output.Endpoint),
-        Endpoints: output.Endpoints != null ? deserializeAws_restJson1EndpointsMap(output.Endpoints, context) : undefined,
-        LogPublishingOptions: output.LogPublishingOptions != null
-            ? deserializeAws_restJson1LogPublishingOptions(output.LogPublishingOptions, context)
-            : undefined,
+        Endpoints: output.Endpoints != null ? de_EndpointsMap(output.Endpoints, context) : undefined,
+        LogPublishingOptions: output.LogPublishingOptions != null ? de_LogPublishingOptions(output.LogPublishingOptions, context) : undefined,
         NodeToNodeEncryptionOptions: output.NodeToNodeEncryptionOptions != null
-            ? deserializeAws_restJson1NodeToNodeEncryptionOptions(output.NodeToNodeEncryptionOptions, context)
+            ? de_NodeToNodeEncryptionOptions(output.NodeToNodeEncryptionOptions, context)
             : undefined,
         Processing: __expectBoolean(output.Processing),
         ServiceSoftwareOptions: output.ServiceSoftwareOptions != null
-            ? deserializeAws_restJson1ServiceSoftwareOptions(output.ServiceSoftwareOptions, context)
-            : undefined,
-        SnapshotOptions: output.SnapshotOptions != null
-            ? deserializeAws_restJson1SnapshotOptions(output.SnapshotOptions, context)
+            ? de_ServiceSoftwareOptions(output.ServiceSoftwareOptions, context)
             : undefined,
+        SnapshotOptions: output.SnapshotOptions != null ? de_SnapshotOptions(output.SnapshotOptions, context) : undefined,
         UpgradeProcessing: __expectBoolean(output.UpgradeProcessing),
-        VPCOptions: output.VPCOptions != null ? deserializeAws_restJson1VPCDerivedInfo(output.VPCOptions, context) : undefined,
+        VPCOptions: output.VPCOptions != null ? de_VPCDerivedInfo(output.VPCOptions, context) : undefined,
     };
 };
-const deserializeAws_restJson1ElasticsearchDomainStatusList = (output, context) => {
+const de_ElasticsearchDomainStatusList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1ElasticsearchDomainStatus(entry, context);
+        return de_ElasticsearchDomainStatus(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1ElasticsearchInstanceTypeList = (output, context) => {
+const de_ElasticsearchInstanceTypeList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
@@ -4189,7 +4129,7 @@ const deserializeAws_restJson1ElasticsearchInstanceTypeList = (output, context)
     });
     return retVal;
 };
-const deserializeAws_restJson1ElasticsearchVersionList = (output, context) => {
+const de_ElasticsearchVersionList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
@@ -4200,25 +4140,25 @@ const deserializeAws_restJson1ElasticsearchVersionList = (output, context) => {
     });
     return retVal;
 };
-const deserializeAws_restJson1ElasticsearchVersionStatus = (output, context) => {
+const de_ElasticsearchVersionStatus = (output, context) => {
     return {
         Options: __expectString(output.Options),
-        Status: output.Status != null ? deserializeAws_restJson1OptionStatus(output.Status, context) : undefined,
+        Status: output.Status != null ? de_OptionStatus(output.Status, context) : undefined,
     };
 };
-const deserializeAws_restJson1EncryptionAtRestOptions = (output, context) => {
+const de_EncryptionAtRestOptions = (output, context) => {
     return {
         Enabled: __expectBoolean(output.Enabled),
         KmsKeyId: __expectString(output.KmsKeyId),
     };
 };
-const deserializeAws_restJson1EncryptionAtRestOptionsStatus = (output, context) => {
+const de_EncryptionAtRestOptionsStatus = (output, context) => {
     return {
-        Options: output.Options != null ? deserializeAws_restJson1EncryptionAtRestOptions(output.Options, context) : undefined,
-        Status: output.Status != null ? deserializeAws_restJson1OptionStatus(output.Status, context) : undefined,
+        Options: output.Options != null ? de_EncryptionAtRestOptions(output.Options, context) : undefined,
+        Status: output.Status != null ? de_OptionStatus(output.Status, context) : undefined,
     };
 };
-const deserializeAws_restJson1EndpointsMap = (output, context) => {
+const de_EndpointsMap = (output, context) => {
     return Object.entries(output).reduce((acc, [key, value]) => {
         if (value === null) {
             return acc;
@@ -4227,57 +4167,51 @@ const deserializeAws_restJson1EndpointsMap = (output, context) => {
         return acc;
     }, {});
 };
-const deserializeAws_restJson1ErrorDetails = (output, context) => {
+const de_ErrorDetails = (output, context) => {
     return {
         ErrorMessage: __expectString(output.ErrorMessage),
         ErrorType: __expectString(output.ErrorType),
     };
 };
-const deserializeAws_restJson1InboundCrossClusterSearchConnection = (output, context) => {
+const de_InboundCrossClusterSearchConnection = (output, context) => {
     return {
         ConnectionStatus: output.ConnectionStatus != null
-            ? deserializeAws_restJson1InboundCrossClusterSearchConnectionStatus(output.ConnectionStatus, context)
+            ? de_InboundCrossClusterSearchConnectionStatus(output.ConnectionStatus, context)
             : undefined,
         CrossClusterSearchConnectionId: __expectString(output.CrossClusterSearchConnectionId),
-        DestinationDomainInfo: output.DestinationDomainInfo != null
-            ? deserializeAws_restJson1DomainInformation(output.DestinationDomainInfo, context)
-            : undefined,
-        SourceDomainInfo: output.SourceDomainInfo != null
-            ? deserializeAws_restJson1DomainInformation(output.SourceDomainInfo, context)
-            : undefined,
+        DestinationDomainInfo: output.DestinationDomainInfo != null ? de_DomainInformation(output.DestinationDomainInfo, context) : undefined,
+        SourceDomainInfo: output.SourceDomainInfo != null ? de_DomainInformation(output.SourceDomainInfo, context) : undefined,
     };
 };
-const deserializeAws_restJson1InboundCrossClusterSearchConnections = (output, context) => {
+const de_InboundCrossClusterSearchConnections = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1InboundCrossClusterSearchConnection(entry, context);
+        return de_InboundCrossClusterSearchConnection(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1InboundCrossClusterSearchConnectionStatus = (output, context) => {
+const de_InboundCrossClusterSearchConnectionStatus = (output, context) => {
     return {
         Message: __expectString(output.Message),
         StatusCode: __expectString(output.StatusCode),
     };
 };
-const deserializeAws_restJson1InstanceCountLimits = (output, context) => {
+const de_InstanceCountLimits = (output, context) => {
     return {
         MaximumInstanceCount: __expectInt32(output.MaximumInstanceCount),
         MinimumInstanceCount: __expectInt32(output.MinimumInstanceCount),
     };
 };
-const deserializeAws_restJson1InstanceLimits = (output, context) => {
+const de_InstanceLimits = (output, context) => {
     return {
-        InstanceCountLimits: output.InstanceCountLimits != null
-            ? deserializeAws_restJson1InstanceCountLimits(output.InstanceCountLimits, context)
-            : undefined,
+        InstanceCountLimits: output.InstanceCountLimits != null ? de_InstanceCountLimits(output.InstanceCountLimits, context) : undefined,
     };
 };
-const deserializeAws_restJson1Issues = (output, context) => {
+const de_Issues = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
@@ -4288,27 +4222,23 @@ const deserializeAws_restJson1Issues = (output, context) => {
     });
     return retVal;
 };
-const deserializeAws_restJson1Limits = (output, context) => {
+const de_Limits = (output, context) => {
     return {
-        AdditionalLimits: output.AdditionalLimits != null
-            ? deserializeAws_restJson1AdditionalLimitList(output.AdditionalLimits, context)
-            : undefined,
-        InstanceLimits: output.InstanceLimits != null
-            ? deserializeAws_restJson1InstanceLimits(output.InstanceLimits, context)
-            : undefined,
-        StorageTypes: output.StorageTypes != null ? deserializeAws_restJson1StorageTypeList(output.StorageTypes, context) : undefined,
+        AdditionalLimits: output.AdditionalLimits != null ? de_AdditionalLimitList(output.AdditionalLimits, context) : undefined,
+        InstanceLimits: output.InstanceLimits != null ? de_InstanceLimits(output.InstanceLimits, context) : undefined,
+        StorageTypes: output.StorageTypes != null ? de_StorageTypeList(output.StorageTypes, context) : undefined,
     };
 };
-const deserializeAws_restJson1LimitsByRole = (output, context) => {
+const de_LimitsByRole = (output, context) => {
     return Object.entries(output).reduce((acc, [key, value]) => {
         if (value === null) {
             return acc;
         }
-        acc[key] = deserializeAws_restJson1Limits(value, context);
+        acc[key] = de_Limits(value, context);
         return acc;
     }, {});
 };
-const deserializeAws_restJson1LimitValueList = (output, context) => {
+const de_LimitValueList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
@@ -4319,39 +4249,39 @@ const deserializeAws_restJson1LimitValueList = (output, context) => {
     });
     return retVal;
 };
-const deserializeAws_restJson1LogPublishingOption = (output, context) => {
+const de_LogPublishingOption = (output, context) => {
     return {
         CloudWatchLogsLogGroupArn: __expectString(output.CloudWatchLogsLogGroupArn),
         Enabled: __expectBoolean(output.Enabled),
     };
 };
-const deserializeAws_restJson1LogPublishingOptions = (output, context) => {
+const de_LogPublishingOptions = (output, context) => {
     return Object.entries(output).reduce((acc, [key, value]) => {
         if (value === null) {
             return acc;
         }
-        acc[key] = deserializeAws_restJson1LogPublishingOption(value, context);
+        acc[key] = de_LogPublishingOption(value, context);
         return acc;
     }, {});
 };
-const deserializeAws_restJson1LogPublishingOptionsStatus = (output, context) => {
+const de_LogPublishingOptionsStatus = (output, context) => {
     return {
-        Options: output.Options != null ? deserializeAws_restJson1LogPublishingOptions(output.Options, context) : undefined,
-        Status: output.Status != null ? deserializeAws_restJson1OptionStatus(output.Status, context) : undefined,
+        Options: output.Options != null ? de_LogPublishingOptions(output.Options, context) : undefined,
+        Status: output.Status != null ? de_OptionStatus(output.Status, context) : undefined,
     };
 };
-const deserializeAws_restJson1NodeToNodeEncryptionOptions = (output, context) => {
+const de_NodeToNodeEncryptionOptions = (output, context) => {
     return {
         Enabled: __expectBoolean(output.Enabled),
     };
 };
-const deserializeAws_restJson1NodeToNodeEncryptionOptionsStatus = (output, context) => {
+const de_NodeToNodeEncryptionOptionsStatus = (output, context) => {
     return {
-        Options: output.Options != null ? deserializeAws_restJson1NodeToNodeEncryptionOptions(output.Options, context) : undefined,
-        Status: output.Status != null ? deserializeAws_restJson1OptionStatus(output.Status, context) : undefined,
+        Options: output.Options != null ? de_NodeToNodeEncryptionOptions(output.Options, context) : undefined,
+        Status: output.Status != null ? de_OptionStatus(output.Status, context) : undefined,
     };
 };
-const deserializeAws_restJson1OptionStatus = (output, context) => {
+const de_OptionStatus = (output, context) => {
     return {
         CreationDate: output.CreationDate != null
             ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.CreationDate)))
@@ -4362,43 +4292,39 @@ const deserializeAws_restJson1OptionStatus = (output, context) => {
         UpdateVersion: __expectInt32(output.UpdateVersion),
     };
 };
-const deserializeAws_restJson1OutboundCrossClusterSearchConnection = (output, context) => {
+const de_OutboundCrossClusterSearchConnection = (output, context) => {
     return {
         ConnectionAlias: __expectString(output.ConnectionAlias),
         ConnectionStatus: output.ConnectionStatus != null
-            ? deserializeAws_restJson1OutboundCrossClusterSearchConnectionStatus(output.ConnectionStatus, context)
+            ? de_OutboundCrossClusterSearchConnectionStatus(output.ConnectionStatus, context)
             : undefined,
         CrossClusterSearchConnectionId: __expectString(output.CrossClusterSearchConnectionId),
-        DestinationDomainInfo: output.DestinationDomainInfo != null
-            ? deserializeAws_restJson1DomainInformation(output.DestinationDomainInfo, context)
-            : undefined,
-        SourceDomainInfo: output.SourceDomainInfo != null
-            ? deserializeAws_restJson1DomainInformation(output.SourceDomainInfo, context)
-            : undefined,
+        DestinationDomainInfo: output.DestinationDomainInfo != null ? de_DomainInformation(output.DestinationDomainInfo, context) : undefined,
+        SourceDomainInfo: output.SourceDomainInfo != null ? de_DomainInformation(output.SourceDomainInfo, context) : undefined,
     };
 };
-const deserializeAws_restJson1OutboundCrossClusterSearchConnections = (output, context) => {
+const de_OutboundCrossClusterSearchConnections = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1OutboundCrossClusterSearchConnection(entry, context);
+        return de_OutboundCrossClusterSearchConnection(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1OutboundCrossClusterSearchConnectionStatus = (output, context) => {
+const de_OutboundCrossClusterSearchConnectionStatus = (output, context) => {
     return {
         Message: __expectString(output.Message),
         StatusCode: __expectString(output.StatusCode),
     };
 };
-const deserializeAws_restJson1PackageDetails = (output, context) => {
+const de_PackageDetails = (output, context) => {
     return {
         AvailablePackageVersion: __expectString(output.AvailablePackageVersion),
         CreatedAt: output.CreatedAt != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.CreatedAt))) : undefined,
-        ErrorDetails: output.ErrorDetails != null ? deserializeAws_restJson1ErrorDetails(output.ErrorDetails, context) : undefined,
+        ErrorDetails: output.ErrorDetails != null ? de_ErrorDetails(output.ErrorDetails, context) : undefined,
         LastUpdatedAt: output.LastUpdatedAt != null
             ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.LastUpdatedAt)))
             : undefined,
@@ -4409,53 +4335,53 @@ const deserializeAws_restJson1PackageDetails = (output, context) => {
         PackageType: __expectString(output.PackageType),
     };
 };
-const deserializeAws_restJson1PackageDetailsList = (output, context) => {
+const de_PackageDetailsList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1PackageDetails(entry, context);
+        return de_PackageDetails(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1PackageVersionHistory = (output, context) => {
+const de_PackageVersionHistory = (output, context) => {
     return {
         CommitMessage: __expectString(output.CommitMessage),
         CreatedAt: output.CreatedAt != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.CreatedAt))) : undefined,
         PackageVersion: __expectString(output.PackageVersion),
     };
 };
-const deserializeAws_restJson1PackageVersionHistoryList = (output, context) => {
+const de_PackageVersionHistoryList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1PackageVersionHistory(entry, context);
+        return de_PackageVersionHistory(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1RecurringCharge = (output, context) => {
+const de_RecurringCharge = (output, context) => {
     return {
         RecurringChargeAmount: __limitedParseDouble(output.RecurringChargeAmount),
         RecurringChargeFrequency: __expectString(output.RecurringChargeFrequency),
     };
 };
-const deserializeAws_restJson1RecurringChargeList = (output, context) => {
+const de_RecurringChargeList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1RecurringCharge(entry, context);
+        return de_RecurringCharge(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1ReservedElasticsearchInstance = (output, context) => {
+const de_ReservedElasticsearchInstance = (output, context) => {
     return {
         CurrencyCode: __expectString(output.CurrencyCode),
         Duration: __expectInt32(output.Duration),
@@ -4463,9 +4389,7 @@ const deserializeAws_restJson1ReservedElasticsearchInstance = (output, context)
         ElasticsearchInstanceType: __expectString(output.ElasticsearchInstanceType),
         FixedPrice: __limitedParseDouble(output.FixedPrice),
         PaymentOption: __expectString(output.PaymentOption),
-        RecurringCharges: output.RecurringCharges != null
-            ? deserializeAws_restJson1RecurringChargeList(output.RecurringCharges, context)
-            : undefined,
+        RecurringCharges: output.RecurringCharges != null ? de_RecurringChargeList(output.RecurringCharges, context) : undefined,
         ReservationName: __expectString(output.ReservationName),
         ReservedElasticsearchInstanceId: __expectString(output.ReservedElasticsearchInstanceId),
         ReservedElasticsearchInstanceOfferingId: __expectString(output.ReservedElasticsearchInstanceOfferingId),
@@ -4474,58 +4398,56 @@ const deserializeAws_restJson1ReservedElasticsearchInstance = (output, context)
         UsagePrice: __limitedParseDouble(output.UsagePrice),
     };
 };
-const deserializeAws_restJson1ReservedElasticsearchInstanceList = (output, context) => {
+const de_ReservedElasticsearchInstanceList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1ReservedElasticsearchInstance(entry, context);
+        return de_ReservedElasticsearchInstance(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1ReservedElasticsearchInstanceOffering = (output, context) => {
+const de_ReservedElasticsearchInstanceOffering = (output, context) => {
     return {
         CurrencyCode: __expectString(output.CurrencyCode),
         Duration: __expectInt32(output.Duration),
         ElasticsearchInstanceType: __expectString(output.ElasticsearchInstanceType),
         FixedPrice: __limitedParseDouble(output.FixedPrice),
         PaymentOption: __expectString(output.PaymentOption),
-        RecurringCharges: output.RecurringCharges != null
-            ? deserializeAws_restJson1RecurringChargeList(output.RecurringCharges, context)
-            : undefined,
+        RecurringCharges: output.RecurringCharges != null ? de_RecurringChargeList(output.RecurringCharges, context) : undefined,
         ReservedElasticsearchInstanceOfferingId: __expectString(output.ReservedElasticsearchInstanceOfferingId),
         UsagePrice: __limitedParseDouble(output.UsagePrice),
     };
 };
-const deserializeAws_restJson1ReservedElasticsearchInstanceOfferingList = (output, context) => {
+const de_ReservedElasticsearchInstanceOfferingList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1ReservedElasticsearchInstanceOffering(entry, context);
+        return de_ReservedElasticsearchInstanceOffering(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1SAMLIdp = (output, context) => {
+const de_SAMLIdp = (output, context) => {
     return {
         EntityId: __expectString(output.EntityId),
         MetadataContent: __expectString(output.MetadataContent),
     };
 };
-const deserializeAws_restJson1SAMLOptionsOutput = (output, context) => {
+const de_SAMLOptionsOutput = (output, context) => {
     return {
         Enabled: __expectBoolean(output.Enabled),
-        Idp: output.Idp != null ? deserializeAws_restJson1SAMLIdp(output.Idp, context) : undefined,
+        Idp: output.Idp != null ? de_SAMLIdp(output.Idp, context) : undefined,
         RolesKey: __expectString(output.RolesKey),
         SessionTimeoutMinutes: __expectInt32(output.SessionTimeoutMinutes),
         SubjectKey: __expectString(output.SubjectKey),
     };
 };
-const deserializeAws_restJson1ScheduledAutoTuneDetails = (output, context) => {
+const de_ScheduledAutoTuneDetails = (output, context) => {
     return {
         Action: __expectString(output.Action),
         ActionType: __expectString(output.ActionType),
@@ -4533,7 +4455,7 @@ const deserializeAws_restJson1ScheduledAutoTuneDetails = (output, context) => {
         Severity: __expectString(output.Severity),
     };
 };
-const deserializeAws_restJson1ServiceSoftwareOptions = (output, context) => {
+const de_ServiceSoftwareOptions = (output, context) => {
     return {
         AutomatedUpdateDate: output.AutomatedUpdateDate != null
             ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.AutomatedUpdateDate)))
@@ -4547,55 +4469,53 @@ const deserializeAws_restJson1ServiceSoftwareOptions = (output, context) => {
         UpdateStatus: __expectString(output.UpdateStatus),
     };
 };
-const deserializeAws_restJson1SnapshotOptions = (output, context) => {
+const de_SnapshotOptions = (output, context) => {
     return {
         AutomatedSnapshotStartHour: __expectInt32(output.AutomatedSnapshotStartHour),
     };
 };
-const deserializeAws_restJson1SnapshotOptionsStatus = (output, context) => {
+const de_SnapshotOptionsStatus = (output, context) => {
     return {
-        Options: output.Options != null ? deserializeAws_restJson1SnapshotOptions(output.Options, context) : undefined,
-        Status: output.Status != null ? deserializeAws_restJson1OptionStatus(output.Status, context) : undefined,
+        Options: output.Options != null ? de_SnapshotOptions(output.Options, context) : undefined,
+        Status: output.Status != null ? de_OptionStatus(output.Status, context) : undefined,
     };
 };
-const deserializeAws_restJson1StorageType = (output, context) => {
+const de_StorageType = (output, context) => {
     return {
         StorageSubTypeName: __expectString(output.StorageSubTypeName),
-        StorageTypeLimits: output.StorageTypeLimits != null
-            ? deserializeAws_restJson1StorageTypeLimitList(output.StorageTypeLimits, context)
-            : undefined,
+        StorageTypeLimits: output.StorageTypeLimits != null ? de_StorageTypeLimitList(output.StorageTypeLimits, context) : undefined,
         StorageTypeName: __expectString(output.StorageTypeName),
     };
 };
-const deserializeAws_restJson1StorageTypeLimit = (output, context) => {
+const de_StorageTypeLimit = (output, context) => {
     return {
         LimitName: __expectString(output.LimitName),
-        LimitValues: output.LimitValues != null ? deserializeAws_restJson1LimitValueList(output.LimitValues, context) : undefined,
+        LimitValues: output.LimitValues != null ? de_LimitValueList(output.LimitValues, context) : undefined,
     };
 };
-const deserializeAws_restJson1StorageTypeLimitList = (output, context) => {
+const de_StorageTypeLimitList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1StorageTypeLimit(entry, context);
+        return de_StorageTypeLimit(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1StorageTypeList = (output, context) => {
+const de_StorageTypeList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1StorageType(entry, context);
+        return de_StorageType(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1StringList = (output, context) => {
+const de_StringList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
@@ -4606,121 +4526,117 @@ const deserializeAws_restJson1StringList = (output, context) => {
     });
     return retVal;
 };
-const deserializeAws_restJson1Tag = (output, context) => {
+const de_Tag = (output, context) => {
     return {
         Key: __expectString(output.Key),
         Value: __expectString(output.Value),
     };
 };
-const deserializeAws_restJson1TagList = (output, context) => {
+const de_TagList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1Tag(entry, context);
+        return de_Tag(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1UpgradeHistory = (output, context) => {
+const de_UpgradeHistory = (output, context) => {
     return {
         StartTimestamp: output.StartTimestamp != null
             ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.StartTimestamp)))
             : undefined,
-        StepsList: output.StepsList != null ? deserializeAws_restJson1UpgradeStepsList(output.StepsList, context) : undefined,
+        StepsList: output.StepsList != null ? de_UpgradeStepsList(output.StepsList, context) : undefined,
         UpgradeName: __expectString(output.UpgradeName),
         UpgradeStatus: __expectString(output.UpgradeStatus),
     };
 };
-const deserializeAws_restJson1UpgradeHistoryList = (output, context) => {
+const de_UpgradeHistoryList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1UpgradeHistory(entry, context);
+        return de_UpgradeHistory(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1UpgradeStepItem = (output, context) => {
+const de_UpgradeStepItem = (output, context) => {
     return {
-        Issues: output.Issues != null ? deserializeAws_restJson1Issues(output.Issues, context) : undefined,
+        Issues: output.Issues != null ? de_Issues(output.Issues, context) : undefined,
         ProgressPercent: __limitedParseDouble(output.ProgressPercent),
         UpgradeStep: __expectString(output.UpgradeStep),
         UpgradeStepStatus: __expectString(output.UpgradeStepStatus),
     };
 };
-const deserializeAws_restJson1UpgradeStepsList = (output, context) => {
+const de_UpgradeStepsList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1UpgradeStepItem(entry, context);
+        return de_UpgradeStepItem(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1VPCDerivedInfo = (output, context) => {
+const de_VPCDerivedInfo = (output, context) => {
     return {
-        AvailabilityZones: output.AvailabilityZones != null
-            ? deserializeAws_restJson1StringList(output.AvailabilityZones, context)
-            : undefined,
-        SecurityGroupIds: output.SecurityGroupIds != null
-            ? deserializeAws_restJson1StringList(output.SecurityGroupIds, context)
-            : undefined,
-        SubnetIds: output.SubnetIds != null ? deserializeAws_restJson1StringList(output.SubnetIds, context) : undefined,
+        AvailabilityZones: output.AvailabilityZones != null ? de_StringList(output.AvailabilityZones, context) : undefined,
+        SecurityGroupIds: output.SecurityGroupIds != null ? de_StringList(output.SecurityGroupIds, context) : undefined,
+        SubnetIds: output.SubnetIds != null ? de_StringList(output.SubnetIds, context) : undefined,
         VPCId: __expectString(output.VPCId),
     };
 };
-const deserializeAws_restJson1VPCDerivedInfoStatus = (output, context) => {
+const de_VPCDerivedInfoStatus = (output, context) => {
     return {
-        Options: output.Options != null ? deserializeAws_restJson1VPCDerivedInfo(output.Options, context) : undefined,
-        Status: output.Status != null ? deserializeAws_restJson1OptionStatus(output.Status, context) : undefined,
+        Options: output.Options != null ? de_VPCDerivedInfo(output.Options, context) : undefined,
+        Status: output.Status != null ? de_OptionStatus(output.Status, context) : undefined,
     };
 };
-const deserializeAws_restJson1VpcEndpoint = (output, context) => {
+const de_VpcEndpoint = (output, context) => {
     return {
         DomainArn: __expectString(output.DomainArn),
         Endpoint: __expectString(output.Endpoint),
         Status: __expectString(output.Status),
         VpcEndpointId: __expectString(output.VpcEndpointId),
         VpcEndpointOwner: __expectString(output.VpcEndpointOwner),
-        VpcOptions: output.VpcOptions != null ? deserializeAws_restJson1VPCDerivedInfo(output.VpcOptions, context) : undefined,
+        VpcOptions: output.VpcOptions != null ? de_VPCDerivedInfo(output.VpcOptions, context) : undefined,
     };
 };
-const deserializeAws_restJson1VpcEndpointError = (output, context) => {
+const de_VpcEndpointError = (output, context) => {
     return {
         ErrorCode: __expectString(output.ErrorCode),
         ErrorMessage: __expectString(output.ErrorMessage),
         VpcEndpointId: __expectString(output.VpcEndpointId),
     };
 };
-const deserializeAws_restJson1VpcEndpointErrorList = (output, context) => {
+const de_VpcEndpointErrorList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1VpcEndpointError(entry, context);
+        return de_VpcEndpointError(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1VpcEndpoints = (output, context) => {
+const de_VpcEndpoints = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1VpcEndpoint(entry, context);
+        return de_VpcEndpoint(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1VpcEndpointSummary = (output, context) => {
+const de_VpcEndpointSummary = (output, context) => {
     return {
         DomainArn: __expectString(output.DomainArn),
         Status: __expectString(output.Status),
@@ -4728,18 +4644,18 @@ const deserializeAws_restJson1VpcEndpointSummary = (output, context) => {
         VpcEndpointOwner: __expectString(output.VpcEndpointOwner),
     };
 };
-const deserializeAws_restJson1VpcEndpointSummaryList = (output, context) => {
+const de_VpcEndpointSummaryList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1VpcEndpointSummary(entry, context);
+        return de_VpcEndpointSummary(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1ZoneAwarenessConfig = (output, context) => {
+const de_ZoneAwarenessConfig = (output, context) => {
     return {
         AvailabilityZoneCount: __expectInt32(output.AvailabilityZoneCount),
     };