@aws-sdk/client-elasticsearch-service 3.310.0 → 3.315.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (3) hide show
  1. package/dist-cjs/protocols/Aws_restJson1.js +742 -1621
  2. package/dist-es/protocols/Aws_restJson1.js +666 -1545
  3. package/package.json +6 -6
package/dist-es/protocols/Aws_restJson1.js CHANGED
@@ -1,5 +1,5 @@
1
1
  import { HttpRequest as __HttpRequest } from "@aws-sdk/protocol-http";
2
- 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";
2
+ import { _json, decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectInt32 as __expectInt32, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectObject as __expectObject, expectString as __expectString, limitedParseDouble as __limitedParseDouble, map, parseEpochTimestamp as __parseEpochTimestamp, resolvedPath as __resolvedPath, take, withBaseException, } from "@aws-sdk/smithy-client";
3
3
  import { ElasticsearchServiceServiceException as __BaseException } from "../models/ElasticsearchServiceServiceException";
4
4
  import { AccessDeniedException, BaseException, ConflictException, DisabledOperationException, InternalException, InvalidPaginationTokenException, InvalidTypeException, LimitExceededException, ResourceAlreadyExistsException, ResourceNotFoundException, ValidationException, } from "../models/models_0";
5
5
  export const se_AcceptInboundCrossClusterSearchConnectionCommand = async (input, context) => {
@@ -26,10 +26,10 @@ export const se_AddTagsCommand = async (input, context) => {
26
26
  };
27
27
  const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/2015-01-01/tags";
28
28
  let body;
29
- body = JSON.stringify({
30
- ...(input.ARN != null && { ARN: input.ARN }),
31
- ...(input.TagList != null && { TagList: se_TagList(input.TagList, context) }),
32
- });
29
+ body = JSON.stringify(take(input, {
30
+ ARN: [],
31
+ TagList: (_) => _json(_),
32
+ }));
33
33
  return new __HttpRequest({
34
34
  protocol,
35
35
  hostname,
@@ -67,9 +67,9 @@ export const se_AuthorizeVpcEndpointAccessCommand = async (input, context) => {
67
67
  "/2015-01-01/es/domain/{DomainName}/authorizeVpcEndpointAccess";
68
68
  resolvedPath = __resolvedPath(resolvedPath, input, "DomainName", () => input.DomainName, "{DomainName}", false);
69
69
  let body;
70
- body = JSON.stringify({
71
- ...(input.Account != null && { Account: input.Account }),
72
- });
70
+ body = JSON.stringify(take(input, {
71
+ Account: [],
72
+ }));
73
73
  return new __HttpRequest({
74
74
  protocol,
75
75
  hostname,
@@ -88,9 +88,9 @@ export const se_CancelElasticsearchServiceSoftwareUpdateCommand = async (input,
88
88
  const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
89
89
  "/2015-01-01/es/serviceSoftwareUpdate/cancel";
90
90
  let body;
91
- body = JSON.stringify({
92
- ...(input.DomainName != null && { DomainName: input.DomainName }),
93
- });
91
+ body = JSON.stringify(take(input, {
92
+ DomainName: [],
93
+ }));
94
94
  return new __HttpRequest({
95
95
  protocol,
96
96
  hostname,
@@ -108,36 +108,24 @@ export const se_CreateElasticsearchDomainCommand = async (input, context) => {
108
108
  };
109
109
  const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/2015-01-01/es/domain";
110
110
  let body;
111
- body = JSON.stringify({
112
- ...(input.AccessPolicies != null && { AccessPolicies: input.AccessPolicies }),
113
- ...(input.AdvancedOptions != null && { AdvancedOptions: se_AdvancedOptions(input.AdvancedOptions, context) }),
114
- ...(input.AdvancedSecurityOptions != null && {
115
- AdvancedSecurityOptions: se_AdvancedSecurityOptionsInput(input.AdvancedSecurityOptions, context),
116
- }),
117
- ...(input.AutoTuneOptions != null && { AutoTuneOptions: se_AutoTuneOptionsInput(input.AutoTuneOptions, context) }),
118
- ...(input.CognitoOptions != null && { CognitoOptions: se_CognitoOptions(input.CognitoOptions, context) }),
119
- ...(input.DomainEndpointOptions != null && {
120
- DomainEndpointOptions: se_DomainEndpointOptions(input.DomainEndpointOptions, context),
121
- }),
122
- ...(input.DomainName != null && { DomainName: input.DomainName }),
123
- ...(input.EBSOptions != null && { EBSOptions: se_EBSOptions(input.EBSOptions, context) }),
124
- ...(input.ElasticsearchClusterConfig != null && {
125
- ElasticsearchClusterConfig: se_ElasticsearchClusterConfig(input.ElasticsearchClusterConfig, context),
126
- }),
127
- ...(input.ElasticsearchVersion != null && { ElasticsearchVersion: input.ElasticsearchVersion }),
128
- ...(input.EncryptionAtRestOptions != null && {
129
- EncryptionAtRestOptions: se_EncryptionAtRestOptions(input.EncryptionAtRestOptions, context),
130
- }),
131
- ...(input.LogPublishingOptions != null && {
132
- LogPublishingOptions: se_LogPublishingOptions(input.LogPublishingOptions, context),
133
- }),
134
- ...(input.NodeToNodeEncryptionOptions != null && {
135
- NodeToNodeEncryptionOptions: se_NodeToNodeEncryptionOptions(input.NodeToNodeEncryptionOptions, context),
136
- }),
137
- ...(input.SnapshotOptions != null && { SnapshotOptions: se_SnapshotOptions(input.SnapshotOptions, context) }),
138
- ...(input.TagList != null && { TagList: se_TagList(input.TagList, context) }),
139
- ...(input.VPCOptions != null && { VPCOptions: se_VPCOptions(input.VPCOptions, context) }),
140
- });
111
+ body = JSON.stringify(take(input, {
112
+ AccessPolicies: [],
113
+ AdvancedOptions: (_) => _json(_),
114
+ AdvancedSecurityOptions: (_) => _json(_),
115
+ AutoTuneOptions: (_) => se_AutoTuneOptionsInput(_, context),
116
+ CognitoOptions: (_) => _json(_),
117
+ DomainEndpointOptions: (_) => _json(_),
118
+ DomainName: [],
119
+ EBSOptions: (_) => _json(_),
120
+ ElasticsearchClusterConfig: (_) => _json(_),
121
+ ElasticsearchVersion: [],
122
+ EncryptionAtRestOptions: (_) => _json(_),
123
+ LogPublishingOptions: (_) => _json(_),
124
+ NodeToNodeEncryptionOptions: (_) => _json(_),
125
+ SnapshotOptions: (_) => _json(_),
126
+ TagList: (_) => _json(_),
127
+ VPCOptions: (_) => _json(_),
128
+ }));
141
129
  return new __HttpRequest({
142
130
  protocol,
143
131
  hostname,
@@ -155,13 +143,11 @@ export const se_CreateOutboundCrossClusterSearchConnectionCommand = async (input
155
143
  };
156
144
  const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/2015-01-01/es/ccs/outboundConnection";
157
145
  let body;
158
- body = JSON.stringify({
159
- ...(input.ConnectionAlias != null && { ConnectionAlias: input.ConnectionAlias }),
160
- ...(input.DestinationDomainInfo != null && {
161
- DestinationDomainInfo: se_DomainInformation(input.DestinationDomainInfo, context),
162
- }),
163
- ...(input.SourceDomainInfo != null && { SourceDomainInfo: se_DomainInformation(input.SourceDomainInfo, context) }),
164
- });
146
+ body = JSON.stringify(take(input, {
147
+ ConnectionAlias: [],
148
+ DestinationDomainInfo: (_) => _json(_),
149
+ SourceDomainInfo: (_) => _json(_),
150
+ }));
165
151
  return new __HttpRequest({
166
152
  protocol,
167
153
  hostname,
@@ -179,12 +165,12 @@ export const se_CreatePackageCommand = async (input, context) => {
179
165
  };
180
166
  const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/2015-01-01/packages";
181
167
  let body;
182
- body = JSON.stringify({
183
- ...(input.PackageDescription != null && { PackageDescription: input.PackageDescription }),
184
- ...(input.PackageName != null && { PackageName: input.PackageName }),
185
- ...(input.PackageSource != null && { PackageSource: se_PackageSource(input.PackageSource, context) }),
186
- ...(input.PackageType != null && { PackageType: input.PackageType }),
187
- });
168
+ body = JSON.stringify(take(input, {
169
+ PackageDescription: [],
170
+ PackageName: [],
171
+ PackageSource: (_) => _json(_),
172
+ PackageType: [],
173
+ }));
188
174
  return new __HttpRequest({
189
175
  protocol,
190
176
  hostname,
@@ -202,11 +188,11 @@ export const se_CreateVpcEndpointCommand = async (input, context) => {
202
188
  };
203
189
  const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/2015-01-01/es/vpcEndpoints";
204
190
  let body;
205
- body = JSON.stringify({
206
- ...(input.ClientToken != null && { ClientToken: input.ClientToken }),
207
- ...(input.DomainArn != null && { DomainArn: input.DomainArn }),
208
- ...(input.VpcOptions != null && { VpcOptions: se_VPCOptions(input.VpcOptions, context) }),
209
- });
191
+ body = JSON.stringify(take(input, {
192
+ ClientToken: [],
193
+ DomainArn: [],
194
+ VpcOptions: (_) => _json(_),
195
+ }));
210
196
  return new __HttpRequest({
211
197
  protocol,
212
198
  hostname,
@@ -327,10 +313,10 @@ export const se_DescribeDomainAutoTunesCommand = async (input, context) => {
327
313
  "/2015-01-01/es/domain/{DomainName}/autoTunes";
328
314
  resolvedPath = __resolvedPath(resolvedPath, input, "DomainName", () => input.DomainName, "{DomainName}", false);
329
315
  let body;
330
- body = JSON.stringify({
331
- ...(input.MaxResults != null && { MaxResults: input.MaxResults }),
332
- ...(input.NextToken != null && { NextToken: input.NextToken }),
333
- });
316
+ body = JSON.stringify(take(input, {
317
+ MaxResults: [],
318
+ NextToken: [],
319
+ }));
334
320
  return new __HttpRequest({
335
321
  protocol,
336
322
  hostname,
@@ -401,9 +387,9 @@ export const se_DescribeElasticsearchDomainsCommand = async (input, context) =>
401
387
  };
402
388
  const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/2015-01-01/es/domain-info";
403
389
  let body;
404
- body = JSON.stringify({
405
- ...(input.DomainNames != null && { DomainNames: se_DomainNameList(input.DomainNames, context) }),
406
- });
390
+ body = JSON.stringify(take(input, {
391
+ DomainNames: (_) => _json(_),
392
+ }));
407
393
  return new __HttpRequest({
408
394
  protocol,
409
395
  hostname,
@@ -444,11 +430,11 @@ export const se_DescribeInboundCrossClusterSearchConnectionsCommand = async (inp
444
430
  const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
445
431
  "/2015-01-01/es/ccs/inboundConnection/search";
446
432
  let body;
447
- body = JSON.stringify({
448
- ...(input.Filters != null && { Filters: se_FilterList(input.Filters, context) }),
449
- ...(input.MaxResults != null && { MaxResults: input.MaxResults }),
450
- ...(input.NextToken != null && { NextToken: input.NextToken }),
451
- });
433
+ body = JSON.stringify(take(input, {
434
+ Filters: (_) => _json(_),
435
+ MaxResults: [],
436
+ NextToken: [],
437
+ }));
452
438
  return new __HttpRequest({
453
439
  protocol,
454
440
  hostname,
@@ -467,11 +453,11 @@ export const se_DescribeOutboundCrossClusterSearchConnectionsCommand = async (in
467
453
  const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
468
454
  "/2015-01-01/es/ccs/outboundConnection/search";
469
455
  let body;
470
- body = JSON.stringify({
471
- ...(input.Filters != null && { Filters: se_FilterList(input.Filters, context) }),
472
- ...(input.MaxResults != null && { MaxResults: input.MaxResults }),
473
- ...(input.NextToken != null && { NextToken: input.NextToken }),
474
- });
456
+ body = JSON.stringify(take(input, {
457
+ Filters: (_) => _json(_),
458
+ MaxResults: [],
459
+ NextToken: [],
460
+ }));
475
461
  return new __HttpRequest({
476
462
  protocol,
477
463
  hostname,
@@ -489,11 +475,11 @@ export const se_DescribePackagesCommand = async (input, context) => {
489
475
  };
490
476
  const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/2015-01-01/packages/describe";
491
477
  let body;
492
- body = JSON.stringify({
493
- ...(input.Filters != null && { Filters: se_DescribePackagesFilterList(input.Filters, context) }),
494
- ...(input.MaxResults != null && { MaxResults: input.MaxResults }),
495
- ...(input.NextToken != null && { NextToken: input.NextToken }),
496
- });
478
+ body = JSON.stringify(take(input, {
479
+ Filters: (_) => _json(_),
480
+ MaxResults: [],
481
+ NextToken: [],
482
+ }));
497
483
  return new __HttpRequest({
498
484
  protocol,
499
485
  hostname,
@@ -553,9 +539,9 @@ export const se_DescribeVpcEndpointsCommand = async (input, context) => {
553
539
  };
554
540
  const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/2015-01-01/es/vpcEndpoints/describe";
555
541
  let body;
556
- body = JSON.stringify({
557
- ...(input.VpcEndpointIds != null && { VpcEndpointIds: se_VpcEndpointIdList(input.VpcEndpointIds, context) }),
558
- });
542
+ body = JSON.stringify(take(input, {
543
+ VpcEndpointIds: (_) => _json(_),
544
+ }));
559
545
  return new __HttpRequest({
560
546
  protocol,
561
547
  hostname,
@@ -855,13 +841,11 @@ export const se_PurchaseReservedElasticsearchInstanceOfferingCommand = async (in
855
841
  const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
856
842
  "/2015-01-01/es/purchaseReservedInstanceOffering";
857
843
  let body;
858
- body = JSON.stringify({
859
- ...(input.InstanceCount != null && { InstanceCount: input.InstanceCount }),
860
- ...(input.ReservationName != null && { ReservationName: input.ReservationName }),
861
- ...(input.ReservedElasticsearchInstanceOfferingId != null && {
862
- ReservedElasticsearchInstanceOfferingId: input.ReservedElasticsearchInstanceOfferingId,
863
- }),
864
- });
844
+ body = JSON.stringify(take(input, {
845
+ InstanceCount: [],
846
+ ReservationName: [],
847
+ ReservedElasticsearchInstanceOfferingId: [],
848
+ }));
865
849
  return new __HttpRequest({
866
850
  protocol,
867
851
  hostname,
@@ -896,10 +880,10 @@ export const se_RemoveTagsCommand = async (input, context) => {
896
880
  };
897
881
  const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/2015-01-01/tags-removal";
898
882
  let body;
899
- body = JSON.stringify({
900
- ...(input.ARN != null && { ARN: input.ARN }),
901
- ...(input.TagKeys != null && { TagKeys: se_StringList(input.TagKeys, context) }),
902
- });
883
+ body = JSON.stringify(take(input, {
884
+ ARN: [],
885
+ TagKeys: (_) => _json(_),
886
+ }));
903
887
  return new __HttpRequest({
904
888
  protocol,
905
889
  hostname,
@@ -919,9 +903,9 @@ export const se_RevokeVpcEndpointAccessCommand = async (input, context) => {
919
903
  "/2015-01-01/es/domain/{DomainName}/revokeVpcEndpointAccess";
920
904
  resolvedPath = __resolvedPath(resolvedPath, input, "DomainName", () => input.DomainName, "{DomainName}", false);
921
905
  let body;
922
- body = JSON.stringify({
923
- ...(input.Account != null && { Account: input.Account }),
924
- });
906
+ body = JSON.stringify(take(input, {
907
+ Account: [],
908
+ }));
925
909
  return new __HttpRequest({
926
910
  protocol,
927
911
  hostname,
@@ -940,9 +924,9 @@ export const se_StartElasticsearchServiceSoftwareUpdateCommand = async (input, c
940
924
  const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
941
925
  "/2015-01-01/es/serviceSoftwareUpdate/start";
942
926
  let body;
943
- body = JSON.stringify({
944
- ...(input.DomainName != null && { DomainName: input.DomainName }),
945
- });
927
+ body = JSON.stringify(take(input, {
928
+ DomainName: [],
929
+ }));
946
930
  return new __HttpRequest({
947
931
  protocol,
948
932
  hostname,
@@ -961,34 +945,22 @@ export const se_UpdateElasticsearchDomainConfigCommand = async (input, context)
961
945
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/2015-01-01/es/domain/{DomainName}/config";
962
946
  resolvedPath = __resolvedPath(resolvedPath, input, "DomainName", () => input.DomainName, "{DomainName}", false);
963
947
  let body;
964
- body = JSON.stringify({
965
- ...(input.AccessPolicies != null && { AccessPolicies: input.AccessPolicies }),
966
- ...(input.AdvancedOptions != null && { AdvancedOptions: se_AdvancedOptions(input.AdvancedOptions, context) }),
967
- ...(input.AdvancedSecurityOptions != null && {
968
- AdvancedSecurityOptions: se_AdvancedSecurityOptionsInput(input.AdvancedSecurityOptions, context),
969
- }),
970
- ...(input.AutoTuneOptions != null && { AutoTuneOptions: se_AutoTuneOptions(input.AutoTuneOptions, context) }),
971
- ...(input.CognitoOptions != null && { CognitoOptions: se_CognitoOptions(input.CognitoOptions, context) }),
972
- ...(input.DomainEndpointOptions != null && {
973
- DomainEndpointOptions: se_DomainEndpointOptions(input.DomainEndpointOptions, context),
974
- }),
975
- ...(input.DryRun != null && { DryRun: input.DryRun }),
976
- ...(input.EBSOptions != null && { EBSOptions: se_EBSOptions(input.EBSOptions, context) }),
977
- ...(input.ElasticsearchClusterConfig != null && {
978
- ElasticsearchClusterConfig: se_ElasticsearchClusterConfig(input.ElasticsearchClusterConfig, context),
979
- }),
980
- ...(input.EncryptionAtRestOptions != null && {
981
- EncryptionAtRestOptions: se_EncryptionAtRestOptions(input.EncryptionAtRestOptions, context),
982
- }),
983
- ...(input.LogPublishingOptions != null && {
984
- LogPublishingOptions: se_LogPublishingOptions(input.LogPublishingOptions, context),
985
- }),
986
- ...(input.NodeToNodeEncryptionOptions != null && {
987
- NodeToNodeEncryptionOptions: se_NodeToNodeEncryptionOptions(input.NodeToNodeEncryptionOptions, context),
988
- }),
989
- ...(input.SnapshotOptions != null && { SnapshotOptions: se_SnapshotOptions(input.SnapshotOptions, context) }),
990
- ...(input.VPCOptions != null && { VPCOptions: se_VPCOptions(input.VPCOptions, context) }),
991
- });
948
+ body = JSON.stringify(take(input, {
949
+ AccessPolicies: [],
950
+ AdvancedOptions: (_) => _json(_),
951
+ AdvancedSecurityOptions: (_) => _json(_),
952
+ AutoTuneOptions: (_) => se_AutoTuneOptions(_, context),
953
+ CognitoOptions: (_) => _json(_),
954
+ DomainEndpointOptions: (_) => _json(_),
955
+ DryRun: [],
956
+ EBSOptions: (_) => _json(_),
957
+ ElasticsearchClusterConfig: (_) => _json(_),
958
+ EncryptionAtRestOptions: (_) => _json(_),
959
+ LogPublishingOptions: (_) => _json(_),
960
+ NodeToNodeEncryptionOptions: (_) => _json(_),
961
+ SnapshotOptions: (_) => _json(_),
962
+ VPCOptions: (_) => _json(_),
963
+ }));
992
964
  return new __HttpRequest({
993
965
  protocol,
994
966
  hostname,
@@ -1006,12 +978,12 @@ export const se_UpdatePackageCommand = async (input, context) => {
1006
978
  };
1007
979
  const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/2015-01-01/packages/update";
1008
980
  let body;
1009
- body = JSON.stringify({
1010
- ...(input.CommitMessage != null && { CommitMessage: input.CommitMessage }),
1011
- ...(input.PackageDescription != null && { PackageDescription: input.PackageDescription }),
1012
- ...(input.PackageID != null && { PackageID: input.PackageID }),
1013
- ...(input.PackageSource != null && { PackageSource: se_PackageSource(input.PackageSource, context) }),
1014
- });
981
+ body = JSON.stringify(take(input, {
982
+ CommitMessage: [],
983
+ PackageDescription: [],
984
+ PackageID: [],
985
+ PackageSource: (_) => _json(_),
986
+ }));
1015
987
  return new __HttpRequest({
1016
988
  protocol,
1017
989
  hostname,
@@ -1029,10 +1001,10 @@ export const se_UpdateVpcEndpointCommand = async (input, context) => {
1029
1001
  };
1030
1002
  const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/2015-01-01/es/vpcEndpoints/update";
1031
1003
  let body;
1032
- body = JSON.stringify({
1033
- ...(input.VpcEndpointId != null && { VpcEndpointId: input.VpcEndpointId }),
1034
- ...(input.VpcOptions != null && { VpcOptions: se_VPCOptions(input.VpcOptions, context) }),
1035
- });
1004
+ body = JSON.stringify(take(input, {
1005
+ VpcEndpointId: [],
1006
+ VpcOptions: (_) => _json(_),
1007
+ }));
1036
1008
  return new __HttpRequest({
1037
1009
  protocol,
1038
1010
  hostname,
@@ -1050,11 +1022,11 @@ export const se_UpgradeElasticsearchDomainCommand = async (input, context) => {
1050
1022
  };
1051
1023
  const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/2015-01-01/es/upgradeDomain";
1052
1024
  let body;
1053
- body = JSON.stringify({
1054
- ...(input.DomainName != null && { DomainName: input.DomainName }),
1055
- ...(input.PerformCheckOnly != null && { PerformCheckOnly: input.PerformCheckOnly }),
1056
- ...(input.TargetVersion != null && { TargetVersion: input.TargetVersion }),
1057
- });
1025
+ body = JSON.stringify(take(input, {
1026
+ DomainName: [],
1027
+ PerformCheckOnly: [],
1028
+ TargetVersion: [],
1029
+ }));
1058
1030
  return new __HttpRequest({
1059
1031
  protocol,
1060
1032
  hostname,
@@ -1073,9 +1045,10 @@ export const de_AcceptInboundCrossClusterSearchConnectionCommand = async (output
1073
1045
  $metadata: deserializeMetadata(output),
1074
1046
  });
1075
1047
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1076
- if (data.CrossClusterSearchConnection != null) {
1077
- contents.CrossClusterSearchConnection = de_InboundCrossClusterSearchConnection(data.CrossClusterSearchConnection, context);
1078
- }
1048
+ const doc = take(data, {
1049
+ CrossClusterSearchConnection: _json,
1050
+ });
1051
+ Object.assign(contents, doc);
1079
1052
  return contents;
1080
1053
  };
1081
1054
  const de_AcceptInboundCrossClusterSearchConnectionCommandError = async (output, context) => {
@@ -1096,10 +1069,9 @@ const de_AcceptInboundCrossClusterSearchConnectionCommandError = async (output,
1096
1069
  throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1097
1070
  default:
1098
1071
  const parsedBody = parsedOutput.body;
1099
- throwDefaultError({
1072
+ return throwDefaultError({
1100
1073
  output,
1101
1074
  parsedBody,
1102
- exceptionCtor: __BaseException,
1103
1075
  errorCode,
1104
1076
  });
1105
1077
  }
@@ -1135,10 +1107,9 @@ const de_AddTagsCommandError = async (output, context) => {
1135
1107
  throw await de_ValidationExceptionRes(parsedOutput, context);
1136
1108
  default:
1137
1109
  const parsedBody = parsedOutput.body;
1138
- throwDefaultError({
1110
+ return throwDefaultError({
1139
1111
  output,
1140
1112
  parsedBody,
1141
- exceptionCtor: __BaseException,
1142
1113
  errorCode,
1143
1114
  });
1144
1115
  }
@@ -1151,9 +1122,10 @@ export const de_AssociatePackageCommand = async (output, context) => {
1151
1122
  $metadata: deserializeMetadata(output),
1152
1123
  });
1153
1124
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1154
- if (data.DomainPackageDetails != null) {
1155
- contents.DomainPackageDetails = de_DomainPackageDetails(data.DomainPackageDetails, context);
1156
- }
1125
+ const doc = take(data, {
1126
+ DomainPackageDetails: (_) => de_DomainPackageDetails(_, context),
1127
+ });
1128
+ Object.assign(contents, doc);
1157
1129
  return contents;
1158
1130
  };
1159
1131
  const de_AssociatePackageCommandError = async (output, context) => {
@@ -1183,10 +1155,9 @@ const de_AssociatePackageCommandError = async (output, context) => {
1183
1155
  throw await de_ValidationExceptionRes(parsedOutput, context);
1184
1156
  default:
1185
1157
  const parsedBody = parsedOutput.body;
1186
- throwDefaultError({
1158
+ return throwDefaultError({
1187
1159
  output,
1188
1160
  parsedBody,
1189
- exceptionCtor: __BaseException,
1190
1161
  errorCode,
1191
1162
  });
1192
1163
  }
@@ -1199,9 +1170,10 @@ export const de_AuthorizeVpcEndpointAccessCommand = async (output, context) => {
1199
1170
  $metadata: deserializeMetadata(output),
1200
1171
  });
1201
1172
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1202
- if (data.AuthorizedPrincipal != null) {
1203
- contents.AuthorizedPrincipal = de_AuthorizedPrincipal(data.AuthorizedPrincipal, context);
1204
- }
1173
+ const doc = take(data, {
1174
+ AuthorizedPrincipal: _json,
1175
+ });
1176
+ Object.assign(contents, doc);
1205
1177
  return contents;
1206
1178
  };
1207
1179
  const de_AuthorizeVpcEndpointAccessCommandError = async (output, context) => {
@@ -1231,10 +1203,9 @@ const de_AuthorizeVpcEndpointAccessCommandError = async (output, context) => {
1231
1203
  throw await de_ValidationExceptionRes(parsedOutput, context);
1232
1204
  default:
1233
1205
  const parsedBody = parsedOutput.body;
1234
- throwDefaultError({
1206
+ return throwDefaultError({
1235
1207
  output,
1236
1208
  parsedBody,
1237
- exceptionCtor: __BaseException,
1238
1209
  errorCode,
1239
1210
  });
1240
1211
  }
@@ -1247,9 +1218,10 @@ export const de_CancelElasticsearchServiceSoftwareUpdateCommand = async (output,
1247
1218
  $metadata: deserializeMetadata(output),
1248
1219
  });
1249
1220
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1250
- if (data.ServiceSoftwareOptions != null) {
1251
- contents.ServiceSoftwareOptions = de_ServiceSoftwareOptions(data.ServiceSoftwareOptions, context);
1252
- }
1221
+ const doc = take(data, {
1222
+ ServiceSoftwareOptions: (_) => de_ServiceSoftwareOptions(_, context),
1223
+ });
1224
+ Object.assign(contents, doc);
1253
1225
  return contents;
1254
1226
  };
1255
1227
  const de_CancelElasticsearchServiceSoftwareUpdateCommandError = async (output, context) => {
@@ -1273,10 +1245,9 @@ const de_CancelElasticsearchServiceSoftwareUpdateCommandError = async (output, c
1273
1245
  throw await de_ValidationExceptionRes(parsedOutput, context);
1274
1246
  default:
1275
1247
  const parsedBody = parsedOutput.body;
1276
- throwDefaultError({
1248
+ return throwDefaultError({
1277
1249
  output,
1278
1250
  parsedBody,
1279
- exceptionCtor: __BaseException,
1280
1251
  errorCode,
1281
1252
  });
1282
1253
  }
@@ -1289,9 +1260,10 @@ export const de_CreateElasticsearchDomainCommand = async (output, context) => {
1289
1260
  $metadata: deserializeMetadata(output),
1290
1261
  });
1291
1262
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1292
- if (data.DomainStatus != null) {
1293
- contents.DomainStatus = de_ElasticsearchDomainStatus(data.DomainStatus, context);
1294
- }
1263
+ const doc = take(data, {
1264
+ DomainStatus: (_) => de_ElasticsearchDomainStatus(_, context),
1265
+ });
1266
+ Object.assign(contents, doc);
1295
1267
  return contents;
1296
1268
  };
1297
1269
  const de_CreateElasticsearchDomainCommandError = async (output, context) => {
@@ -1324,10 +1296,9 @@ const de_CreateElasticsearchDomainCommandError = async (output, context) => {
1324
1296
  throw await de_ValidationExceptionRes(parsedOutput, context);
1325
1297
  default:
1326
1298
  const parsedBody = parsedOutput.body;
1327
- throwDefaultError({
1299
+ return throwDefaultError({
1328
1300
  output,
1329
1301
  parsedBody,
1330
- exceptionCtor: __BaseException,
1331
1302
  errorCode,
1332
1303
  });
1333
1304
  }
@@ -1340,21 +1311,14 @@ export const de_CreateOutboundCrossClusterSearchConnectionCommand = async (outpu
1340
1311
  $metadata: deserializeMetadata(output),
1341
1312
  });
1342
1313
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1343
- if (data.ConnectionAlias != null) {
1344
- contents.ConnectionAlias = __expectString(data.ConnectionAlias);
1345
- }
1346
- if (data.ConnectionStatus != null) {
1347
- contents.ConnectionStatus = de_OutboundCrossClusterSearchConnectionStatus(data.ConnectionStatus, context);
1348
- }
1349
- if (data.CrossClusterSearchConnectionId != null) {
1350
- contents.CrossClusterSearchConnectionId = __expectString(data.CrossClusterSearchConnectionId);
1351
- }
1352
- if (data.DestinationDomainInfo != null) {
1353
- contents.DestinationDomainInfo = de_DomainInformation(data.DestinationDomainInfo, context);
1354
- }
1355
- if (data.SourceDomainInfo != null) {
1356
- contents.SourceDomainInfo = de_DomainInformation(data.SourceDomainInfo, context);
1357
- }
1314
+ const doc = take(data, {
1315
+ ConnectionAlias: __expectString,
1316
+ ConnectionStatus: _json,
1317
+ CrossClusterSearchConnectionId: __expectString,
1318
+ DestinationDomainInfo: _json,
1319
+ SourceDomainInfo: _json,
1320
+ });
1321
+ Object.assign(contents, doc);
1358
1322
  return contents;
1359
1323
  };
1360
1324
  const de_CreateOutboundCrossClusterSearchConnectionCommandError = async (output, context) => {
@@ -1378,10 +1342,9 @@ const de_CreateOutboundCrossClusterSearchConnectionCommandError = async (output,
1378
1342
  throw await de_ResourceAlreadyExistsExceptionRes(parsedOutput, context);
1379
1343
  default:
1380
1344
  const parsedBody = parsedOutput.body;
1381
- throwDefaultError({
1345
+ return throwDefaultError({
1382
1346
  output,
1383
1347
  parsedBody,
1384
- exceptionCtor: __BaseException,
1385
1348
  errorCode,
1386
1349
  });
1387
1350
  }
@@ -1394,9 +1357,10 @@ export const de_CreatePackageCommand = async (output, context) => {
1394
1357
  $metadata: deserializeMetadata(output),
1395
1358
  });
1396
1359
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1397
- if (data.PackageDetails != null) {
1398
- contents.PackageDetails = de_PackageDetails(data.PackageDetails, context);
1399
- }
1360
+ const doc = take(data, {
1361
+ PackageDetails: (_) => de_PackageDetails(_, context),
1362
+ });
1363
+ Object.assign(contents, doc);
1400
1364
  return contents;
1401
1365
  };
1402
1366
  const de_CreatePackageCommandError = async (output, context) => {
@@ -1429,10 +1393,9 @@ const de_CreatePackageCommandError = async (output, context) => {
1429
1393
  throw await de_ValidationExceptionRes(parsedOutput, context);
1430
1394
  default:
1431
1395
  const parsedBody = parsedOutput.body;
1432
- throwDefaultError({
1396
+ return throwDefaultError({
1433
1397
  output,
1434
1398
  parsedBody,
1435
- exceptionCtor: __BaseException,
1436
1399
  errorCode,
1437
1400
  });
1438
1401
  }
@@ -1445,9 +1408,10 @@ export const de_CreateVpcEndpointCommand = async (output, context) => {
1445
1408
  $metadata: deserializeMetadata(output),
1446
1409
  });
1447
1410
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1448
- if (data.VpcEndpoint != null) {
1449
- contents.VpcEndpoint = de_VpcEndpoint(data.VpcEndpoint, context);
1450
- }
1411
+ const doc = take(data, {
1412
+ VpcEndpoint: _json,
1413
+ });
1414
+ Object.assign(contents, doc);
1451
1415
  return contents;
1452
1416
  };
1453
1417
  const de_CreateVpcEndpointCommandError = async (output, context) => {
@@ -1477,10 +1441,9 @@ const de_CreateVpcEndpointCommandError = async (output, context) => {
1477
1441
  throw await de_ValidationExceptionRes(parsedOutput, context);
1478
1442
  default:
1479
1443
  const parsedBody = parsedOutput.body;
1480
- throwDefaultError({
1444
+ return throwDefaultError({
1481
1445
  output,
1482
1446
  parsedBody,
1483
- exceptionCtor: __BaseException,
1484
1447
  errorCode,
1485
1448
  });
1486
1449
  }
@@ -1493,9 +1456,10 @@ export const de_DeleteElasticsearchDomainCommand = async (output, context) => {
1493
1456
  $metadata: deserializeMetadata(output),
1494
1457
  });
1495
1458
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1496
- if (data.DomainStatus != null) {
1497
- contents.DomainStatus = de_ElasticsearchDomainStatus(data.DomainStatus, context);
1498
- }
1459
+ const doc = take(data, {
1460
+ DomainStatus: (_) => de_ElasticsearchDomainStatus(_, context),
1461
+ });
1462
+ Object.assign(contents, doc);
1499
1463
  return contents;
1500
1464
  };
1501
1465
  const de_DeleteElasticsearchDomainCommandError = async (output, context) => {
@@ -1519,10 +1483,9 @@ const de_DeleteElasticsearchDomainCommandError = async (output, context) => {
1519
1483
  throw await de_ValidationExceptionRes(parsedOutput, context);
1520
1484
  default:
1521
1485
  const parsedBody = parsedOutput.body;
1522
- throwDefaultError({
1486
+ return throwDefaultError({
1523
1487
  output,
1524
1488
  parsedBody,
1525
- exceptionCtor: __BaseException,
1526
1489
  errorCode,
1527
1490
  });
1528
1491
  }
@@ -1555,10 +1518,9 @@ const de_DeleteElasticsearchServiceRoleCommandError = async (output, context) =>
1555
1518
  throw await de_ValidationExceptionRes(parsedOutput, context);
1556
1519
  default:
1557
1520
  const parsedBody = parsedOutput.body;
1558
- throwDefaultError({
1521
+ return throwDefaultError({
1559
1522
  output,
1560
1523
  parsedBody,
1561
- exceptionCtor: __BaseException,
1562
1524
  errorCode,
1563
1525
  });
1564
1526
  }
@@ -1571,9 +1533,10 @@ export const de_DeleteInboundCrossClusterSearchConnectionCommand = async (output
1571
1533
  $metadata: deserializeMetadata(output),
1572
1534
  });
1573
1535
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1574
- if (data.CrossClusterSearchConnection != null) {
1575
- contents.CrossClusterSearchConnection = de_InboundCrossClusterSearchConnection(data.CrossClusterSearchConnection, context);
1576
- }
1536
+ const doc = take(data, {
1537
+ CrossClusterSearchConnection: _json,
1538
+ });
1539
+ Object.assign(contents, doc);
1577
1540
  return contents;
1578
1541
  };
1579
1542
  const de_DeleteInboundCrossClusterSearchConnectionCommandError = async (output, context) => {
@@ -1591,10 +1554,9 @@ const de_DeleteInboundCrossClusterSearchConnectionCommandError = async (output,
1591
1554
  throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1592
1555
  default:
1593
1556
  const parsedBody = parsedOutput.body;
1594
- throwDefaultError({
1557
+ return throwDefaultError({
1595
1558
  output,
1596
1559
  parsedBody,
1597
- exceptionCtor: __BaseException,
1598
1560
  errorCode,
1599
1561
  });
1600
1562
  }
@@ -1607,9 +1569,10 @@ export const de_DeleteOutboundCrossClusterSearchConnectionCommand = async (outpu
1607
1569
  $metadata: deserializeMetadata(output),
1608
1570
  });
1609
1571
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1610
- if (data.CrossClusterSearchConnection != null) {
1611
- contents.CrossClusterSearchConnection = de_OutboundCrossClusterSearchConnection(data.CrossClusterSearchConnection, context);
1612
- }
1572
+ const doc = take(data, {
1573
+ CrossClusterSearchConnection: _json,
1574
+ });
1575
+ Object.assign(contents, doc);
1613
1576
  return contents;
1614
1577
  };
1615
1578
  const de_DeleteOutboundCrossClusterSearchConnectionCommandError = async (output, context) => {
@@ -1627,10 +1590,9 @@ const de_DeleteOutboundCrossClusterSearchConnectionCommandError = async (output,
1627
1590
  throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1628
1591
  default:
1629
1592
  const parsedBody = parsedOutput.body;
1630
- throwDefaultError({
1593
+ return throwDefaultError({
1631
1594
  output,
1632
1595
  parsedBody,
1633
- exceptionCtor: __BaseException,
1634
1596
  errorCode,
1635
1597
  });
1636
1598
  }
@@ -1643,9 +1605,10 @@ export const de_DeletePackageCommand = async (output, context) => {
1643
1605
  $metadata: deserializeMetadata(output),
1644
1606
  });
1645
1607
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1646
- if (data.PackageDetails != null) {
1647
- contents.PackageDetails = de_PackageDetails(data.PackageDetails, context);
1648
- }
1608
+ const doc = take(data, {
1609
+ PackageDetails: (_) => de_PackageDetails(_, context),
1610
+ });
1611
+ Object.assign(contents, doc);
1649
1612
  return contents;
1650
1613
  };
1651
1614
  const de_DeletePackageCommandError = async (output, context) => {
@@ -1675,10 +1638,9 @@ const de_DeletePackageCommandError = async (output, context) => {
1675
1638
  throw await de_ValidationExceptionRes(parsedOutput, context);
1676
1639
  default:
1677
1640
  const parsedBody = parsedOutput.body;
1678
- throwDefaultError({
1641
+ return throwDefaultError({
1679
1642
  output,
1680
1643
  parsedBody,
1681
- exceptionCtor: __BaseException,
1682
1644
  errorCode,
1683
1645
  });
1684
1646
  }
@@ -1691,9 +1653,10 @@ export const de_DeleteVpcEndpointCommand = async (output, context) => {
1691
1653
  $metadata: deserializeMetadata(output),
1692
1654
  });
1693
1655
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1694
- if (data.VpcEndpointSummary != null) {
1695
- contents.VpcEndpointSummary = de_VpcEndpointSummary(data.VpcEndpointSummary, context);
1696
- }
1656
+ const doc = take(data, {
1657
+ VpcEndpointSummary: _json,
1658
+ });
1659
+ Object.assign(contents, doc);
1697
1660
  return contents;
1698
1661
  };
1699
1662
  const de_DeleteVpcEndpointCommandError = async (output, context) => {
@@ -1717,10 +1680,9 @@ const de_DeleteVpcEndpointCommandError = async (output, context) => {
1717
1680
  throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1718
1681
  default:
1719
1682
  const parsedBody = parsedOutput.body;
1720
- throwDefaultError({
1683
+ return throwDefaultError({
1721
1684
  output,
1722
1685
  parsedBody,
1723
- exceptionCtor: __BaseException,
1724
1686
  errorCode,
1725
1687
  });
1726
1688
  }
@@ -1733,12 +1695,11 @@ export const de_DescribeDomainAutoTunesCommand = async (output, context) => {
1733
1695
  $metadata: deserializeMetadata(output),
1734
1696
  });
1735
1697
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1736
- if (data.AutoTunes != null) {
1737
- contents.AutoTunes = de_AutoTuneList(data.AutoTunes, context);
1738
- }
1739
- if (data.NextToken != null) {
1740
- contents.NextToken = __expectString(data.NextToken);
1741
- }
1698
+ const doc = take(data, {
1699
+ AutoTunes: (_) => de_AutoTuneList(_, context),
1700
+ NextToken: __expectString,
1701
+ });
1702
+ Object.assign(contents, doc);
1742
1703
  return contents;
1743
1704
  };
1744
1705
  const de_DescribeDomainAutoTunesCommandError = async (output, context) => {
@@ -1762,10 +1723,9 @@ const de_DescribeDomainAutoTunesCommandError = async (output, context) => {
1762
1723
  throw await de_ValidationExceptionRes(parsedOutput, context);
1763
1724
  default:
1764
1725
  const parsedBody = parsedOutput.body;
1765
- throwDefaultError({
1726
+ return throwDefaultError({
1766
1727
  output,
1767
1728
  parsedBody,
1768
- exceptionCtor: __BaseException,
1769
1729
  errorCode,
1770
1730
  });
1771
1731
  }
@@ -1778,9 +1738,10 @@ export const de_DescribeDomainChangeProgressCommand = async (output, context) =>
1778
1738
  $metadata: deserializeMetadata(output),
1779
1739
  });
1780
1740
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1781
- if (data.ChangeProgressStatus != null) {
1782
- contents.ChangeProgressStatus = de_ChangeProgressStatusDetails(data.ChangeProgressStatus, context);
1783
- }
1741
+ const doc = take(data, {
1742
+ ChangeProgressStatus: (_) => de_ChangeProgressStatusDetails(_, context),
1743
+ });
1744
+ Object.assign(contents, doc);
1784
1745
  return contents;
1785
1746
  };
1786
1747
  const de_DescribeDomainChangeProgressCommandError = async (output, context) => {
@@ -1804,10 +1765,9 @@ const de_DescribeDomainChangeProgressCommandError = async (output, context) => {
1804
1765
  throw await de_ValidationExceptionRes(parsedOutput, context);
1805
1766
  default:
1806
1767
  const parsedBody = parsedOutput.body;
1807
- throwDefaultError({
1768
+ return throwDefaultError({
1808
1769
  output,
1809
1770
  parsedBody,
1810
- exceptionCtor: __BaseException,
1811
1771
  errorCode,
1812
1772
  });
1813
1773
  }
@@ -1820,9 +1780,10 @@ export const de_DescribeElasticsearchDomainCommand = async (output, context) =>
1820
1780
  $metadata: deserializeMetadata(output),
1821
1781
  });
1822
1782
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1823
- if (data.DomainStatus != null) {
1824
- contents.DomainStatus = de_ElasticsearchDomainStatus(data.DomainStatus, context);
1825
- }
1783
+ const doc = take(data, {
1784
+ DomainStatus: (_) => de_ElasticsearchDomainStatus(_, context),
1785
+ });
1786
+ Object.assign(contents, doc);
1826
1787
  return contents;
1827
1788
  };
1828
1789
  const de_DescribeElasticsearchDomainCommandError = async (output, context) => {
@@ -1846,10 +1807,9 @@ const de_DescribeElasticsearchDomainCommandError = async (output, context) => {
1846
1807
  throw await de_ValidationExceptionRes(parsedOutput, context);
1847
1808
  default:
1848
1809
  const parsedBody = parsedOutput.body;
1849
- throwDefaultError({
1810
+ return throwDefaultError({
1850
1811
  output,
1851
1812
  parsedBody,
1852
- exceptionCtor: __BaseException,
1853
1813
  errorCode,
1854
1814
  });
1855
1815
  }
@@ -1862,9 +1822,10 @@ export const de_DescribeElasticsearchDomainConfigCommand = async (output, contex
1862
1822
  $metadata: deserializeMetadata(output),
1863
1823
  });
1864
1824
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1865
- if (data.DomainConfig != null) {
1866
- contents.DomainConfig = de_ElasticsearchDomainConfig(data.DomainConfig, context);
1867
- }
1825
+ const doc = take(data, {
1826
+ DomainConfig: (_) => de_ElasticsearchDomainConfig(_, context),
1827
+ });
1828
+ Object.assign(contents, doc);
1868
1829
  return contents;
1869
1830
  };
1870
1831
  const de_DescribeElasticsearchDomainConfigCommandError = async (output, context) => {
@@ -1888,10 +1849,9 @@ const de_DescribeElasticsearchDomainConfigCommandError = async (output, context)
1888
1849
  throw await de_ValidationExceptionRes(parsedOutput, context);
1889
1850
  default:
1890
1851
  const parsedBody = parsedOutput.body;
1891
- throwDefaultError({
1852
+ return throwDefaultError({
1892
1853
  output,
1893
1854
  parsedBody,
1894
- exceptionCtor: __BaseException,
1895
1855
  errorCode,
1896
1856
  });
1897
1857
  }
@@ -1904,9 +1864,10 @@ export const de_DescribeElasticsearchDomainsCommand = async (output, context) =>
1904
1864
  $metadata: deserializeMetadata(output),
1905
1865
  });
1906
1866
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1907
- if (data.DomainStatusList != null) {
1908
- contents.DomainStatusList = de_ElasticsearchDomainStatusList(data.DomainStatusList, context);
1909
- }
1867
+ const doc = take(data, {
1868
+ DomainStatusList: (_) => de_ElasticsearchDomainStatusList(_, context),
1869
+ });
1870
+ Object.assign(contents, doc);
1910
1871
  return contents;
1911
1872
  };
1912
1873
  const de_DescribeElasticsearchDomainsCommandError = async (output, context) => {
@@ -1927,10 +1888,9 @@ const de_DescribeElasticsearchDomainsCommandError = async (output, context) => {
1927
1888
  throw await de_ValidationExceptionRes(parsedOutput, context);
1928
1889
  default:
1929
1890
  const parsedBody = parsedOutput.body;
1930
- throwDefaultError({
1891
+ return throwDefaultError({
1931
1892
  output,
1932
1893
  parsedBody,
1933
- exceptionCtor: __BaseException,
1934
1894
  errorCode,
1935
1895
  });
1936
1896
  }
@@ -1943,9 +1903,10 @@ export const de_DescribeElasticsearchInstanceTypeLimitsCommand = async (output,
1943
1903
  $metadata: deserializeMetadata(output),
1944
1904
  });
1945
1905
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1946
- if (data.LimitsByRole != null) {
1947
- contents.LimitsByRole = de_LimitsByRole(data.LimitsByRole, context);
1948
- }
1906
+ const doc = take(data, {
1907
+ LimitsByRole: _json,
1908
+ });
1909
+ Object.assign(contents, doc);
1949
1910
  return contents;
1950
1911
  };
1951
1912
  const de_DescribeElasticsearchInstanceTypeLimitsCommandError = async (output, context) => {
@@ -1975,10 +1936,9 @@ const de_DescribeElasticsearchInstanceTypeLimitsCommandError = async (output, co
1975
1936
  throw await de_ValidationExceptionRes(parsedOutput, context);
1976
1937
  default:
1977
1938
  const parsedBody = parsedOutput.body;
1978
- throwDefaultError({
1939
+ return throwDefaultError({
1979
1940
  output,
1980
1941
  parsedBody,
1981
- exceptionCtor: __BaseException,
1982
1942
  errorCode,
1983
1943
  });
1984
1944
  }
@@ -1991,12 +1951,11 @@ export const de_DescribeInboundCrossClusterSearchConnectionsCommand = async (out
1991
1951
  $metadata: deserializeMetadata(output),
1992
1952
  });
1993
1953
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1994
- if (data.CrossClusterSearchConnections != null) {
1995
- contents.CrossClusterSearchConnections = de_InboundCrossClusterSearchConnections(data.CrossClusterSearchConnections, context);
1996
- }
1997
- if (data.NextToken != null) {
1998
- contents.NextToken = __expectString(data.NextToken);
1999
- }
1954
+ const doc = take(data, {
1955
+ CrossClusterSearchConnections: _json,
1956
+ NextToken: __expectString,
1957
+ });
1958
+ Object.assign(contents, doc);
2000
1959
  return contents;
2001
1960
  };
2002
1961
  const de_DescribeInboundCrossClusterSearchConnectionsCommandError = async (output, context) => {
@@ -2014,10 +1973,9 @@ const de_DescribeInboundCrossClusterSearchConnectionsCommandError = async (outpu
2014
1973
  throw await de_InvalidPaginationTokenExceptionRes(parsedOutput, context);
2015
1974
  default:
2016
1975
  const parsedBody = parsedOutput.body;
2017
- throwDefaultError({
1976
+ return throwDefaultError({
2018
1977
  output,
2019
1978
  parsedBody,
2020
- exceptionCtor: __BaseException,
2021
1979
  errorCode,
2022
1980
  });
2023
1981
  }
@@ -2030,12 +1988,11 @@ export const de_DescribeOutboundCrossClusterSearchConnectionsCommand = async (ou
2030
1988
  $metadata: deserializeMetadata(output),
2031
1989
  });
2032
1990
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
2033
- if (data.CrossClusterSearchConnections != null) {
2034
- contents.CrossClusterSearchConnections = de_OutboundCrossClusterSearchConnections(data.CrossClusterSearchConnections, context);
2035
- }
2036
- if (data.NextToken != null) {
2037
- contents.NextToken = __expectString(data.NextToken);
2038
- }
1991
+ const doc = take(data, {
1992
+ CrossClusterSearchConnections: _json,
1993
+ NextToken: __expectString,
1994
+ });
1995
+ Object.assign(contents, doc);
2039
1996
  return contents;
2040
1997
  };
2041
1998
  const de_DescribeOutboundCrossClusterSearchConnectionsCommandError = async (output, context) => {
@@ -2053,10 +2010,9 @@ const de_DescribeOutboundCrossClusterSearchConnectionsCommandError = async (outp
2053
2010
  throw await de_InvalidPaginationTokenExceptionRes(parsedOutput, context);
2054
2011
  default:
2055
2012
  const parsedBody = parsedOutput.body;
2056
- throwDefaultError({
2013
+ return throwDefaultError({
2057
2014
  output,
2058
2015
  parsedBody,
2059
- exceptionCtor: __BaseException,
2060
2016
  errorCode,
2061
2017
  });
2062
2018
  }
@@ -2069,12 +2025,11 @@ export const de_DescribePackagesCommand = async (output, context) => {
2069
2025
  $metadata: deserializeMetadata(output),
2070
2026
  });
2071
2027
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
2072
- if (data.NextToken != null) {
2073
- contents.NextToken = __expectString(data.NextToken);
2074
- }
2075
- if (data.PackageDetailsList != null) {
2076
- contents.PackageDetailsList = de_PackageDetailsList(data.PackageDetailsList, context);
2077
- }
2028
+ const doc = take(data, {
2029
+ NextToken: __expectString,
2030
+ PackageDetailsList: (_) => de_PackageDetailsList(_, context),
2031
+ });
2032
+ Object.assign(contents, doc);
2078
2033
  return contents;
2079
2034
  };
2080
2035
  const de_DescribePackagesCommandError = async (output, context) => {
@@ -2101,10 +2056,9 @@ const de_DescribePackagesCommandError = async (output, context) => {
2101
2056
  throw await de_ValidationExceptionRes(parsedOutput, context);
2102
2057
  default:
2103
2058
  const parsedBody = parsedOutput.body;
2104
- throwDefaultError({
2059
+ return throwDefaultError({
2105
2060
  output,
2106
2061
  parsedBody,
2107
- exceptionCtor: __BaseException,
2108
2062
  errorCode,
2109
2063
  });
2110
2064
  }
@@ -2117,12 +2071,11 @@ export const de_DescribeReservedElasticsearchInstanceOfferingsCommand = async (o
2117
2071
  $metadata: deserializeMetadata(output),
2118
2072
  });
2119
2073
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
2120
- if (data.NextToken != null) {
2121
- contents.NextToken = __expectString(data.NextToken);
2122
- }
2123
- if (data.ReservedElasticsearchInstanceOfferings != null) {
2124
- contents.ReservedElasticsearchInstanceOfferings = de_ReservedElasticsearchInstanceOfferingList(data.ReservedElasticsearchInstanceOfferings, context);
2125
- }
2074
+ const doc = take(data, {
2075
+ NextToken: __expectString,
2076
+ ReservedElasticsearchInstanceOfferings: (_) => de_ReservedElasticsearchInstanceOfferingList(_, context),
2077
+ });
2078
+ Object.assign(contents, doc);
2126
2079
  return contents;
2127
2080
  };
2128
2081
  const de_DescribeReservedElasticsearchInstanceOfferingsCommandError = async (output, context) => {
@@ -2146,10 +2099,9 @@ const de_DescribeReservedElasticsearchInstanceOfferingsCommandError = async (out
2146
2099
  throw await de_ValidationExceptionRes(parsedOutput, context);
2147
2100
  default:
2148
2101
  const parsedBody = parsedOutput.body;
2149
- throwDefaultError({
2102
+ return throwDefaultError({
2150
2103
  output,
2151
2104
  parsedBody,
2152
- exceptionCtor: __BaseException,
2153
2105
  errorCode,
2154
2106
  });
2155
2107
  }
@@ -2162,12 +2114,11 @@ export const de_DescribeReservedElasticsearchInstancesCommand = async (output, c
2162
2114
  $metadata: deserializeMetadata(output),
2163
2115
  });
2164
2116
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
2165
- if (data.NextToken != null) {
2166
- contents.NextToken = __expectString(data.NextToken);
2167
- }
2168
- if (data.ReservedElasticsearchInstances != null) {
2169
- contents.ReservedElasticsearchInstances = de_ReservedElasticsearchInstanceList(data.ReservedElasticsearchInstances, context);
2170
- }
2117
+ const doc = take(data, {
2118
+ NextToken: __expectString,
2119
+ ReservedElasticsearchInstances: (_) => de_ReservedElasticsearchInstanceList(_, context),
2120
+ });
2121
+ Object.assign(contents, doc);
2171
2122
  return contents;
2172
2123
  };
2173
2124
  const de_DescribeReservedElasticsearchInstancesCommandError = async (output, context) => {
@@ -2191,10 +2142,9 @@ const de_DescribeReservedElasticsearchInstancesCommandError = async (output, con
2191
2142
  throw await de_ValidationExceptionRes(parsedOutput, context);
2192
2143
  default:
2193
2144
  const parsedBody = parsedOutput.body;
2194
- throwDefaultError({
2145
+ return throwDefaultError({
2195
2146
  output,
2196
2147
  parsedBody,
2197
- exceptionCtor: __BaseException,
2198
2148
  errorCode,
2199
2149
  });
2200
2150
  }
@@ -2207,12 +2157,11 @@ export const de_DescribeVpcEndpointsCommand = async (output, context) => {
2207
2157
  $metadata: deserializeMetadata(output),
2208
2158
  });
2209
2159
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
2210
- if (data.VpcEndpointErrors != null) {
2211
- contents.VpcEndpointErrors = de_VpcEndpointErrorList(data.VpcEndpointErrors, context);
2212
- }
2213
- if (data.VpcEndpoints != null) {
2214
- contents.VpcEndpoints = de_VpcEndpoints(data.VpcEndpoints, context);
2215
- }
2160
+ const doc = take(data, {
2161
+ VpcEndpointErrors: _json,
2162
+ VpcEndpoints: _json,
2163
+ });
2164
+ Object.assign(contents, doc);
2216
2165
  return contents;
2217
2166
  };
2218
2167
  const de_DescribeVpcEndpointsCommandError = async (output, context) => {
@@ -2236,10 +2185,9 @@ const de_DescribeVpcEndpointsCommandError = async (output, context) => {
2236
2185
  throw await de_ValidationExceptionRes(parsedOutput, context);
2237
2186
  default:
2238
2187
  const parsedBody = parsedOutput.body;
2239
- throwDefaultError({
2188
+ return throwDefaultError({
2240
2189
  output,
2241
2190
  parsedBody,
2242
- exceptionCtor: __BaseException,
2243
2191
  errorCode,
2244
2192
  });
2245
2193
  }
@@ -2252,9 +2200,10 @@ export const de_DissociatePackageCommand = async (output, context) => {
2252
2200
  $metadata: deserializeMetadata(output),
2253
2201
  });
2254
2202
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
2255
- if (data.DomainPackageDetails != null) {
2256
- contents.DomainPackageDetails = de_DomainPackageDetails(data.DomainPackageDetails, context);
2257
- }
2203
+ const doc = take(data, {
2204
+ DomainPackageDetails: (_) => de_DomainPackageDetails(_, context),
2205
+ });
2206
+ Object.assign(contents, doc);
2258
2207
  return contents;
2259
2208
  };
2260
2209
  const de_DissociatePackageCommandError = async (output, context) => {
@@ -2284,10 +2233,9 @@ const de_DissociatePackageCommandError = async (output, context) => {
2284
2233
  throw await de_ValidationExceptionRes(parsedOutput, context);
2285
2234
  default:
2286
2235
  const parsedBody = parsedOutput.body;
2287
- throwDefaultError({
2236
+ return throwDefaultError({
2288
2237
  output,
2289
2238
  parsedBody,
2290
- exceptionCtor: __BaseException,
2291
2239
  errorCode,
2292
2240
  });
2293
2241
  }
@@ -2300,9 +2248,10 @@ export const de_GetCompatibleElasticsearchVersionsCommand = async (output, conte
2300
2248
  $metadata: deserializeMetadata(output),
2301
2249
  });
2302
2250
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
2303
- if (data.CompatibleElasticsearchVersions != null) {
2304
- contents.CompatibleElasticsearchVersions = de_CompatibleElasticsearchVersionsList(data.CompatibleElasticsearchVersions, context);
2305
- }
2251
+ const doc = take(data, {
2252
+ CompatibleElasticsearchVersions: _json,
2253
+ });
2254
+ Object.assign(contents, doc);
2306
2255
  return contents;
2307
2256
  };
2308
2257
  const de_GetCompatibleElasticsearchVersionsCommandError = async (output, context) => {
@@ -2329,10 +2278,9 @@ const de_GetCompatibleElasticsearchVersionsCommandError = async (output, context
2329
2278
  throw await de_ValidationExceptionRes(parsedOutput, context);
2330
2279
  default:
2331
2280
  const parsedBody = parsedOutput.body;
2332
- throwDefaultError({
2281
+ return throwDefaultError({
2333
2282
  output,
2334
2283
  parsedBody,
2335
- exceptionCtor: __BaseException,
2336
2284
  errorCode,
2337
2285
  });
2338
2286
  }
@@ -2345,15 +2293,12 @@ export const de_GetPackageVersionHistoryCommand = async (output, context) => {
2345
2293
  $metadata: deserializeMetadata(output),
2346
2294
  });
2347
2295
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
2348
- if (data.NextToken != null) {
2349
- contents.NextToken = __expectString(data.NextToken);
2350
- }
2351
- if (data.PackageID != null) {
2352
- contents.PackageID = __expectString(data.PackageID);
2353
- }
2354
- if (data.PackageVersionHistoryList != null) {
2355
- contents.PackageVersionHistoryList = de_PackageVersionHistoryList(data.PackageVersionHistoryList, context);
2356
- }
2296
+ const doc = take(data, {
2297
+ NextToken: __expectString,
2298
+ PackageID: __expectString,
2299
+ PackageVersionHistoryList: (_) => de_PackageVersionHistoryList(_, context),
2300
+ });
2301
+ Object.assign(contents, doc);
2357
2302
  return contents;
2358
2303
  };
2359
2304
  const de_GetPackageVersionHistoryCommandError = async (output, context) => {
@@ -2380,10 +2325,9 @@ const de_GetPackageVersionHistoryCommandError = async (output, context) => {
2380
2325
  throw await de_ValidationExceptionRes(parsedOutput, context);
2381
2326
  default:
2382
2327
  const parsedBody = parsedOutput.body;
2383
- throwDefaultError({
2328
+ return throwDefaultError({
2384
2329
  output,
2385
2330
  parsedBody,
2386
- exceptionCtor: __BaseException,
2387
2331
  errorCode,
2388
2332
  });
2389
2333
  }
@@ -2396,12 +2340,11 @@ export const de_GetUpgradeHistoryCommand = async (output, context) => {
2396
2340
  $metadata: deserializeMetadata(output),
2397
2341
  });
2398
2342
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
2399
- if (data.NextToken != null) {
2400
- contents.NextToken = __expectString(data.NextToken);
2401
- }
2402
- if (data.UpgradeHistories != null) {
2403
- contents.UpgradeHistories = de_UpgradeHistoryList(data.UpgradeHistories, context);
2404
- }
2343
+ const doc = take(data, {
2344
+ NextToken: __expectString,
2345
+ UpgradeHistories: (_) => de_UpgradeHistoryList(_, context),
2346
+ });
2347
+ Object.assign(contents, doc);
2405
2348
  return contents;
2406
2349
  };
2407
2350
  const de_GetUpgradeHistoryCommandError = async (output, context) => {
@@ -2428,10 +2371,9 @@ const de_GetUpgradeHistoryCommandError = async (output, context) => {
2428
2371
  throw await de_ValidationExceptionRes(parsedOutput, context);
2429
2372
  default:
2430
2373
  const parsedBody = parsedOutput.body;
2431
- throwDefaultError({
2374
+ return throwDefaultError({
2432
2375
  output,
2433
2376
  parsedBody,
2434
- exceptionCtor: __BaseException,
2435
2377
  errorCode,
2436
2378
  });
2437
2379
  }
@@ -2444,15 +2386,12 @@ export const de_GetUpgradeStatusCommand = async (output, context) => {
2444
2386
  $metadata: deserializeMetadata(output),
2445
2387
  });
2446
2388
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
2447
- if (data.StepStatus != null) {
2448
- contents.StepStatus = __expectString(data.StepStatus);
2449
- }
2450
- if (data.UpgradeName != null) {
2451
- contents.UpgradeName = __expectString(data.UpgradeName);
2452
- }
2453
- if (data.UpgradeStep != null) {
2454
- contents.UpgradeStep = __expectString(data.UpgradeStep);
2455
- }
2389
+ const doc = take(data, {
2390
+ StepStatus: __expectString,
2391
+ UpgradeName: __expectString,
2392
+ UpgradeStep: __expectString,
2393
+ });
2394
+ Object.assign(contents, doc);
2456
2395
  return contents;
2457
2396
  };
2458
2397
  const de_GetUpgradeStatusCommandError = async (output, context) => {
@@ -2479,10 +2418,9 @@ const de_GetUpgradeStatusCommandError = async (output, context) => {
2479
2418
  throw await de_ValidationExceptionRes(parsedOutput, context);
2480
2419
  default:
2481
2420
  const parsedBody = parsedOutput.body;
2482
- throwDefaultError({
2421
+ return throwDefaultError({
2483
2422
  output,
2484
2423
  parsedBody,
2485
- exceptionCtor: __BaseException,
2486
2424
  errorCode,
2487
2425
  });
2488
2426
  }
@@ -2495,9 +2433,10 @@ export const de_ListDomainNamesCommand = async (output, context) => {
2495
2433
  $metadata: deserializeMetadata(output),
2496
2434
  });
2497
2435
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
2498
- if (data.DomainNames != null) {
2499
- contents.DomainNames = de_DomainInfoList(data.DomainNames, context);
2500
- }
2436
+ const doc = take(data, {
2437
+ DomainNames: _json,
2438
+ });
2439
+ Object.assign(contents, doc);
2501
2440
  return contents;
2502
2441
  };
2503
2442
  const de_ListDomainNamesCommandError = async (output, context) => {
@@ -2515,10 +2454,9 @@ const de_ListDomainNamesCommandError = async (output, context) => {
2515
2454
  throw await de_ValidationExceptionRes(parsedOutput, context);
2516
2455
  default:
2517
2456
  const parsedBody = parsedOutput.body;
2518
- throwDefaultError({
2457
+ return throwDefaultError({
2519
2458
  output,
2520
2459
  parsedBody,
2521
- exceptionCtor: __BaseException,
2522
2460
  errorCode,
2523
2461
  });
2524
2462
  }
@@ -2531,12 +2469,11 @@ export const de_ListDomainsForPackageCommand = async (output, context) => {
2531
2469
  $metadata: deserializeMetadata(output),
2532
2470
  });
2533
2471
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
2534
- if (data.DomainPackageDetailsList != null) {
2535
- contents.DomainPackageDetailsList = de_DomainPackageDetailsList(data.DomainPackageDetailsList, context);
2536
- }
2537
- if (data.NextToken != null) {
2538
- contents.NextToken = __expectString(data.NextToken);
2539
- }
2472
+ const doc = take(data, {
2473
+ DomainPackageDetailsList: (_) => de_DomainPackageDetailsList(_, context),
2474
+ NextToken: __expectString,
2475
+ });
2476
+ Object.assign(contents, doc);
2540
2477
  return contents;
2541
2478
  };
2542
2479
  const de_ListDomainsForPackageCommandError = async (output, context) => {
@@ -2563,10 +2500,9 @@ const de_ListDomainsForPackageCommandError = async (output, context) => {
2563
2500
  throw await de_ValidationExceptionRes(parsedOutput, context);
2564
2501
  default:
2565
2502
  const parsedBody = parsedOutput.body;
2566
- throwDefaultError({
2503
+ return throwDefaultError({
2567
2504
  output,
2568
2505
  parsedBody,
2569
- exceptionCtor: __BaseException,
2570
2506
  errorCode,
2571
2507
  });
2572
2508
  }
@@ -2579,12 +2515,11 @@ export const de_ListElasticsearchInstanceTypesCommand = async (output, context)
2579
2515
  $metadata: deserializeMetadata(output),
2580
2516
  });
2581
2517
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
2582
- if (data.ElasticsearchInstanceTypes != null) {
2583
- contents.ElasticsearchInstanceTypes = de_ElasticsearchInstanceTypeList(data.ElasticsearchInstanceTypes, context);
2584
- }
2585
- if (data.NextToken != null) {
2586
- contents.NextToken = __expectString(data.NextToken);
2587
- }
2518
+ const doc = take(data, {
2519
+ ElasticsearchInstanceTypes: _json,
2520
+ NextToken: __expectString,
2521
+ });
2522
+ Object.assign(contents, doc);
2588
2523
  return contents;
2589
2524
  };
2590
2525
  const de_ListElasticsearchInstanceTypesCommandError = async (output, context) => {
@@ -2608,10 +2543,9 @@ const de_ListElasticsearchInstanceTypesCommandError = async (output, context) =>
2608
2543
  throw await de_ValidationExceptionRes(parsedOutput, context);
2609
2544
  default:
2610
2545
  const parsedBody = parsedOutput.body;
2611
- throwDefaultError({
2546
+ return throwDefaultError({
2612
2547
  output,
2613
2548
  parsedBody,
2614
- exceptionCtor: __BaseException,
2615
2549
  errorCode,
2616
2550
  });
2617
2551
  }
@@ -2624,12 +2558,11 @@ export const de_ListElasticsearchVersionsCommand = async (output, context) => {
2624
2558
  $metadata: deserializeMetadata(output),
2625
2559
  });
2626
2560
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
2627
- if (data.ElasticsearchVersions != null) {
2628
- contents.ElasticsearchVersions = de_ElasticsearchVersionList(data.ElasticsearchVersions, context);
2629
- }
2630
- if (data.NextToken != null) {
2631
- contents.NextToken = __expectString(data.NextToken);
2632
- }
2561
+ const doc = take(data, {
2562
+ ElasticsearchVersions: _json,
2563
+ NextToken: __expectString,
2564
+ });
2565
+ Object.assign(contents, doc);
2633
2566
  return contents;
2634
2567
  };
2635
2568
  const de_ListElasticsearchVersionsCommandError = async (output, context) => {
@@ -2653,10 +2586,9 @@ const de_ListElasticsearchVersionsCommandError = async (output, context) => {
2653
2586
  throw await de_ValidationExceptionRes(parsedOutput, context);
2654
2587
  default:
2655
2588
  const parsedBody = parsedOutput.body;
2656
- throwDefaultError({
2589
+ return throwDefaultError({
2657
2590
  output,
2658
2591
  parsedBody,
2659
- exceptionCtor: __BaseException,
2660
2592
  errorCode,
2661
2593
  });
2662
2594
  }
@@ -2669,12 +2601,11 @@ export const de_ListPackagesForDomainCommand = async (output, context) => {
2669
2601
  $metadata: deserializeMetadata(output),
2670
2602
  });
2671
2603
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
2672
- if (data.DomainPackageDetailsList != null) {
2673
- contents.DomainPackageDetailsList = de_DomainPackageDetailsList(data.DomainPackageDetailsList, context);
2674
- }
2675
- if (data.NextToken != null) {
2676
- contents.NextToken = __expectString(data.NextToken);
2677
- }
2604
+ const doc = take(data, {
2605
+ DomainPackageDetailsList: (_) => de_DomainPackageDetailsList(_, context),
2606
+ NextToken: __expectString,
2607
+ });
2608
+ Object.assign(contents, doc);
2678
2609
  return contents;
2679
2610
  };
2680
2611
  const de_ListPackagesForDomainCommandError = async (output, context) => {
@@ -2701,10 +2632,9 @@ const de_ListPackagesForDomainCommandError = async (output, context) => {
2701
2632
  throw await de_ValidationExceptionRes(parsedOutput, context);
2702
2633
  default:
2703
2634
  const parsedBody = parsedOutput.body;
2704
- throwDefaultError({
2635
+ return throwDefaultError({
2705
2636
  output,
2706
2637
  parsedBody,
2707
- exceptionCtor: __BaseException,
2708
2638
  errorCode,
2709
2639
  });
2710
2640
  }
@@ -2717,9 +2647,10 @@ export const de_ListTagsCommand = async (output, context) => {
2717
2647
  $metadata: deserializeMetadata(output),
2718
2648
  });
2719
2649
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
2720
- if (data.TagList != null) {
2721
- contents.TagList = de_TagList(data.TagList, context);
2722
- }
2650
+ const doc = take(data, {
2651
+ TagList: _json,
2652
+ });
2653
+ Object.assign(contents, doc);
2723
2654
  return contents;
2724
2655
  };
2725
2656
  const de_ListTagsCommandError = async (output, context) => {
@@ -2743,10 +2674,9 @@ const de_ListTagsCommandError = async (output, context) => {
2743
2674
  throw await de_ValidationExceptionRes(parsedOutput, context);
2744
2675
  default:
2745
2676
  const parsedBody = parsedOutput.body;
2746
- throwDefaultError({
2677
+ return throwDefaultError({
2747
2678
  output,
2748
2679
  parsedBody,
2749
- exceptionCtor: __BaseException,
2750
2680
  errorCode,
2751
2681
  });
2752
2682
  }
@@ -2759,12 +2689,11 @@ export const de_ListVpcEndpointAccessCommand = async (output, context) => {
2759
2689
  $metadata: deserializeMetadata(output),
2760
2690
  });
2761
2691
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
2762
- if (data.AuthorizedPrincipalList != null) {
2763
- contents.AuthorizedPrincipalList = de_AuthorizedPrincipalList(data.AuthorizedPrincipalList, context);
2764
- }
2765
- if (data.NextToken != null) {
2766
- contents.NextToken = __expectString(data.NextToken);
2767
- }
2692
+ const doc = take(data, {
2693
+ AuthorizedPrincipalList: _json,
2694
+ NextToken: __expectString,
2695
+ });
2696
+ Object.assign(contents, doc);
2768
2697
  return contents;
2769
2698
  };
2770
2699
  const de_ListVpcEndpointAccessCommandError = async (output, context) => {
@@ -2788,10 +2717,9 @@ const de_ListVpcEndpointAccessCommandError = async (output, context) => {
2788
2717
  throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2789
2718
  default:
2790
2719
  const parsedBody = parsedOutput.body;
2791
- throwDefaultError({
2720
+ return throwDefaultError({
2792
2721
  output,
2793
2722
  parsedBody,
2794
- exceptionCtor: __BaseException,
2795
2723
  errorCode,
2796
2724
  });
2797
2725
  }
@@ -2804,12 +2732,11 @@ export const de_ListVpcEndpointsCommand = async (output, context) => {
2804
2732
  $metadata: deserializeMetadata(output),
2805
2733
  });
2806
2734
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
2807
- if (data.NextToken != null) {
2808
- contents.NextToken = __expectString(data.NextToken);
2809
- }
2810
- if (data.VpcEndpointSummaryList != null) {
2811
- contents.VpcEndpointSummaryList = de_VpcEndpointSummaryList(data.VpcEndpointSummaryList, context);
2812
- }
2735
+ const doc = take(data, {
2736
+ NextToken: __expectString,
2737
+ VpcEndpointSummaryList: _json,
2738
+ });
2739
+ Object.assign(contents, doc);
2813
2740
  return contents;
2814
2741
  };
2815
2742
  const de_ListVpcEndpointsCommandError = async (output, context) => {
@@ -2830,10 +2757,9 @@ const de_ListVpcEndpointsCommandError = async (output, context) => {
2830
2757
  throw await de_InternalExceptionRes(parsedOutput, context);
2831
2758
  default:
2832
2759
  const parsedBody = parsedOutput.body;
2833
- throwDefaultError({
2760
+ return throwDefaultError({
2834
2761
  output,
2835
2762
  parsedBody,
2836
- exceptionCtor: __BaseException,
2837
2763
  errorCode,
2838
2764
  });
2839
2765
  }
@@ -2846,12 +2772,11 @@ export const de_ListVpcEndpointsForDomainCommand = async (output, context) => {
2846
2772
  $metadata: deserializeMetadata(output),
2847
2773
  });
2848
2774
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
2849
- if (data.NextToken != null) {
2850
- contents.NextToken = __expectString(data.NextToken);
2851
- }
2852
- if (data.VpcEndpointSummaryList != null) {
2853
- contents.VpcEndpointSummaryList = de_VpcEndpointSummaryList(data.VpcEndpointSummaryList, context);
2854
- }
2775
+ const doc = take(data, {
2776
+ NextToken: __expectString,
2777
+ VpcEndpointSummaryList: _json,
2778
+ });
2779
+ Object.assign(contents, doc);
2855
2780
  return contents;
2856
2781
  };
2857
2782
  const de_ListVpcEndpointsForDomainCommandError = async (output, context) => {
@@ -2875,10 +2800,9 @@ const de_ListVpcEndpointsForDomainCommandError = async (output, context) => {
2875
2800
  throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2876
2801
  default:
2877
2802
  const parsedBody = parsedOutput.body;
2878
- throwDefaultError({
2803
+ return throwDefaultError({
2879
2804
  output,
2880
2805
  parsedBody,
2881
- exceptionCtor: __BaseException,
2882
2806
  errorCode,
2883
2807
  });
2884
2808
  }
@@ -2891,12 +2815,11 @@ export const de_PurchaseReservedElasticsearchInstanceOfferingCommand = async (ou
2891
2815
  $metadata: deserializeMetadata(output),
2892
2816
  });
2893
2817
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
2894
- if (data.ReservationName != null) {
2895
- contents.ReservationName = __expectString(data.ReservationName);
2896
- }
2897
- if (data.ReservedElasticsearchInstanceId != null) {
2898
- contents.ReservedElasticsearchInstanceId = __expectString(data.ReservedElasticsearchInstanceId);
2899
- }
2818
+ const doc = take(data, {
2819
+ ReservationName: __expectString,
2820
+ ReservedElasticsearchInstanceId: __expectString,
2821
+ });
2822
+ Object.assign(contents, doc);
2900
2823
  return contents;
2901
2824
  };
2902
2825
  const de_PurchaseReservedElasticsearchInstanceOfferingCommandError = async (output, context) => {
@@ -2926,10 +2849,9 @@ const de_PurchaseReservedElasticsearchInstanceOfferingCommandError = async (outp
2926
2849
  throw await de_ValidationExceptionRes(parsedOutput, context);
2927
2850
  default:
2928
2851
  const parsedBody = parsedOutput.body;
2929
- throwDefaultError({
2852
+ return throwDefaultError({
2930
2853
  output,
2931
2854
  parsedBody,
2932
- exceptionCtor: __BaseException,
2933
2855
  errorCode,
2934
2856
  });
2935
2857
  }
@@ -2942,9 +2864,10 @@ export const de_RejectInboundCrossClusterSearchConnectionCommand = async (output
2942
2864
  $metadata: deserializeMetadata(output),
2943
2865
  });
2944
2866
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
2945
- if (data.CrossClusterSearchConnection != null) {
2946
- contents.CrossClusterSearchConnection = de_InboundCrossClusterSearchConnection(data.CrossClusterSearchConnection, context);
2947
- }
2867
+ const doc = take(data, {
2868
+ CrossClusterSearchConnection: _json,
2869
+ });
2870
+ Object.assign(contents, doc);
2948
2871
  return contents;
2949
2872
  };
2950
2873
  const de_RejectInboundCrossClusterSearchConnectionCommandError = async (output, context) => {
@@ -2962,10 +2885,9 @@ const de_RejectInboundCrossClusterSearchConnectionCommandError = async (output,
2962
2885
  throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2963
2886
  default:
2964
2887
  const parsedBody = parsedOutput.body;
2965
- throwDefaultError({
2888
+ return throwDefaultError({
2966
2889
  output,
2967
2890
  parsedBody,
2968
- exceptionCtor: __BaseException,
2969
2891
  errorCode,
2970
2892
  });
2971
2893
  }
@@ -2998,10 +2920,9 @@ const de_RemoveTagsCommandError = async (output, context) => {
2998
2920
  throw await de_ValidationExceptionRes(parsedOutput, context);
2999
2921
  default:
3000
2922
  const parsedBody = parsedOutput.body;
3001
- throwDefaultError({
2923
+ return throwDefaultError({
3002
2924
  output,
3003
2925
  parsedBody,
3004
- exceptionCtor: __BaseException,
3005
2926
  errorCode,
3006
2927
  });
3007
2928
  }
@@ -3040,10 +2961,9 @@ const de_RevokeVpcEndpointAccessCommandError = async (output, context) => {
3040
2961
  throw await de_ValidationExceptionRes(parsedOutput, context);
3041
2962
  default:
3042
2963
  const parsedBody = parsedOutput.body;
3043
- throwDefaultError({
2964
+ return throwDefaultError({
3044
2965
  output,
3045
2966
  parsedBody,
3046
- exceptionCtor: __BaseException,
3047
2967
  errorCode,
3048
2968
  });
3049
2969
  }
@@ -3056,9 +2976,10 @@ export const de_StartElasticsearchServiceSoftwareUpdateCommand = async (output,
3056
2976
  $metadata: deserializeMetadata(output),
3057
2977
  });
3058
2978
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
3059
- if (data.ServiceSoftwareOptions != null) {
3060
- contents.ServiceSoftwareOptions = de_ServiceSoftwareOptions(data.ServiceSoftwareOptions, context);
3061
- }
2979
+ const doc = take(data, {
2980
+ ServiceSoftwareOptions: (_) => de_ServiceSoftwareOptions(_, context),
2981
+ });
2982
+ Object.assign(contents, doc);
3062
2983
  return contents;
3063
2984
  };
3064
2985
  const de_StartElasticsearchServiceSoftwareUpdateCommandError = async (output, context) => {
@@ -3082,10 +3003,9 @@ const de_StartElasticsearchServiceSoftwareUpdateCommandError = async (output, co
3082
3003
  throw await de_ValidationExceptionRes(parsedOutput, context);
3083
3004
  default:
3084
3005
  const parsedBody = parsedOutput.body;
3085
- throwDefaultError({
3006
+ return throwDefaultError({
3086
3007
  output,
3087
3008
  parsedBody,
3088
- exceptionCtor: __BaseException,
3089
3009
  errorCode,
3090
3010
  });
3091
3011
  }
@@ -3098,12 +3018,11 @@ export const de_UpdateElasticsearchDomainConfigCommand = async (output, context)
3098
3018
  $metadata: deserializeMetadata(output),
3099
3019
  });
3100
3020
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
3101
- if (data.DomainConfig != null) {
3102
- contents.DomainConfig = de_ElasticsearchDomainConfig(data.DomainConfig, context);
3103
- }
3104
- if (data.DryRunResults != null) {
3105
- contents.DryRunResults = de_DryRunResults(data.DryRunResults, context);
3106
- }
3021
+ const doc = take(data, {
3022
+ DomainConfig: (_) => de_ElasticsearchDomainConfig(_, context),
3023
+ DryRunResults: _json,
3024
+ });
3025
+ Object.assign(contents, doc);
3107
3026
  return contents;
3108
3027
  };
3109
3028
  const de_UpdateElasticsearchDomainConfigCommandError = async (output, context) => {
@@ -3133,10 +3052,9 @@ const de_UpdateElasticsearchDomainConfigCommandError = async (output, context) =
3133
3052
  throw await de_ValidationExceptionRes(parsedOutput, context);
3134
3053
  default:
3135
3054
  const parsedBody = parsedOutput.body;
3136
- throwDefaultError({
3055
+ return throwDefaultError({
3137
3056
  output,
3138
3057
  parsedBody,
3139
- exceptionCtor: __BaseException,
3140
3058
  errorCode,
3141
3059
  });
3142
3060
  }
@@ -3149,9 +3067,10 @@ export const de_UpdatePackageCommand = async (output, context) => {
3149
3067
  $metadata: deserializeMetadata(output),
3150
3068
  });
3151
3069
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
3152
- if (data.PackageDetails != null) {
3153
- contents.PackageDetails = de_PackageDetails(data.PackageDetails, context);
3154
- }
3070
+ const doc = take(data, {
3071
+ PackageDetails: (_) => de_PackageDetails(_, context),
3072
+ });
3073
+ Object.assign(contents, doc);
3155
3074
  return contents;
3156
3075
  };
3157
3076
  const de_UpdatePackageCommandError = async (output, context) => {
@@ -3181,10 +3100,9 @@ const de_UpdatePackageCommandError = async (output, context) => {
3181
3100
  throw await de_ValidationExceptionRes(parsedOutput, context);
3182
3101
  default:
3183
3102
  const parsedBody = parsedOutput.body;
3184
- throwDefaultError({
3103
+ return throwDefaultError({
3185
3104
  output,
3186
3105
  parsedBody,
3187
- exceptionCtor: __BaseException,
3188
3106
  errorCode,
3189
3107
  });
3190
3108
  }
@@ -3197,9 +3115,10 @@ export const de_UpdateVpcEndpointCommand = async (output, context) => {
3197
3115
  $metadata: deserializeMetadata(output),
3198
3116
  });
3199
3117
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
3200
- if (data.VpcEndpoint != null) {
3201
- contents.VpcEndpoint = de_VpcEndpoint(data.VpcEndpoint, context);
3202
- }
3118
+ const doc = take(data, {
3119
+ VpcEndpoint: _json,
3120
+ });
3121
+ Object.assign(contents, doc);
3203
3122
  return contents;
3204
3123
  };
3205
3124
  const de_UpdateVpcEndpointCommandError = async (output, context) => {
@@ -3229,10 +3148,9 @@ const de_UpdateVpcEndpointCommandError = async (output, context) => {
3229
3148
  throw await de_ValidationExceptionRes(parsedOutput, context);
3230
3149
  default:
3231
3150
  const parsedBody = parsedOutput.body;
3232
- throwDefaultError({
3151
+ return throwDefaultError({
3233
3152
  output,
3234
3153
  parsedBody,
3235
- exceptionCtor: __BaseException,
3236
3154
  errorCode,
3237
3155
  });
3238
3156
  }
@@ -3245,18 +3163,13 @@ export const de_UpgradeElasticsearchDomainCommand = async (output, context) => {
3245
3163
  $metadata: deserializeMetadata(output),
3246
3164
  });
3247
3165
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
3248
- if (data.ChangeProgressDetails != null) {
3249
- contents.ChangeProgressDetails = de_ChangeProgressDetails(data.ChangeProgressDetails, context);
3250
- }
3251
- if (data.DomainName != null) {
3252
- contents.DomainName = __expectString(data.DomainName);
3253
- }
3254
- if (data.PerformCheckOnly != null) {
3255
- contents.PerformCheckOnly = __expectBoolean(data.PerformCheckOnly);
3256
- }
3257
- if (data.TargetVersion != null) {
3258
- contents.TargetVersion = __expectString(data.TargetVersion);
3259
- }
3166
+ const doc = take(data, {
3167
+ ChangeProgressDetails: _json,
3168
+ DomainName: __expectString,
3169
+ PerformCheckOnly: __expectBoolean,
3170
+ TargetVersion: __expectString,
3171
+ });
3172
+ Object.assign(contents, doc);
3260
3173
  return contents;
3261
3174
  };
3262
3175
  const de_UpgradeElasticsearchDomainCommandError = async (output, context) => {
@@ -3286,21 +3199,21 @@ const de_UpgradeElasticsearchDomainCommandError = async (output, context) => {
3286
3199
  throw await de_ValidationExceptionRes(parsedOutput, context);
3287
3200
  default:
3288
3201
  const parsedBody = parsedOutput.body;
3289
- throwDefaultError({
3202
+ return throwDefaultError({
3290
3203
  output,
3291
3204
  parsedBody,
3292
- exceptionCtor: __BaseException,
3293
3205
  errorCode,
3294
3206
  });
3295
3207
  }
3296
3208
  };
3297
- const map = __map;
3209
+ const throwDefaultError = withBaseException(__BaseException);
3298
3210
  const de_AccessDeniedExceptionRes = async (parsedOutput, context) => {
3299
3211
  const contents = map({});
3300
3212
  const data = parsedOutput.body;
3301
- if (data.message != null) {
3302
- contents.message = __expectString(data.message);
3303
- }
3213
+ const doc = take(data, {
3214
+ message: __expectString,
3215
+ });
3216
+ Object.assign(contents, doc);
3304
3217
  const exception = new AccessDeniedException({
3305
3218
  $metadata: deserializeMetadata(parsedOutput),
3306
3219
  ...contents,
@@ -3310,9 +3223,10 @@ const de_AccessDeniedExceptionRes = async (parsedOutput, context) => {
3310
3223
  const de_BaseExceptionRes = async (parsedOutput, context) => {
3311
3224
  const contents = map({});
3312
3225
  const data = parsedOutput.body;
3313
- if (data.message != null) {
3314
- contents.message = __expectString(data.message);
3315
- }
3226
+ const doc = take(data, {
3227
+ message: __expectString,
3228
+ });
3229
+ Object.assign(contents, doc);
3316
3230
  const exception = new BaseException({
3317
3231
  $metadata: deserializeMetadata(parsedOutput),
3318
3232
  ...contents,
@@ -3322,9 +3236,10 @@ const de_BaseExceptionRes = async (parsedOutput, context) => {
3322
3236
  const de_ConflictExceptionRes = async (parsedOutput, context) => {
3323
3237
  const contents = map({});
3324
3238
  const data = parsedOutput.body;
3325
- if (data.message != null) {
3326
- contents.message = __expectString(data.message);
3327
- }
3239
+ const doc = take(data, {
3240
+ message: __expectString,
3241
+ });
3242
+ Object.assign(contents, doc);
3328
3243
  const exception = new ConflictException({
3329
3244
  $metadata: deserializeMetadata(parsedOutput),
3330
3245
  ...contents,
@@ -3334,9 +3249,10 @@ const de_ConflictExceptionRes = async (parsedOutput, context) => {
3334
3249
  const de_DisabledOperationExceptionRes = async (parsedOutput, context) => {
3335
3250
  const contents = map({});
3336
3251
  const data = parsedOutput.body;
3337
- if (data.message != null) {
3338
- contents.message = __expectString(data.message);
3339
- }
3252
+ const doc = take(data, {
3253
+ message: __expectString,
3254
+ });
3255
+ Object.assign(contents, doc);
3340
3256
  const exception = new DisabledOperationException({
3341
3257
  $metadata: deserializeMetadata(parsedOutput),
3342
3258
  ...contents,
@@ -3346,9 +3262,10 @@ const de_DisabledOperationExceptionRes = async (parsedOutput, context) => {
3346
3262
  const de_InternalExceptionRes = async (parsedOutput, context) => {
3347
3263
  const contents = map({});
3348
3264
  const data = parsedOutput.body;
3349
- if (data.message != null) {
3350
- contents.message = __expectString(data.message);
3351
- }
3265
+ const doc = take(data, {
3266
+ message: __expectString,
3267
+ });
3268
+ Object.assign(contents, doc);
3352
3269
  const exception = new InternalException({
3353
3270
  $metadata: deserializeMetadata(parsedOutput),
3354
3271
  ...contents,
@@ -3358,9 +3275,10 @@ const de_InternalExceptionRes = async (parsedOutput, context) => {
3358
3275
  const de_InvalidPaginationTokenExceptionRes = async (parsedOutput, context) => {
3359
3276
  const contents = map({});
3360
3277
  const data = parsedOutput.body;
3361
- if (data.message != null) {
3362
- contents.message = __expectString(data.message);
3363
- }
3278
+ const doc = take(data, {
3279
+ message: __expectString,
3280
+ });
3281
+ Object.assign(contents, doc);
3364
3282
  const exception = new InvalidPaginationTokenException({
3365
3283
  $metadata: deserializeMetadata(parsedOutput),
3366
3284
  ...contents,
@@ -3370,9 +3288,10 @@ const de_InvalidPaginationTokenExceptionRes = async (parsedOutput, context) => {
3370
3288
  const de_InvalidTypeExceptionRes = async (parsedOutput, context) => {
3371
3289
  const contents = map({});
3372
3290
  const data = parsedOutput.body;
3373
- if (data.message != null) {
3374
- contents.message = __expectString(data.message);
3375
- }
3291
+ const doc = take(data, {
3292
+ message: __expectString,
3293
+ });
3294
+ Object.assign(contents, doc);
3376
3295
  const exception = new InvalidTypeException({
3377
3296
  $metadata: deserializeMetadata(parsedOutput),
3378
3297
  ...contents,
@@ -3382,9 +3301,10 @@ const de_InvalidTypeExceptionRes = async (parsedOutput, context) => {
3382
3301
  const de_LimitExceededExceptionRes = async (parsedOutput, context) => {
3383
3302
  const contents = map({});
3384
3303
  const data = parsedOutput.body;
3385
- if (data.message != null) {
3386
- contents.message = __expectString(data.message);
3387
- }
3304
+ const doc = take(data, {
3305
+ message: __expectString,
3306
+ });
3307
+ Object.assign(contents, doc);
3388
3308
  const exception = new LimitExceededException({
3389
3309
  $metadata: deserializeMetadata(parsedOutput),
3390
3310
  ...contents,
@@ -3394,9 +3314,10 @@ const de_LimitExceededExceptionRes = async (parsedOutput, context) => {
3394
3314
  const de_ResourceAlreadyExistsExceptionRes = async (parsedOutput, context) => {
3395
3315
  const contents = map({});
3396
3316
  const data = parsedOutput.body;
3397
- if (data.message != null) {
3398
- contents.message = __expectString(data.message);
3399
- }
3317
+ const doc = take(data, {
3318
+ message: __expectString,
3319
+ });
3320
+ Object.assign(contents, doc);
3400
3321
  const exception = new ResourceAlreadyExistsException({
3401
3322
  $metadata: deserializeMetadata(parsedOutput),
3402
3323
  ...contents,
@@ -3406,9 +3327,10 @@ const de_ResourceAlreadyExistsExceptionRes = async (parsedOutput, context) => {
3406
3327
  const de_ResourceNotFoundExceptionRes = async (parsedOutput, context) => {
3407
3328
  const contents = map({});
3408
3329
  const data = parsedOutput.body;
3409
- if (data.message != null) {
3410
- contents.message = __expectString(data.message);
3411
- }
3330
+ const doc = take(data, {
3331
+ message: __expectString,
3332
+ });
3333
+ Object.assign(contents, doc);
3412
3334
  const exception = new ResourceNotFoundException({
3413
3335
  $metadata: deserializeMetadata(parsedOutput),
3414
3336
  ...contents,
@@ -3418,45 +3340,22 @@ const de_ResourceNotFoundExceptionRes = async (parsedOutput, context) => {
3418
3340
  const de_ValidationExceptionRes = async (parsedOutput, context) => {
3419
3341
  const contents = map({});
3420
3342
  const data = parsedOutput.body;
3421
- if (data.message != null) {
3422
- contents.message = __expectString(data.message);
3423
- }
3343
+ const doc = take(data, {
3344
+ message: __expectString,
3345
+ });
3346
+ Object.assign(contents, doc);
3424
3347
  const exception = new ValidationException({
3425
3348
  $metadata: deserializeMetadata(parsedOutput),
3426
3349
  ...contents,
3427
3350
  });
3428
3351
  return __decorateServiceException(exception, parsedOutput.body);
3429
3352
  };
3430
- const se_AdvancedOptions = (input, context) => {
3431
- return Object.entries(input).reduce((acc, [key, value]) => {
3432
- if (value === null) {
3433
- return acc;
3434
- }
3435
- acc[key] = value;
3436
- return acc;
3437
- }, {});
3438
- };
3439
- const se_AdvancedSecurityOptionsInput = (input, context) => {
3440
- return {
3441
- ...(input.AnonymousAuthEnabled != null && { AnonymousAuthEnabled: input.AnonymousAuthEnabled }),
3442
- ...(input.Enabled != null && { Enabled: input.Enabled }),
3443
- ...(input.InternalUserDatabaseEnabled != null && {
3444
- InternalUserDatabaseEnabled: input.InternalUserDatabaseEnabled,
3445
- }),
3446
- ...(input.MasterUserOptions != null && {
3447
- MasterUserOptions: se_MasterUserOptions(input.MasterUserOptions, context),
3448
- }),
3449
- ...(input.SAMLOptions != null && { SAMLOptions: se_SAMLOptionsInput(input.SAMLOptions, context) }),
3450
- };
3451
- };
3452
3353
  const se_AutoTuneMaintenanceSchedule = (input, context) => {
3453
- return {
3454
- ...(input.CronExpressionForRecurrence != null && {
3455
- CronExpressionForRecurrence: input.CronExpressionForRecurrence,
3456
- }),
3457
- ...(input.Duration != null && { Duration: se_Duration(input.Duration, context) }),
3458
- ...(input.StartAt != null && { StartAt: Math.round(input.StartAt.getTime() / 1000) }),
3459
- };
3354
+ return take(input, {
3355
+ CronExpressionForRecurrence: [],
3356
+ Duration: _json,
3357
+ StartAt: (_) => Math.round(_.getTime() / 1000),
3358
+ });
3460
3359
  };
3461
3360
  const se_AutoTuneMaintenanceScheduleList = (input, context) => {
3462
3361
  return input
@@ -3466,1199 +3365,421 @@ const se_AutoTuneMaintenanceScheduleList = (input, context) => {
3466
3365
  });
3467
3366
  };
3468
3367
  const se_AutoTuneOptions = (input, context) => {
3469
- return {
3470
- ...(input.DesiredState != null && { DesiredState: input.DesiredState }),
3471
- ...(input.MaintenanceSchedules != null && {
3472
- MaintenanceSchedules: se_AutoTuneMaintenanceScheduleList(input.MaintenanceSchedules, context),
3473
- }),
3474
- ...(input.RollbackOnDisable != null && { RollbackOnDisable: input.RollbackOnDisable }),
3475
- };
3476
- };
3477
- const se_AutoTuneOptionsInput = (input, context) => {
3478
- return {
3479
- ...(input.DesiredState != null && { DesiredState: input.DesiredState }),
3480
- ...(input.MaintenanceSchedules != null && {
3481
- MaintenanceSchedules: se_AutoTuneMaintenanceScheduleList(input.MaintenanceSchedules, context),
3482
- }),
3483
- };
3484
- };
3485
- const se_CognitoOptions = (input, context) => {
3486
- return {
3487
- ...(input.Enabled != null && { Enabled: input.Enabled }),
3488
- ...(input.IdentityPoolId != null && { IdentityPoolId: input.IdentityPoolId }),
3489
- ...(input.RoleArn != null && { RoleArn: input.RoleArn }),
3490
- ...(input.UserPoolId != null && { UserPoolId: input.UserPoolId }),
3491
- };
3492
- };
3493
- const se_ColdStorageOptions = (input, context) => {
3494
- return {
3495
- ...(input.Enabled != null && { Enabled: input.Enabled }),
3496
- };
3497
- };
3498
- const se_DescribePackagesFilter = (input, context) => {
3499
- return {
3500
- ...(input.Name != null && { Name: input.Name }),
3501
- ...(input.Value != null && { Value: se_DescribePackagesFilterValues(input.Value, context) }),
3502
- };
3503
- };
3504
- const se_DescribePackagesFilterList = (input, context) => {
3505
- return input
3506
- .filter((e) => e != null)
3507
- .map((entry) => {
3508
- return se_DescribePackagesFilter(entry, context);
3509
- });
3510
- };
3511
- const se_DescribePackagesFilterValues = (input, context) => {
3512
- return input
3513
- .filter((e) => e != null)
3514
- .map((entry) => {
3515
- return entry;
3516
- });
3517
- };
3518
- const se_DomainEndpointOptions = (input, context) => {
3519
- return {
3520
- ...(input.CustomEndpoint != null && { CustomEndpoint: input.CustomEndpoint }),
3521
- ...(input.CustomEndpointCertificateArn != null && {
3522
- CustomEndpointCertificateArn: input.CustomEndpointCertificateArn,
3523
- }),
3524
- ...(input.CustomEndpointEnabled != null && { CustomEndpointEnabled: input.CustomEndpointEnabled }),
3525
- ...(input.EnforceHTTPS != null && { EnforceHTTPS: input.EnforceHTTPS }),
3526
- ...(input.TLSSecurityPolicy != null && { TLSSecurityPolicy: input.TLSSecurityPolicy }),
3527
- };
3528
- };
3529
- const se_DomainInformation = (input, context) => {
3530
- return {
3531
- ...(input.DomainName != null && { DomainName: input.DomainName }),
3532
- ...(input.OwnerId != null && { OwnerId: input.OwnerId }),
3533
- ...(input.Region != null && { Region: input.Region }),
3534
- };
3535
- };
3536
- const se_DomainNameList = (input, context) => {
3537
- return input
3538
- .filter((e) => e != null)
3539
- .map((entry) => {
3540
- return entry;
3541
- });
3542
- };
3543
- const se_Duration = (input, context) => {
3544
- return {
3545
- ...(input.Unit != null && { Unit: input.Unit }),
3546
- ...(input.Value != null && { Value: input.Value }),
3547
- };
3548
- };
3549
- const se_EBSOptions = (input, context) => {
3550
- return {
3551
- ...(input.EBSEnabled != null && { EBSEnabled: input.EBSEnabled }),
3552
- ...(input.Iops != null && { Iops: input.Iops }),
3553
- ...(input.Throughput != null && { Throughput: input.Throughput }),
3554
- ...(input.VolumeSize != null && { VolumeSize: input.VolumeSize }),
3555
- ...(input.VolumeType != null && { VolumeType: input.VolumeType }),
3556
- };
3557
- };
3558
- const se_ElasticsearchClusterConfig = (input, context) => {
3559
- return {
3560
- ...(input.ColdStorageOptions != null && {
3561
- ColdStorageOptions: se_ColdStorageOptions(input.ColdStorageOptions, context),
3562
- }),
3563
- ...(input.DedicatedMasterCount != null && { DedicatedMasterCount: input.DedicatedMasterCount }),
3564
- ...(input.DedicatedMasterEnabled != null && { DedicatedMasterEnabled: input.DedicatedMasterEnabled }),
3565
- ...(input.DedicatedMasterType != null && { DedicatedMasterType: input.DedicatedMasterType }),
3566
- ...(input.InstanceCount != null && { InstanceCount: input.InstanceCount }),
3567
- ...(input.InstanceType != null && { InstanceType: input.InstanceType }),
3568
- ...(input.WarmCount != null && { WarmCount: input.WarmCount }),
3569
- ...(input.WarmEnabled != null && { WarmEnabled: input.WarmEnabled }),
3570
- ...(input.WarmType != null && { WarmType: input.WarmType }),
3571
- ...(input.ZoneAwarenessConfig != null && {
3572
- ZoneAwarenessConfig: se_ZoneAwarenessConfig(input.ZoneAwarenessConfig, context),
3573
- }),
3574
- ...(input.ZoneAwarenessEnabled != null && { ZoneAwarenessEnabled: input.ZoneAwarenessEnabled }),
3575
- };
3576
- };
3577
- const se_EncryptionAtRestOptions = (input, context) => {
3578
- return {
3579
- ...(input.Enabled != null && { Enabled: input.Enabled }),
3580
- ...(input.KmsKeyId != null && { KmsKeyId: input.KmsKeyId }),
3581
- };
3582
- };
3583
- const se_Filter = (input, context) => {
3584
- return {
3585
- ...(input.Name != null && { Name: input.Name }),
3586
- ...(input.Values != null && { Values: se_ValueStringList(input.Values, context) }),
3587
- };
3588
- };
3589
- const se_FilterList = (input, context) => {
3590
- return input
3591
- .filter((e) => e != null)
3592
- .map((entry) => {
3593
- return se_Filter(entry, context);
3594
- });
3595
- };
3596
- const se_LogPublishingOption = (input, context) => {
3597
- return {
3598
- ...(input.CloudWatchLogsLogGroupArn != null && { CloudWatchLogsLogGroupArn: input.CloudWatchLogsLogGroupArn }),
3599
- ...(input.Enabled != null && { Enabled: input.Enabled }),
3600
- };
3601
- };
3602
- const se_LogPublishingOptions = (input, context) => {
3603
- return Object.entries(input).reduce((acc, [key, value]) => {
3604
- if (value === null) {
3605
- return acc;
3606
- }
3607
- acc[key] = se_LogPublishingOption(value, context);
3608
- return acc;
3609
- }, {});
3610
- };
3611
- const se_MasterUserOptions = (input, context) => {
3612
- return {
3613
- ...(input.MasterUserARN != null && { MasterUserARN: input.MasterUserARN }),
3614
- ...(input.MasterUserName != null && { MasterUserName: input.MasterUserName }),
3615
- ...(input.MasterUserPassword != null && { MasterUserPassword: input.MasterUserPassword }),
3616
- };
3617
- };
3618
- const se_NodeToNodeEncryptionOptions = (input, context) => {
3619
- return {
3620
- ...(input.Enabled != null && { Enabled: input.Enabled }),
3621
- };
3622
- };
3623
- const se_PackageSource = (input, context) => {
3624
- return {
3625
- ...(input.S3BucketName != null && { S3BucketName: input.S3BucketName }),
3626
- ...(input.S3Key != null && { S3Key: input.S3Key }),
3627
- };
3628
- };
3629
- const se_SAMLIdp = (input, context) => {
3630
- return {
3631
- ...(input.EntityId != null && { EntityId: input.EntityId }),
3632
- ...(input.MetadataContent != null && { MetadataContent: input.MetadataContent }),
3633
- };
3634
- };
3635
- const se_SAMLOptionsInput = (input, context) => {
3636
- return {
3637
- ...(input.Enabled != null && { Enabled: input.Enabled }),
3638
- ...(input.Idp != null && { Idp: se_SAMLIdp(input.Idp, context) }),
3639
- ...(input.MasterBackendRole != null && { MasterBackendRole: input.MasterBackendRole }),
3640
- ...(input.MasterUserName != null && { MasterUserName: input.MasterUserName }),
3641
- ...(input.RolesKey != null && { RolesKey: input.RolesKey }),
3642
- ...(input.SessionTimeoutMinutes != null && { SessionTimeoutMinutes: input.SessionTimeoutMinutes }),
3643
- ...(input.SubjectKey != null && { SubjectKey: input.SubjectKey }),
3644
- };
3645
- };
3646
- const se_SnapshotOptions = (input, context) => {
3647
- return {
3648
- ...(input.AutomatedSnapshotStartHour != null && { AutomatedSnapshotStartHour: input.AutomatedSnapshotStartHour }),
3649
- };
3650
- };
3651
- const se_StringList = (input, context) => {
3652
- return input
3653
- .filter((e) => e != null)
3654
- .map((entry) => {
3655
- return entry;
3656
- });
3657
- };
3658
- const se_Tag = (input, context) => {
3659
- return {
3660
- ...(input.Key != null && { Key: input.Key }),
3661
- ...(input.Value != null && { Value: input.Value }),
3662
- };
3663
- };
3664
- const se_TagList = (input, context) => {
3665
- return input
3666
- .filter((e) => e != null)
3667
- .map((entry) => {
3668
- return se_Tag(entry, context);
3669
- });
3670
- };
3671
- const se_ValueStringList = (input, context) => {
3672
- return input
3673
- .filter((e) => e != null)
3674
- .map((entry) => {
3675
- return entry;
3368
+ return take(input, {
3369
+ DesiredState: [],
3370
+ MaintenanceSchedules: (_) => se_AutoTuneMaintenanceScheduleList(_, context),
3371
+ RollbackOnDisable: [],
3676
3372
  });
3677
3373
  };
3678
- const se_VpcEndpointIdList = (input, context) => {
3679
- return input
3680
- .filter((e) => e != null)
3681
- .map((entry) => {
3682
- return entry;
3374
+ const se_AutoTuneOptionsInput = (input, context) => {
3375
+ return take(input, {
3376
+ DesiredState: [],
3377
+ MaintenanceSchedules: (_) => se_AutoTuneMaintenanceScheduleList(_, context),
3683
3378
  });
3684
3379
  };
3685
- const se_VPCOptions = (input, context) => {
3686
- return {
3687
- ...(input.SecurityGroupIds != null && { SecurityGroupIds: se_StringList(input.SecurityGroupIds, context) }),
3688
- ...(input.SubnetIds != null && { SubnetIds: se_StringList(input.SubnetIds, context) }),
3689
- };
3690
- };
3691
- const se_ZoneAwarenessConfig = (input, context) => {
3692
- return {
3693
- ...(input.AvailabilityZoneCount != null && { AvailabilityZoneCount: input.AvailabilityZoneCount }),
3694
- };
3695
- };
3696
3380
  const de_AccessPoliciesStatus = (output, context) => {
3697
- return {
3698
- Options: __expectString(output.Options),
3699
- Status: output.Status != null ? de_OptionStatus(output.Status, context) : undefined,
3700
- };
3701
- };
3702
- const de_AdditionalLimit = (output, context) => {
3703
- return {
3704
- LimitName: __expectString(output.LimitName),
3705
- LimitValues: output.LimitValues != null ? de_LimitValueList(output.LimitValues, context) : undefined,
3706
- };
3707
- };
3708
- const de_AdditionalLimitList = (output, context) => {
3709
- const retVal = (output || [])
3710
- .filter((e) => e != null)
3711
- .map((entry) => {
3712
- if (entry === null) {
3713
- return null;
3714
- }
3715
- return de_AdditionalLimit(entry, context);
3381
+ return take(output, {
3382
+ Options: __expectString,
3383
+ Status: (_) => de_OptionStatus(_, context),
3716
3384
  });
3717
- return retVal;
3718
- };
3719
- const de_AdvancedOptions = (output, context) => {
3720
- return Object.entries(output).reduce((acc, [key, value]) => {
3721
- if (value === null) {
3722
- return acc;
3723
- }
3724
- acc[key] = __expectString(value);
3725
- return acc;
3726
- }, {});
3727
3385
  };
3728
3386
  const de_AdvancedOptionsStatus = (output, context) => {
3729
- return {
3730
- Options: output.Options != null ? de_AdvancedOptions(output.Options, context) : undefined,
3731
- Status: output.Status != null ? de_OptionStatus(output.Status, context) : undefined,
3732
- };
3387
+ return take(output, {
3388
+ Options: _json,
3389
+ Status: (_) => de_OptionStatus(_, context),
3390
+ });
3733
3391
  };
3734
3392
  const de_AdvancedSecurityOptions = (output, context) => {
3735
- return {
3736
- AnonymousAuthDisableDate: output.AnonymousAuthDisableDate != null
3737
- ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.AnonymousAuthDisableDate)))
3738
- : undefined,
3739
- AnonymousAuthEnabled: __expectBoolean(output.AnonymousAuthEnabled),
3740
- Enabled: __expectBoolean(output.Enabled),
3741
- InternalUserDatabaseEnabled: __expectBoolean(output.InternalUserDatabaseEnabled),
3742
- SAMLOptions: output.SAMLOptions != null ? de_SAMLOptionsOutput(output.SAMLOptions, context) : undefined,
3743
- };
3393
+ return take(output, {
3394
+ AnonymousAuthDisableDate: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
3395
+ AnonymousAuthEnabled: __expectBoolean,
3396
+ Enabled: __expectBoolean,
3397
+ InternalUserDatabaseEnabled: __expectBoolean,
3398
+ SAMLOptions: _json,
3399
+ });
3744
3400
  };
3745
3401
  const de_AdvancedSecurityOptionsStatus = (output, context) => {
3746
- return {
3747
- Options: output.Options != null ? de_AdvancedSecurityOptions(output.Options, context) : undefined,
3748
- Status: output.Status != null ? de_OptionStatus(output.Status, context) : undefined,
3749
- };
3750
- };
3751
- const de_AuthorizedPrincipal = (output, context) => {
3752
- return {
3753
- Principal: __expectString(output.Principal),
3754
- PrincipalType: __expectString(output.PrincipalType),
3755
- };
3756
- };
3757
- const de_AuthorizedPrincipalList = (output, context) => {
3758
- const retVal = (output || [])
3759
- .filter((e) => e != null)
3760
- .map((entry) => {
3761
- if (entry === null) {
3762
- return null;
3763
- }
3764
- return de_AuthorizedPrincipal(entry, context);
3402
+ return take(output, {
3403
+ Options: (_) => de_AdvancedSecurityOptions(_, context),
3404
+ Status: (_) => de_OptionStatus(_, context),
3765
3405
  });
3766
- return retVal;
3767
3406
  };
3768
3407
  const de_AutoTune = (output, context) => {
3769
- return {
3770
- AutoTuneDetails: output.AutoTuneDetails != null ? de_AutoTuneDetails(output.AutoTuneDetails, context) : undefined,
3771
- AutoTuneType: __expectString(output.AutoTuneType),
3772
- };
3408
+ return take(output, {
3409
+ AutoTuneDetails: (_) => de_AutoTuneDetails(_, context),
3410
+ AutoTuneType: __expectString,
3411
+ });
3773
3412
  };
3774
3413
  const de_AutoTuneDetails = (output, context) => {
3775
- return {
3776
- ScheduledAutoTuneDetails: output.ScheduledAutoTuneDetails != null
3777
- ? de_ScheduledAutoTuneDetails(output.ScheduledAutoTuneDetails, context)
3778
- : undefined,
3779
- };
3414
+ return take(output, {
3415
+ ScheduledAutoTuneDetails: (_) => de_ScheduledAutoTuneDetails(_, context),
3416
+ });
3780
3417
  };
3781
3418
  const de_AutoTuneList = (output, context) => {
3782
3419
  const retVal = (output || [])
3783
3420
  .filter((e) => e != null)
3784
3421
  .map((entry) => {
3785
- if (entry === null) {
3786
- return null;
3787
- }
3788
3422
  return de_AutoTune(entry, context);
3789
3423
  });
3790
3424
  return retVal;
3791
3425
  };
3792
3426
  const de_AutoTuneMaintenanceSchedule = (output, context) => {
3793
- return {
3794
- CronExpressionForRecurrence: __expectString(output.CronExpressionForRecurrence),
3795
- Duration: output.Duration != null ? de_Duration(output.Duration, context) : undefined,
3796
- StartAt: output.StartAt != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.StartAt))) : undefined,
3797
- };
3427
+ return take(output, {
3428
+ CronExpressionForRecurrence: __expectString,
3429
+ Duration: _json,
3430
+ StartAt: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
3431
+ });
3798
3432
  };
3799
3433
  const de_AutoTuneMaintenanceScheduleList = (output, context) => {
3800
3434
  const retVal = (output || [])
3801
3435
  .filter((e) => e != null)
3802
3436
  .map((entry) => {
3803
- if (entry === null) {
3804
- return null;
3805
- }
3806
3437
  return de_AutoTuneMaintenanceSchedule(entry, context);
3807
3438
  });
3808
3439
  return retVal;
3809
3440
  };
3810
3441
  const de_AutoTuneOptions = (output, context) => {
3811
- return {
3812
- DesiredState: __expectString(output.DesiredState),
3813
- MaintenanceSchedules: output.MaintenanceSchedules != null
3814
- ? de_AutoTuneMaintenanceScheduleList(output.MaintenanceSchedules, context)
3815
- : undefined,
3816
- RollbackOnDisable: __expectString(output.RollbackOnDisable),
3817
- };
3818
- };
3819
- const de_AutoTuneOptionsOutput = (output, context) => {
3820
- return {
3821
- ErrorMessage: __expectString(output.ErrorMessage),
3822
- State: __expectString(output.State),
3823
- };
3442
+ return take(output, {
3443
+ DesiredState: __expectString,
3444
+ MaintenanceSchedules: (_) => de_AutoTuneMaintenanceScheduleList(_, context),
3445
+ RollbackOnDisable: __expectString,
3446
+ });
3824
3447
  };
3825
3448
  const de_AutoTuneOptionsStatus = (output, context) => {
3826
- return {
3827
- Options: output.Options != null ? de_AutoTuneOptions(output.Options, context) : undefined,
3828
- Status: output.Status != null ? de_AutoTuneStatus(output.Status, context) : undefined,
3829
- };
3449
+ return take(output, {
3450
+ Options: (_) => de_AutoTuneOptions(_, context),
3451
+ Status: (_) => de_AutoTuneStatus(_, context),
3452
+ });
3830
3453
  };
3831
3454
  const de_AutoTuneStatus = (output, context) => {
3832
- return {
3833
- CreationDate: output.CreationDate != null
3834
- ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.CreationDate)))
3835
- : undefined,
3836
- ErrorMessage: __expectString(output.ErrorMessage),
3837
- PendingDeletion: __expectBoolean(output.PendingDeletion),
3838
- State: __expectString(output.State),
3839
- UpdateDate: output.UpdateDate != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.UpdateDate))) : undefined,
3840
- UpdateVersion: __expectInt32(output.UpdateVersion),
3841
- };
3842
- };
3843
- const de_ChangeProgressDetails = (output, context) => {
3844
- return {
3845
- ChangeId: __expectString(output.ChangeId),
3846
- Message: __expectString(output.Message),
3847
- };
3455
+ return take(output, {
3456
+ CreationDate: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
3457
+ ErrorMessage: __expectString,
3458
+ PendingDeletion: __expectBoolean,
3459
+ State: __expectString,
3460
+ UpdateDate: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
3461
+ UpdateVersion: __expectInt32,
3462
+ });
3848
3463
  };
3849
3464
  const de_ChangeProgressStage = (output, context) => {
3850
- return {
3851
- Description: __expectString(output.Description),
3852
- LastUpdated: output.LastUpdated != null
3853
- ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.LastUpdated)))
3854
- : undefined,
3855
- Name: __expectString(output.Name),
3856
- Status: __expectString(output.Status),
3857
- };
3465
+ return take(output, {
3466
+ Description: __expectString,
3467
+ LastUpdated: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
3468
+ Name: __expectString,
3469
+ Status: __expectString,
3470
+ });
3858
3471
  };
3859
3472
  const de_ChangeProgressStageList = (output, context) => {
3860
3473
  const retVal = (output || [])
3861
3474
  .filter((e) => e != null)
3862
3475
  .map((entry) => {
3863
- if (entry === null) {
3864
- return null;
3865
- }
3866
3476
  return de_ChangeProgressStage(entry, context);
3867
3477
  });
3868
3478
  return retVal;
3869
3479
  };
3870
3480
  const de_ChangeProgressStatusDetails = (output, context) => {
3871
- return {
3872
- ChangeId: __expectString(output.ChangeId),
3873
- ChangeProgressStages: output.ChangeProgressStages != null
3874
- ? de_ChangeProgressStageList(output.ChangeProgressStages, context)
3875
- : undefined,
3876
- CompletedProperties: output.CompletedProperties != null ? de_StringList(output.CompletedProperties, context) : undefined,
3877
- PendingProperties: output.PendingProperties != null ? de_StringList(output.PendingProperties, context) : undefined,
3878
- StartTime: output.StartTime != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.StartTime))) : undefined,
3879
- Status: __expectString(output.Status),
3880
- TotalNumberOfStages: __expectInt32(output.TotalNumberOfStages),
3881
- };
3882
- };
3883
- const de_CognitoOptions = (output, context) => {
3884
- return {
3885
- Enabled: __expectBoolean(output.Enabled),
3886
- IdentityPoolId: __expectString(output.IdentityPoolId),
3887
- RoleArn: __expectString(output.RoleArn),
3888
- UserPoolId: __expectString(output.UserPoolId),
3889
- };
3481
+ return take(output, {
3482
+ ChangeId: __expectString,
3483
+ ChangeProgressStages: (_) => de_ChangeProgressStageList(_, context),
3484
+ CompletedProperties: _json,
3485
+ PendingProperties: _json,
3486
+ StartTime: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
3487
+ Status: __expectString,
3488
+ TotalNumberOfStages: __expectInt32,
3489
+ });
3890
3490
  };
3891
3491
  const de_CognitoOptionsStatus = (output, context) => {
3892
- return {
3893
- Options: output.Options != null ? de_CognitoOptions(output.Options, context) : undefined,
3894
- Status: output.Status != null ? de_OptionStatus(output.Status, context) : undefined,
3895
- };
3896
- };
3897
- const de_ColdStorageOptions = (output, context) => {
3898
- return {
3899
- Enabled: __expectBoolean(output.Enabled),
3900
- };
3901
- };
3902
- const de_CompatibleElasticsearchVersionsList = (output, context) => {
3903
- const retVal = (output || [])
3904
- .filter((e) => e != null)
3905
- .map((entry) => {
3906
- if (entry === null) {
3907
- return null;
3908
- }
3909
- return de_CompatibleVersionsMap(entry, context);
3492
+ return take(output, {
3493
+ Options: _json,
3494
+ Status: (_) => de_OptionStatus(_, context),
3910
3495
  });
3911
- return retVal;
3912
- };
3913
- const de_CompatibleVersionsMap = (output, context) => {
3914
- return {
3915
- SourceVersion: __expectString(output.SourceVersion),
3916
- TargetVersions: output.TargetVersions != null ? de_ElasticsearchVersionList(output.TargetVersions, context) : undefined,
3917
- };
3918
- };
3919
- const de_DomainEndpointOptions = (output, context) => {
3920
- return {
3921
- CustomEndpoint: __expectString(output.CustomEndpoint),
3922
- CustomEndpointCertificateArn: __expectString(output.CustomEndpointCertificateArn),
3923
- CustomEndpointEnabled: __expectBoolean(output.CustomEndpointEnabled),
3924
- EnforceHTTPS: __expectBoolean(output.EnforceHTTPS),
3925
- TLSSecurityPolicy: __expectString(output.TLSSecurityPolicy),
3926
- };
3927
3496
  };
3928
3497
  const de_DomainEndpointOptionsStatus = (output, context) => {
3929
- return {
3930
- Options: output.Options != null ? de_DomainEndpointOptions(output.Options, context) : undefined,
3931
- Status: output.Status != null ? de_OptionStatus(output.Status, context) : undefined,
3932
- };
3933
- };
3934
- const de_DomainInfo = (output, context) => {
3935
- return {
3936
- DomainName: __expectString(output.DomainName),
3937
- EngineType: __expectString(output.EngineType),
3938
- };
3939
- };
3940
- const de_DomainInfoList = (output, context) => {
3941
- const retVal = (output || [])
3942
- .filter((e) => e != null)
3943
- .map((entry) => {
3944
- if (entry === null) {
3945
- return null;
3946
- }
3947
- return de_DomainInfo(entry, context);
3498
+ return take(output, {
3499
+ Options: _json,
3500
+ Status: (_) => de_OptionStatus(_, context),
3948
3501
  });
3949
- return retVal;
3950
- };
3951
- const de_DomainInformation = (output, context) => {
3952
- return {
3953
- DomainName: __expectString(output.DomainName),
3954
- OwnerId: __expectString(output.OwnerId),
3955
- Region: __expectString(output.Region),
3956
- };
3957
3502
  };
3958
3503
  const de_DomainPackageDetails = (output, context) => {
3959
- return {
3960
- DomainName: __expectString(output.DomainName),
3961
- DomainPackageStatus: __expectString(output.DomainPackageStatus),
3962
- ErrorDetails: output.ErrorDetails != null ? de_ErrorDetails(output.ErrorDetails, context) : undefined,
3963
- LastUpdated: output.LastUpdated != null
3964
- ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.LastUpdated)))
3965
- : undefined,
3966
- PackageID: __expectString(output.PackageID),
3967
- PackageName: __expectString(output.PackageName),
3968
- PackageType: __expectString(output.PackageType),
3969
- PackageVersion: __expectString(output.PackageVersion),
3970
- ReferencePath: __expectString(output.ReferencePath),
3971
- };
3504
+ return take(output, {
3505
+ DomainName: __expectString,
3506
+ DomainPackageStatus: __expectString,
3507
+ ErrorDetails: _json,
3508
+ LastUpdated: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
3509
+ PackageID: __expectString,
3510
+ PackageName: __expectString,
3511
+ PackageType: __expectString,
3512
+ PackageVersion: __expectString,
3513
+ ReferencePath: __expectString,
3514
+ });
3972
3515
  };
3973
3516
  const de_DomainPackageDetailsList = (output, context) => {
3974
3517
  const retVal = (output || [])
3975
3518
  .filter((e) => e != null)
3976
3519
  .map((entry) => {
3977
- if (entry === null) {
3978
- return null;
3979
- }
3980
3520
  return de_DomainPackageDetails(entry, context);
3981
3521
  });
3982
3522
  return retVal;
3983
3523
  };
3984
- const de_DryRunResults = (output, context) => {
3985
- return {
3986
- DeploymentType: __expectString(output.DeploymentType),
3987
- Message: __expectString(output.Message),
3988
- };
3989
- };
3990
- const de_Duration = (output, context) => {
3991
- return {
3992
- Unit: __expectString(output.Unit),
3993
- Value: __expectLong(output.Value),
3994
- };
3995
- };
3996
- const de_EBSOptions = (output, context) => {
3997
- return {
3998
- EBSEnabled: __expectBoolean(output.EBSEnabled),
3999
- Iops: __expectInt32(output.Iops),
4000
- Throughput: __expectInt32(output.Throughput),
4001
- VolumeSize: __expectInt32(output.VolumeSize),
4002
- VolumeType: __expectString(output.VolumeType),
4003
- };
4004
- };
4005
3524
  const de_EBSOptionsStatus = (output, context) => {
4006
- return {
4007
- Options: output.Options != null ? de_EBSOptions(output.Options, context) : undefined,
4008
- Status: output.Status != null ? de_OptionStatus(output.Status, context) : undefined,
4009
- };
4010
- };
4011
- const de_ElasticsearchClusterConfig = (output, context) => {
4012
- return {
4013
- ColdStorageOptions: output.ColdStorageOptions != null ? de_ColdStorageOptions(output.ColdStorageOptions, context) : undefined,
4014
- DedicatedMasterCount: __expectInt32(output.DedicatedMasterCount),
4015
- DedicatedMasterEnabled: __expectBoolean(output.DedicatedMasterEnabled),
4016
- DedicatedMasterType: __expectString(output.DedicatedMasterType),
4017
- InstanceCount: __expectInt32(output.InstanceCount),
4018
- InstanceType: __expectString(output.InstanceType),
4019
- WarmCount: __expectInt32(output.WarmCount),
4020
- WarmEnabled: __expectBoolean(output.WarmEnabled),
4021
- WarmType: __expectString(output.WarmType),
4022
- ZoneAwarenessConfig: output.ZoneAwarenessConfig != null ? de_ZoneAwarenessConfig(output.ZoneAwarenessConfig, context) : undefined,
4023
- ZoneAwarenessEnabled: __expectBoolean(output.ZoneAwarenessEnabled),
4024
- };
3525
+ return take(output, {
3526
+ Options: _json,
3527
+ Status: (_) => de_OptionStatus(_, context),
3528
+ });
4025
3529
  };
4026
3530
  const de_ElasticsearchClusterConfigStatus = (output, context) => {
4027
- return {
4028
- Options: output.Options != null ? de_ElasticsearchClusterConfig(output.Options, context) : undefined,
4029
- Status: output.Status != null ? de_OptionStatus(output.Status, context) : undefined,
4030
- };
3531
+ return take(output, {
3532
+ Options: _json,
3533
+ Status: (_) => de_OptionStatus(_, context),
3534
+ });
4031
3535
  };
4032
3536
  const de_ElasticsearchDomainConfig = (output, context) => {
4033
- return {
4034
- AccessPolicies: output.AccessPolicies != null ? de_AccessPoliciesStatus(output.AccessPolicies, context) : undefined,
4035
- AdvancedOptions: output.AdvancedOptions != null ? de_AdvancedOptionsStatus(output.AdvancedOptions, context) : undefined,
4036
- AdvancedSecurityOptions: output.AdvancedSecurityOptions != null
4037
- ? de_AdvancedSecurityOptionsStatus(output.AdvancedSecurityOptions, context)
4038
- : undefined,
4039
- AutoTuneOptions: output.AutoTuneOptions != null ? de_AutoTuneOptionsStatus(output.AutoTuneOptions, context) : undefined,
4040
- ChangeProgressDetails: output.ChangeProgressDetails != null
4041
- ? de_ChangeProgressDetails(output.ChangeProgressDetails, context)
4042
- : undefined,
4043
- CognitoOptions: output.CognitoOptions != null ? de_CognitoOptionsStatus(output.CognitoOptions, context) : undefined,
4044
- DomainEndpointOptions: output.DomainEndpointOptions != null
4045
- ? de_DomainEndpointOptionsStatus(output.DomainEndpointOptions, context)
4046
- : undefined,
4047
- EBSOptions: output.EBSOptions != null ? de_EBSOptionsStatus(output.EBSOptions, context) : undefined,
4048
- ElasticsearchClusterConfig: output.ElasticsearchClusterConfig != null
4049
- ? de_ElasticsearchClusterConfigStatus(output.ElasticsearchClusterConfig, context)
4050
- : undefined,
4051
- ElasticsearchVersion: output.ElasticsearchVersion != null
4052
- ? de_ElasticsearchVersionStatus(output.ElasticsearchVersion, context)
4053
- : undefined,
4054
- EncryptionAtRestOptions: output.EncryptionAtRestOptions != null
4055
- ? de_EncryptionAtRestOptionsStatus(output.EncryptionAtRestOptions, context)
4056
- : undefined,
4057
- LogPublishingOptions: output.LogPublishingOptions != null
4058
- ? de_LogPublishingOptionsStatus(output.LogPublishingOptions, context)
4059
- : undefined,
4060
- NodeToNodeEncryptionOptions: output.NodeToNodeEncryptionOptions != null
4061
- ? de_NodeToNodeEncryptionOptionsStatus(output.NodeToNodeEncryptionOptions, context)
4062
- : undefined,
4063
- SnapshotOptions: output.SnapshotOptions != null ? de_SnapshotOptionsStatus(output.SnapshotOptions, context) : undefined,
4064
- VPCOptions: output.VPCOptions != null ? de_VPCDerivedInfoStatus(output.VPCOptions, context) : undefined,
4065
- };
3537
+ return take(output, {
3538
+ AccessPolicies: (_) => de_AccessPoliciesStatus(_, context),
3539
+ AdvancedOptions: (_) => de_AdvancedOptionsStatus(_, context),
3540
+ AdvancedSecurityOptions: (_) => de_AdvancedSecurityOptionsStatus(_, context),
3541
+ AutoTuneOptions: (_) => de_AutoTuneOptionsStatus(_, context),
3542
+ ChangeProgressDetails: _json,
3543
+ CognitoOptions: (_) => de_CognitoOptionsStatus(_, context),
3544
+ DomainEndpointOptions: (_) => de_DomainEndpointOptionsStatus(_, context),
3545
+ EBSOptions: (_) => de_EBSOptionsStatus(_, context),
3546
+ ElasticsearchClusterConfig: (_) => de_ElasticsearchClusterConfigStatus(_, context),
3547
+ ElasticsearchVersion: (_) => de_ElasticsearchVersionStatus(_, context),
3548
+ EncryptionAtRestOptions: (_) => de_EncryptionAtRestOptionsStatus(_, context),
3549
+ LogPublishingOptions: (_) => de_LogPublishingOptionsStatus(_, context),
3550
+ NodeToNodeEncryptionOptions: (_) => de_NodeToNodeEncryptionOptionsStatus(_, context),
3551
+ SnapshotOptions: (_) => de_SnapshotOptionsStatus(_, context),
3552
+ VPCOptions: (_) => de_VPCDerivedInfoStatus(_, context),
3553
+ });
4066
3554
  };
4067
3555
  const de_ElasticsearchDomainStatus = (output, context) => {
4068
- return {
4069
- ARN: __expectString(output.ARN),
4070
- AccessPolicies: __expectString(output.AccessPolicies),
4071
- AdvancedOptions: output.AdvancedOptions != null ? de_AdvancedOptions(output.AdvancedOptions, context) : undefined,
4072
- AdvancedSecurityOptions: output.AdvancedSecurityOptions != null
4073
- ? de_AdvancedSecurityOptions(output.AdvancedSecurityOptions, context)
4074
- : undefined,
4075
- AutoTuneOptions: output.AutoTuneOptions != null ? de_AutoTuneOptionsOutput(output.AutoTuneOptions, context) : undefined,
4076
- ChangeProgressDetails: output.ChangeProgressDetails != null
4077
- ? de_ChangeProgressDetails(output.ChangeProgressDetails, context)
4078
- : undefined,
4079
- CognitoOptions: output.CognitoOptions != null ? de_CognitoOptions(output.CognitoOptions, context) : undefined,
4080
- Created: __expectBoolean(output.Created),
4081
- Deleted: __expectBoolean(output.Deleted),
4082
- DomainEndpointOptions: output.DomainEndpointOptions != null
4083
- ? de_DomainEndpointOptions(output.DomainEndpointOptions, context)
4084
- : undefined,
4085
- DomainId: __expectString(output.DomainId),
4086
- DomainName: __expectString(output.DomainName),
4087
- EBSOptions: output.EBSOptions != null ? de_EBSOptions(output.EBSOptions, context) : undefined,
4088
- ElasticsearchClusterConfig: output.ElasticsearchClusterConfig != null
4089
- ? de_ElasticsearchClusterConfig(output.ElasticsearchClusterConfig, context)
4090
- : undefined,
4091
- ElasticsearchVersion: __expectString(output.ElasticsearchVersion),
4092
- EncryptionAtRestOptions: output.EncryptionAtRestOptions != null
4093
- ? de_EncryptionAtRestOptions(output.EncryptionAtRestOptions, context)
4094
- : undefined,
4095
- Endpoint: __expectString(output.Endpoint),
4096
- Endpoints: output.Endpoints != null ? de_EndpointsMap(output.Endpoints, context) : undefined,
4097
- LogPublishingOptions: output.LogPublishingOptions != null ? de_LogPublishingOptions(output.LogPublishingOptions, context) : undefined,
4098
- NodeToNodeEncryptionOptions: output.NodeToNodeEncryptionOptions != null
4099
- ? de_NodeToNodeEncryptionOptions(output.NodeToNodeEncryptionOptions, context)
4100
- : undefined,
4101
- Processing: __expectBoolean(output.Processing),
4102
- ServiceSoftwareOptions: output.ServiceSoftwareOptions != null
4103
- ? de_ServiceSoftwareOptions(output.ServiceSoftwareOptions, context)
4104
- : undefined,
4105
- SnapshotOptions: output.SnapshotOptions != null ? de_SnapshotOptions(output.SnapshotOptions, context) : undefined,
4106
- UpgradeProcessing: __expectBoolean(output.UpgradeProcessing),
4107
- VPCOptions: output.VPCOptions != null ? de_VPCDerivedInfo(output.VPCOptions, context) : undefined,
4108
- };
3556
+ return take(output, {
3557
+ ARN: __expectString,
3558
+ AccessPolicies: __expectString,
3559
+ AdvancedOptions: _json,
3560
+ AdvancedSecurityOptions: (_) => de_AdvancedSecurityOptions(_, context),
3561
+ AutoTuneOptions: _json,
3562
+ ChangeProgressDetails: _json,
3563
+ CognitoOptions: _json,
3564
+ Created: __expectBoolean,
3565
+ Deleted: __expectBoolean,
3566
+ DomainEndpointOptions: _json,
3567
+ DomainId: __expectString,
3568
+ DomainName: __expectString,
3569
+ EBSOptions: _json,
3570
+ ElasticsearchClusterConfig: _json,
3571
+ ElasticsearchVersion: __expectString,
3572
+ EncryptionAtRestOptions: _json,
3573
+ Endpoint: __expectString,
3574
+ Endpoints: _json,
3575
+ LogPublishingOptions: _json,
3576
+ NodeToNodeEncryptionOptions: _json,
3577
+ Processing: __expectBoolean,
3578
+ ServiceSoftwareOptions: (_) => de_ServiceSoftwareOptions(_, context),
3579
+ SnapshotOptions: _json,
3580
+ UpgradeProcessing: __expectBoolean,
3581
+ VPCOptions: _json,
3582
+ });
4109
3583
  };
4110
3584
  const de_ElasticsearchDomainStatusList = (output, context) => {
4111
3585
  const retVal = (output || [])
4112
3586
  .filter((e) => e != null)
4113
3587
  .map((entry) => {
4114
- if (entry === null) {
4115
- return null;
4116
- }
4117
3588
  return de_ElasticsearchDomainStatus(entry, context);
4118
3589
  });
4119
3590
  return retVal;
4120
3591
  };
4121
- const de_ElasticsearchInstanceTypeList = (output, context) => {
4122
- const retVal = (output || [])
4123
- .filter((e) => e != null)
4124
- .map((entry) => {
4125
- if (entry === null) {
4126
- return null;
4127
- }
4128
- return __expectString(entry);
4129
- });
4130
- return retVal;
4131
- };
4132
- const de_ElasticsearchVersionList = (output, context) => {
4133
- const retVal = (output || [])
4134
- .filter((e) => e != null)
4135
- .map((entry) => {
4136
- if (entry === null) {
4137
- return null;
4138
- }
4139
- return __expectString(entry);
4140
- });
4141
- return retVal;
4142
- };
4143
3592
  const de_ElasticsearchVersionStatus = (output, context) => {
4144
- return {
4145
- Options: __expectString(output.Options),
4146
- Status: output.Status != null ? de_OptionStatus(output.Status, context) : undefined,
4147
- };
4148
- };
4149
- const de_EncryptionAtRestOptions = (output, context) => {
4150
- return {
4151
- Enabled: __expectBoolean(output.Enabled),
4152
- KmsKeyId: __expectString(output.KmsKeyId),
4153
- };
4154
- };
4155
- const de_EncryptionAtRestOptionsStatus = (output, context) => {
4156
- return {
4157
- Options: output.Options != null ? de_EncryptionAtRestOptions(output.Options, context) : undefined,
4158
- Status: output.Status != null ? de_OptionStatus(output.Status, context) : undefined,
4159
- };
4160
- };
4161
- const de_EndpointsMap = (output, context) => {
4162
- return Object.entries(output).reduce((acc, [key, value]) => {
4163
- if (value === null) {
4164
- return acc;
4165
- }
4166
- acc[key] = __expectString(value);
4167
- return acc;
4168
- }, {});
4169
- };
4170
- const de_ErrorDetails = (output, context) => {
4171
- return {
4172
- ErrorMessage: __expectString(output.ErrorMessage),
4173
- ErrorType: __expectString(output.ErrorType),
4174
- };
4175
- };
4176
- const de_InboundCrossClusterSearchConnection = (output, context) => {
4177
- return {
4178
- ConnectionStatus: output.ConnectionStatus != null
4179
- ? de_InboundCrossClusterSearchConnectionStatus(output.ConnectionStatus, context)
4180
- : undefined,
4181
- CrossClusterSearchConnectionId: __expectString(output.CrossClusterSearchConnectionId),
4182
- DestinationDomainInfo: output.DestinationDomainInfo != null ? de_DomainInformation(output.DestinationDomainInfo, context) : undefined,
4183
- SourceDomainInfo: output.SourceDomainInfo != null ? de_DomainInformation(output.SourceDomainInfo, context) : undefined,
4184
- };
4185
- };
4186
- const de_InboundCrossClusterSearchConnections = (output, context) => {
4187
- const retVal = (output || [])
4188
- .filter((e) => e != null)
4189
- .map((entry) => {
4190
- if (entry === null) {
4191
- return null;
4192
- }
4193
- return de_InboundCrossClusterSearchConnection(entry, context);
4194
- });
4195
- return retVal;
4196
- };
4197
- const de_InboundCrossClusterSearchConnectionStatus = (output, context) => {
4198
- return {
4199
- Message: __expectString(output.Message),
4200
- StatusCode: __expectString(output.StatusCode),
4201
- };
4202
- };
4203
- const de_InstanceCountLimits = (output, context) => {
4204
- return {
4205
- MaximumInstanceCount: __expectInt32(output.MaximumInstanceCount),
4206
- MinimumInstanceCount: __expectInt32(output.MinimumInstanceCount),
4207
- };
4208
- };
4209
- const de_InstanceLimits = (output, context) => {
4210
- return {
4211
- InstanceCountLimits: output.InstanceCountLimits != null ? de_InstanceCountLimits(output.InstanceCountLimits, context) : undefined,
4212
- };
4213
- };
4214
- const de_Issues = (output, context) => {
4215
- const retVal = (output || [])
4216
- .filter((e) => e != null)
4217
- .map((entry) => {
4218
- if (entry === null) {
4219
- return null;
4220
- }
4221
- return __expectString(entry);
3593
+ return take(output, {
3594
+ Options: __expectString,
3595
+ Status: (_) => de_OptionStatus(_, context),
4222
3596
  });
4223
- return retVal;
4224
- };
4225
- const de_Limits = (output, context) => {
4226
- return {
4227
- AdditionalLimits: output.AdditionalLimits != null ? de_AdditionalLimitList(output.AdditionalLimits, context) : undefined,
4228
- InstanceLimits: output.InstanceLimits != null ? de_InstanceLimits(output.InstanceLimits, context) : undefined,
4229
- StorageTypes: output.StorageTypes != null ? de_StorageTypeList(output.StorageTypes, context) : undefined,
4230
- };
4231
- };
4232
- const de_LimitsByRole = (output, context) => {
4233
- return Object.entries(output).reduce((acc, [key, value]) => {
4234
- if (value === null) {
4235
- return acc;
4236
- }
4237
- acc[key] = de_Limits(value, context);
4238
- return acc;
4239
- }, {});
4240
3597
  };
4241
- const de_LimitValueList = (output, context) => {
4242
- const retVal = (output || [])
4243
- .filter((e) => e != null)
4244
- .map((entry) => {
4245
- if (entry === null) {
4246
- return null;
4247
- }
4248
- return __expectString(entry);
3598
+ const de_EncryptionAtRestOptionsStatus = (output, context) => {
3599
+ return take(output, {
3600
+ Options: _json,
3601
+ Status: (_) => de_OptionStatus(_, context),
4249
3602
  });
4250
- return retVal;
4251
- };
4252
- const de_LogPublishingOption = (output, context) => {
4253
- return {
4254
- CloudWatchLogsLogGroupArn: __expectString(output.CloudWatchLogsLogGroupArn),
4255
- Enabled: __expectBoolean(output.Enabled),
4256
- };
4257
- };
4258
- const de_LogPublishingOptions = (output, context) => {
4259
- return Object.entries(output).reduce((acc, [key, value]) => {
4260
- if (value === null) {
4261
- return acc;
4262
- }
4263
- acc[key] = de_LogPublishingOption(value, context);
4264
- return acc;
4265
- }, {});
4266
3603
  };
4267
3604
  const de_LogPublishingOptionsStatus = (output, context) => {
4268
- return {
4269
- Options: output.Options != null ? de_LogPublishingOptions(output.Options, context) : undefined,
4270
- Status: output.Status != null ? de_OptionStatus(output.Status, context) : undefined,
4271
- };
4272
- };
4273
- const de_NodeToNodeEncryptionOptions = (output, context) => {
4274
- return {
4275
- Enabled: __expectBoolean(output.Enabled),
4276
- };
3605
+ return take(output, {
3606
+ Options: _json,
3607
+ Status: (_) => de_OptionStatus(_, context),
3608
+ });
4277
3609
  };
4278
3610
  const de_NodeToNodeEncryptionOptionsStatus = (output, context) => {
4279
- return {
4280
- Options: output.Options != null ? de_NodeToNodeEncryptionOptions(output.Options, context) : undefined,
4281
- Status: output.Status != null ? de_OptionStatus(output.Status, context) : undefined,
4282
- };
3611
+ return take(output, {
3612
+ Options: _json,
3613
+ Status: (_) => de_OptionStatus(_, context),
3614
+ });
4283
3615
  };
4284
3616
  const de_OptionStatus = (output, context) => {
4285
- return {
4286
- CreationDate: output.CreationDate != null
4287
- ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.CreationDate)))
4288
- : undefined,
4289
- PendingDeletion: __expectBoolean(output.PendingDeletion),
4290
- State: __expectString(output.State),
4291
- UpdateDate: output.UpdateDate != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.UpdateDate))) : undefined,
4292
- UpdateVersion: __expectInt32(output.UpdateVersion),
4293
- };
4294
- };
4295
- const de_OutboundCrossClusterSearchConnection = (output, context) => {
4296
- return {
4297
- ConnectionAlias: __expectString(output.ConnectionAlias),
4298
- ConnectionStatus: output.ConnectionStatus != null
4299
- ? de_OutboundCrossClusterSearchConnectionStatus(output.ConnectionStatus, context)
4300
- : undefined,
4301
- CrossClusterSearchConnectionId: __expectString(output.CrossClusterSearchConnectionId),
4302
- DestinationDomainInfo: output.DestinationDomainInfo != null ? de_DomainInformation(output.DestinationDomainInfo, context) : undefined,
4303
- SourceDomainInfo: output.SourceDomainInfo != null ? de_DomainInformation(output.SourceDomainInfo, context) : undefined,
4304
- };
4305
- };
4306
- const de_OutboundCrossClusterSearchConnections = (output, context) => {
4307
- const retVal = (output || [])
4308
- .filter((e) => e != null)
4309
- .map((entry) => {
4310
- if (entry === null) {
4311
- return null;
4312
- }
4313
- return de_OutboundCrossClusterSearchConnection(entry, context);
3617
+ return take(output, {
3618
+ CreationDate: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
3619
+ PendingDeletion: __expectBoolean,
3620
+ State: __expectString,
3621
+ UpdateDate: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
3622
+ UpdateVersion: __expectInt32,
4314
3623
  });
4315
- return retVal;
4316
- };
4317
- const de_OutboundCrossClusterSearchConnectionStatus = (output, context) => {
4318
- return {
4319
- Message: __expectString(output.Message),
4320
- StatusCode: __expectString(output.StatusCode),
4321
- };
4322
3624
  };
4323
3625
  const de_PackageDetails = (output, context) => {
4324
- return {
4325
- AvailablePackageVersion: __expectString(output.AvailablePackageVersion),
4326
- CreatedAt: output.CreatedAt != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.CreatedAt))) : undefined,
4327
- ErrorDetails: output.ErrorDetails != null ? de_ErrorDetails(output.ErrorDetails, context) : undefined,
4328
- LastUpdatedAt: output.LastUpdatedAt != null
4329
- ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.LastUpdatedAt)))
4330
- : undefined,
4331
- PackageDescription: __expectString(output.PackageDescription),
4332
- PackageID: __expectString(output.PackageID),
4333
- PackageName: __expectString(output.PackageName),
4334
- PackageStatus: __expectString(output.PackageStatus),
4335
- PackageType: __expectString(output.PackageType),
4336
- };
3626
+ return take(output, {
3627
+ AvailablePackageVersion: __expectString,
3628
+ CreatedAt: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
3629
+ ErrorDetails: _json,
3630
+ LastUpdatedAt: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
3631
+ PackageDescription: __expectString,
3632
+ PackageID: __expectString,
3633
+ PackageName: __expectString,
3634
+ PackageStatus: __expectString,
3635
+ PackageType: __expectString,
3636
+ });
4337
3637
  };
4338
3638
  const de_PackageDetailsList = (output, context) => {
4339
3639
  const retVal = (output || [])
4340
3640
  .filter((e) => e != null)
4341
3641
  .map((entry) => {
4342
- if (entry === null) {
4343
- return null;
4344
- }
4345
3642
  return de_PackageDetails(entry, context);
4346
3643
  });
4347
3644
  return retVal;
4348
3645
  };
4349
3646
  const de_PackageVersionHistory = (output, context) => {
4350
- return {
4351
- CommitMessage: __expectString(output.CommitMessage),
4352
- CreatedAt: output.CreatedAt != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.CreatedAt))) : undefined,
4353
- PackageVersion: __expectString(output.PackageVersion),
4354
- };
3647
+ return take(output, {
3648
+ CommitMessage: __expectString,
3649
+ CreatedAt: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
3650
+ PackageVersion: __expectString,
3651
+ });
4355
3652
  };
4356
3653
  const de_PackageVersionHistoryList = (output, context) => {
4357
3654
  const retVal = (output || [])
4358
3655
  .filter((e) => e != null)
4359
3656
  .map((entry) => {
4360
- if (entry === null) {
4361
- return null;
4362
- }
4363
3657
  return de_PackageVersionHistory(entry, context);
4364
3658
  });
4365
3659
  return retVal;
4366
3660
  };
4367
3661
  const de_RecurringCharge = (output, context) => {
4368
- return {
4369
- RecurringChargeAmount: __limitedParseDouble(output.RecurringChargeAmount),
4370
- RecurringChargeFrequency: __expectString(output.RecurringChargeFrequency),
4371
- };
3662
+ return take(output, {
3663
+ RecurringChargeAmount: __limitedParseDouble,
3664
+ RecurringChargeFrequency: __expectString,
3665
+ });
4372
3666
  };
4373
3667
  const de_RecurringChargeList = (output, context) => {
4374
3668
  const retVal = (output || [])
4375
3669
  .filter((e) => e != null)
4376
3670
  .map((entry) => {
4377
- if (entry === null) {
4378
- return null;
4379
- }
4380
3671
  return de_RecurringCharge(entry, context);
4381
3672
  });
4382
3673
  return retVal;
4383
3674
  };
4384
3675
  const de_ReservedElasticsearchInstance = (output, context) => {
4385
- return {
4386
- CurrencyCode: __expectString(output.CurrencyCode),
4387
- Duration: __expectInt32(output.Duration),
4388
- ElasticsearchInstanceCount: __expectInt32(output.ElasticsearchInstanceCount),
4389
- ElasticsearchInstanceType: __expectString(output.ElasticsearchInstanceType),
4390
- FixedPrice: __limitedParseDouble(output.FixedPrice),
4391
- PaymentOption: __expectString(output.PaymentOption),
4392
- RecurringCharges: output.RecurringCharges != null ? de_RecurringChargeList(output.RecurringCharges, context) : undefined,
4393
- ReservationName: __expectString(output.ReservationName),
4394
- ReservedElasticsearchInstanceId: __expectString(output.ReservedElasticsearchInstanceId),
4395
- ReservedElasticsearchInstanceOfferingId: __expectString(output.ReservedElasticsearchInstanceOfferingId),
4396
- StartTime: output.StartTime != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.StartTime))) : undefined,
4397
- State: __expectString(output.State),
4398
- UsagePrice: __limitedParseDouble(output.UsagePrice),
4399
- };
3676
+ return take(output, {
3677
+ CurrencyCode: __expectString,
3678
+ Duration: __expectInt32,
3679
+ ElasticsearchInstanceCount: __expectInt32,
3680
+ ElasticsearchInstanceType: __expectString,
3681
+ FixedPrice: __limitedParseDouble,
3682
+ PaymentOption: __expectString,
3683
+ RecurringCharges: (_) => de_RecurringChargeList(_, context),
3684
+ ReservationName: __expectString,
3685
+ ReservedElasticsearchInstanceId: __expectString,
3686
+ ReservedElasticsearchInstanceOfferingId: __expectString,
3687
+ StartTime: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
3688
+ State: __expectString,
3689
+ UsagePrice: __limitedParseDouble,
3690
+ });
4400
3691
  };
4401
3692
  const de_ReservedElasticsearchInstanceList = (output, context) => {
4402
3693
  const retVal = (output || [])
4403
3694
  .filter((e) => e != null)
4404
3695
  .map((entry) => {
4405
- if (entry === null) {
4406
- return null;
4407
- }
4408
3696
  return de_ReservedElasticsearchInstance(entry, context);
4409
3697
  });
4410
3698
  return retVal;
4411
3699
  };
4412
3700
  const de_ReservedElasticsearchInstanceOffering = (output, context) => {
4413
- return {
4414
- CurrencyCode: __expectString(output.CurrencyCode),
4415
- Duration: __expectInt32(output.Duration),
4416
- ElasticsearchInstanceType: __expectString(output.ElasticsearchInstanceType),
4417
- FixedPrice: __limitedParseDouble(output.FixedPrice),
4418
- PaymentOption: __expectString(output.PaymentOption),
4419
- RecurringCharges: output.RecurringCharges != null ? de_RecurringChargeList(output.RecurringCharges, context) : undefined,
4420
- ReservedElasticsearchInstanceOfferingId: __expectString(output.ReservedElasticsearchInstanceOfferingId),
4421
- UsagePrice: __limitedParseDouble(output.UsagePrice),
4422
- };
3701
+ return take(output, {
3702
+ CurrencyCode: __expectString,
3703
+ Duration: __expectInt32,
3704
+ ElasticsearchInstanceType: __expectString,
3705
+ FixedPrice: __limitedParseDouble,
3706
+ PaymentOption: __expectString,
3707
+ RecurringCharges: (_) => de_RecurringChargeList(_, context),
3708
+ ReservedElasticsearchInstanceOfferingId: __expectString,
3709
+ UsagePrice: __limitedParseDouble,
3710
+ });
4423
3711
  };
4424
3712
  const de_ReservedElasticsearchInstanceOfferingList = (output, context) => {
4425
3713
  const retVal = (output || [])
4426
3714
  .filter((e) => e != null)
4427
3715
  .map((entry) => {
4428
- if (entry === null) {
4429
- return null;
4430
- }
4431
3716
  return de_ReservedElasticsearchInstanceOffering(entry, context);
4432
3717
  });
4433
3718
  return retVal;
4434
3719
  };
4435
- const de_SAMLIdp = (output, context) => {
4436
- return {
4437
- EntityId: __expectString(output.EntityId),
4438
- MetadataContent: __expectString(output.MetadataContent),
4439
- };
4440
- };
4441
- const de_SAMLOptionsOutput = (output, context) => {
4442
- return {
4443
- Enabled: __expectBoolean(output.Enabled),
4444
- Idp: output.Idp != null ? de_SAMLIdp(output.Idp, context) : undefined,
4445
- RolesKey: __expectString(output.RolesKey),
4446
- SessionTimeoutMinutes: __expectInt32(output.SessionTimeoutMinutes),
4447
- SubjectKey: __expectString(output.SubjectKey),
4448
- };
4449
- };
4450
3720
  const de_ScheduledAutoTuneDetails = (output, context) => {
4451
- return {
4452
- Action: __expectString(output.Action),
4453
- ActionType: __expectString(output.ActionType),
4454
- Date: output.Date != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.Date))) : undefined,
4455
- Severity: __expectString(output.Severity),
4456
- };
4457
- };
4458
- const de_ServiceSoftwareOptions = (output, context) => {
4459
- return {
4460
- AutomatedUpdateDate: output.AutomatedUpdateDate != null
4461
- ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.AutomatedUpdateDate)))
4462
- : undefined,
4463
- Cancellable: __expectBoolean(output.Cancellable),
4464
- CurrentVersion: __expectString(output.CurrentVersion),
4465
- Description: __expectString(output.Description),
4466
- NewVersion: __expectString(output.NewVersion),
4467
- OptionalDeployment: __expectBoolean(output.OptionalDeployment),
4468
- UpdateAvailable: __expectBoolean(output.UpdateAvailable),
4469
- UpdateStatus: __expectString(output.UpdateStatus),
4470
- };
4471
- };
4472
- const de_SnapshotOptions = (output, context) => {
4473
- return {
4474
- AutomatedSnapshotStartHour: __expectInt32(output.AutomatedSnapshotStartHour),
4475
- };
4476
- };
4477
- const de_SnapshotOptionsStatus = (output, context) => {
4478
- return {
4479
- Options: output.Options != null ? de_SnapshotOptions(output.Options, context) : undefined,
4480
- Status: output.Status != null ? de_OptionStatus(output.Status, context) : undefined,
4481
- };
4482
- };
4483
- const de_StorageType = (output, context) => {
4484
- return {
4485
- StorageSubTypeName: __expectString(output.StorageSubTypeName),
4486
- StorageTypeLimits: output.StorageTypeLimits != null ? de_StorageTypeLimitList(output.StorageTypeLimits, context) : undefined,
4487
- StorageTypeName: __expectString(output.StorageTypeName),
4488
- };
4489
- };
4490
- const de_StorageTypeLimit = (output, context) => {
4491
- return {
4492
- LimitName: __expectString(output.LimitName),
4493
- LimitValues: output.LimitValues != null ? de_LimitValueList(output.LimitValues, context) : undefined,
4494
- };
4495
- };
4496
- const de_StorageTypeLimitList = (output, context) => {
4497
- const retVal = (output || [])
4498
- .filter((e) => e != null)
4499
- .map((entry) => {
4500
- if (entry === null) {
4501
- return null;
4502
- }
4503
- return de_StorageTypeLimit(entry, context);
4504
- });
4505
- return retVal;
4506
- };
4507
- const de_StorageTypeList = (output, context) => {
4508
- const retVal = (output || [])
4509
- .filter((e) => e != null)
4510
- .map((entry) => {
4511
- if (entry === null) {
4512
- return null;
4513
- }
4514
- return de_StorageType(entry, context);
3721
+ return take(output, {
3722
+ Action: __expectString,
3723
+ ActionType: __expectString,
3724
+ Date: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
3725
+ Severity: __expectString,
4515
3726
  });
4516
- return retVal;
4517
3727
  };
4518
- const de_StringList = (output, context) => {
4519
- const retVal = (output || [])
4520
- .filter((e) => e != null)
4521
- .map((entry) => {
4522
- if (entry === null) {
4523
- return null;
4524
- }
4525
- return __expectString(entry);
3728
+ const de_ServiceSoftwareOptions = (output, context) => {
3729
+ return take(output, {
3730
+ AutomatedUpdateDate: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
3731
+ Cancellable: __expectBoolean,
3732
+ CurrentVersion: __expectString,
3733
+ Description: __expectString,
3734
+ NewVersion: __expectString,
3735
+ OptionalDeployment: __expectBoolean,
3736
+ UpdateAvailable: __expectBoolean,
3737
+ UpdateStatus: __expectString,
4526
3738
  });
4527
- return retVal;
4528
- };
4529
- const de_Tag = (output, context) => {
4530
- return {
4531
- Key: __expectString(output.Key),
4532
- Value: __expectString(output.Value),
4533
- };
4534
3739
  };
4535
- const de_TagList = (output, context) => {
4536
- const retVal = (output || [])
4537
- .filter((e) => e != null)
4538
- .map((entry) => {
4539
- if (entry === null) {
4540
- return null;
4541
- }
4542
- return de_Tag(entry, context);
3740
+ const de_SnapshotOptionsStatus = (output, context) => {
3741
+ return take(output, {
3742
+ Options: _json,
3743
+ Status: (_) => de_OptionStatus(_, context),
4543
3744
  });
4544
- return retVal;
4545
3745
  };
4546
3746
  const de_UpgradeHistory = (output, context) => {
4547
- return {
4548
- StartTimestamp: output.StartTimestamp != null
4549
- ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.StartTimestamp)))
4550
- : undefined,
4551
- StepsList: output.StepsList != null ? de_UpgradeStepsList(output.StepsList, context) : undefined,
4552
- UpgradeName: __expectString(output.UpgradeName),
4553
- UpgradeStatus: __expectString(output.UpgradeStatus),
4554
- };
3747
+ return take(output, {
3748
+ StartTimestamp: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
3749
+ StepsList: (_) => de_UpgradeStepsList(_, context),
3750
+ UpgradeName: __expectString,
3751
+ UpgradeStatus: __expectString,
3752
+ });
4555
3753
  };
4556
3754
  const de_UpgradeHistoryList = (output, context) => {
4557
3755
  const retVal = (output || [])
4558
3756
  .filter((e) => e != null)
4559
3757
  .map((entry) => {
4560
- if (entry === null) {
4561
- return null;
4562
- }
4563
3758
  return de_UpgradeHistory(entry, context);
4564
3759
  });
4565
3760
  return retVal;
4566
3761
  };
4567
3762
  const de_UpgradeStepItem = (output, context) => {
4568
- return {
4569
- Issues: output.Issues != null ? de_Issues(output.Issues, context) : undefined,
4570
- ProgressPercent: __limitedParseDouble(output.ProgressPercent),
4571
- UpgradeStep: __expectString(output.UpgradeStep),
4572
- UpgradeStepStatus: __expectString(output.UpgradeStepStatus),
4573
- };
3763
+ return take(output, {
3764
+ Issues: _json,
3765
+ ProgressPercent: __limitedParseDouble,
3766
+ UpgradeStep: __expectString,
3767
+ UpgradeStepStatus: __expectString,
3768
+ });
4574
3769
  };
4575
3770
  const de_UpgradeStepsList = (output, context) => {
4576
3771
  const retVal = (output || [])
4577
3772
  .filter((e) => e != null)
4578
3773
  .map((entry) => {
4579
- if (entry === null) {
4580
- return null;
4581
- }
4582
3774
  return de_UpgradeStepItem(entry, context);
4583
3775
  });
4584
3776
  return retVal;
4585
3777
  };
4586
- const de_VPCDerivedInfo = (output, context) => {
4587
- return {
4588
- AvailabilityZones: output.AvailabilityZones != null ? de_StringList(output.AvailabilityZones, context) : undefined,
4589
- SecurityGroupIds: output.SecurityGroupIds != null ? de_StringList(output.SecurityGroupIds, context) : undefined,
4590
- SubnetIds: output.SubnetIds != null ? de_StringList(output.SubnetIds, context) : undefined,
4591
- VPCId: __expectString(output.VPCId),
4592
- };
4593
- };
4594
3778
  const de_VPCDerivedInfoStatus = (output, context) => {
4595
- return {
4596
- Options: output.Options != null ? de_VPCDerivedInfo(output.Options, context) : undefined,
4597
- Status: output.Status != null ? de_OptionStatus(output.Status, context) : undefined,
4598
- };
4599
- };
4600
- const de_VpcEndpoint = (output, context) => {
4601
- return {
4602
- DomainArn: __expectString(output.DomainArn),
4603
- Endpoint: __expectString(output.Endpoint),
4604
- Status: __expectString(output.Status),
4605
- VpcEndpointId: __expectString(output.VpcEndpointId),
4606
- VpcEndpointOwner: __expectString(output.VpcEndpointOwner),
4607
- VpcOptions: output.VpcOptions != null ? de_VPCDerivedInfo(output.VpcOptions, context) : undefined,
4608
- };
4609
- };
4610
- const de_VpcEndpointError = (output, context) => {
4611
- return {
4612
- ErrorCode: __expectString(output.ErrorCode),
4613
- ErrorMessage: __expectString(output.ErrorMessage),
4614
- VpcEndpointId: __expectString(output.VpcEndpointId),
4615
- };
4616
- };
4617
- const de_VpcEndpointErrorList = (output, context) => {
4618
- const retVal = (output || [])
4619
- .filter((e) => e != null)
4620
- .map((entry) => {
4621
- if (entry === null) {
4622
- return null;
4623
- }
4624
- return de_VpcEndpointError(entry, context);
4625
- });
4626
- return retVal;
4627
- };
4628
- const de_VpcEndpoints = (output, context) => {
4629
- const retVal = (output || [])
4630
- .filter((e) => e != null)
4631
- .map((entry) => {
4632
- if (entry === null) {
4633
- return null;
4634
- }
4635
- return de_VpcEndpoint(entry, context);
4636
- });
4637
- return retVal;
4638
- };
4639
- const de_VpcEndpointSummary = (output, context) => {
4640
- return {
4641
- DomainArn: __expectString(output.DomainArn),
4642
- Status: __expectString(output.Status),
4643
- VpcEndpointId: __expectString(output.VpcEndpointId),
4644
- VpcEndpointOwner: __expectString(output.VpcEndpointOwner),
4645
- };
4646
- };
4647
- const de_VpcEndpointSummaryList = (output, context) => {
4648
- const retVal = (output || [])
4649
- .filter((e) => e != null)
4650
- .map((entry) => {
4651
- if (entry === null) {
4652
- return null;
4653
- }
4654
- return de_VpcEndpointSummary(entry, context);
3779
+ return take(output, {
3780
+ Options: _json,
3781
+ Status: (_) => de_OptionStatus(_, context),
4655
3782
  });
4656
- return retVal;
4657
- };
4658
- const de_ZoneAwarenessConfig = (output, context) => {
4659
- return {
4660
- AvailabilityZoneCount: __expectInt32(output.AvailabilityZoneCount),
4661
- };
4662
3783
  };
4663
3784
  const deserializeMetadata = (output) => ({
4664
3785
  httpStatusCode: output.statusCode,