@aws-sdk/client-mediaconnect 3.313.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 +1084 -1305
  2. package/dist-es/protocols/Aws_restJson1.js +1014 -1235
  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, expectInt32 as __expectInt32, expectNonNull as __expectNonNull, expectObject as __expectObject, expectString as __expectString, limitedParseDouble as __limitedParseDouble, map as __map, resolvedPath as __resolvedPath, serializeFloat as __serializeFloat, throwDefaultError, } from "@aws-sdk/smithy-client";
2
+ import { _json, decorateServiceException as __decorateServiceException, expectInt32 as __expectInt32, expectNonNull as __expectNonNull, expectObject as __expectObject, expectString as __expectString, limitedParseDouble as __limitedParseDouble, map, resolvedPath as __resolvedPath, serializeFloat as __serializeFloat, take, withBaseException, } from "@aws-sdk/smithy-client";
3
3
  import { MediaConnectServiceException as __BaseException } from "../models/MediaConnectServiceException";
4
4
  import { AddFlowOutputs420Exception, BadRequestException, ConflictException, CreateBridge420Exception, CreateFlow420Exception, CreateGateway420Exception, ForbiddenException, GrantFlowEntitlements420Exception, InternalServerErrorException, NotFoundException, ServiceUnavailableException, TooManyRequestsException, } from "../models/models_0";
5
5
  export const se_AddBridgeOutputsCommand = async (input, context) => {
@@ -10,9 +10,9 @@ export const se_AddBridgeOutputsCommand = async (input, context) => {
10
10
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/bridges/{BridgeArn}/outputs";
11
11
  resolvedPath = __resolvedPath(resolvedPath, input, "BridgeArn", () => input.BridgeArn, "{BridgeArn}", false);
12
12
  let body;
13
- body = JSON.stringify({
14
- ...(input.Outputs != null && { outputs: se___listOfAddBridgeOutputRequest(input.Outputs, context) }),
15
- });
13
+ body = JSON.stringify(take(input, {
14
+ outputs: [, (_) => se___listOfAddBridgeOutputRequest(_, context), `Outputs`],
15
+ }));
16
16
  return new __HttpRequest({
17
17
  protocol,
18
18
  hostname,
@@ -31,9 +31,9 @@ export const se_AddBridgeSourcesCommand = async (input, context) => {
31
31
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/bridges/{BridgeArn}/sources";
32
32
  resolvedPath = __resolvedPath(resolvedPath, input, "BridgeArn", () => input.BridgeArn, "{BridgeArn}", false);
33
33
  let body;
34
- body = JSON.stringify({
35
- ...(input.Sources != null && { sources: se___listOfAddBridgeSourceRequest(input.Sources, context) }),
36
- });
34
+ body = JSON.stringify(take(input, {
35
+ sources: [, (_) => se___listOfAddBridgeSourceRequest(_, context), `Sources`],
36
+ }));
37
37
  return new __HttpRequest({
38
38
  protocol,
39
39
  hostname,
@@ -52,9 +52,9 @@ export const se_AddFlowMediaStreamsCommand = async (input, context) => {
52
52
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/flows/{FlowArn}/mediaStreams";
53
53
  resolvedPath = __resolvedPath(resolvedPath, input, "FlowArn", () => input.FlowArn, "{FlowArn}", false);
54
54
  let body;
55
- body = JSON.stringify({
56
- ...(input.MediaStreams != null && { mediaStreams: se___listOfAddMediaStreamRequest(input.MediaStreams, context) }),
57
- });
55
+ body = JSON.stringify(take(input, {
56
+ mediaStreams: [, (_) => se___listOfAddMediaStreamRequest(_, context), `MediaStreams`],
57
+ }));
58
58
  return new __HttpRequest({
59
59
  protocol,
60
60
  hostname,
@@ -73,9 +73,9 @@ export const se_AddFlowOutputsCommand = async (input, context) => {
73
73
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/flows/{FlowArn}/outputs";
74
74
  resolvedPath = __resolvedPath(resolvedPath, input, "FlowArn", () => input.FlowArn, "{FlowArn}", false);
75
75
  let body;
76
- body = JSON.stringify({
77
- ...(input.Outputs != null && { outputs: se___listOfAddOutputRequest(input.Outputs, context) }),
78
- });
76
+ body = JSON.stringify(take(input, {
77
+ outputs: [, (_) => se___listOfAddOutputRequest(_, context), `Outputs`],
78
+ }));
79
79
  return new __HttpRequest({
80
80
  protocol,
81
81
  hostname,
@@ -94,9 +94,9 @@ export const se_AddFlowSourcesCommand = async (input, context) => {
94
94
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/flows/{FlowArn}/source";
95
95
  resolvedPath = __resolvedPath(resolvedPath, input, "FlowArn", () => input.FlowArn, "{FlowArn}", false);
96
96
  let body;
97
- body = JSON.stringify({
98
- ...(input.Sources != null && { sources: se___listOfSetSourceRequest(input.Sources, context) }),
99
- });
97
+ body = JSON.stringify(take(input, {
98
+ sources: [, (_) => se___listOfSetSourceRequest(_, context), `Sources`],
99
+ }));
100
100
  return new __HttpRequest({
101
101
  protocol,
102
102
  hostname,
@@ -115,9 +115,9 @@ export const se_AddFlowVpcInterfacesCommand = async (input, context) => {
115
115
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/flows/{FlowArn}/vpcInterfaces";
116
116
  resolvedPath = __resolvedPath(resolvedPath, input, "FlowArn", () => input.FlowArn, "{FlowArn}", false);
117
117
  let body;
118
- body = JSON.stringify({
119
- ...(input.VpcInterfaces != null && { vpcInterfaces: se___listOfVpcInterfaceRequest(input.VpcInterfaces, context) }),
120
- });
118
+ body = JSON.stringify(take(input, {
119
+ vpcInterfaces: [, (_) => se___listOfVpcInterfaceRequest(_, context), `VpcInterfaces`],
120
+ }));
121
121
  return new __HttpRequest({
122
122
  protocol,
123
123
  hostname,
@@ -135,21 +135,15 @@ export const se_CreateBridgeCommand = async (input, context) => {
135
135
  };
136
136
  const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/bridges";
137
137
  let body;
138
- body = JSON.stringify({
139
- ...(input.EgressGatewayBridge != null && {
140
- egressGatewayBridge: se_AddEgressGatewayBridgeRequest(input.EgressGatewayBridge, context),
141
- }),
142
- ...(input.IngressGatewayBridge != null && {
143
- ingressGatewayBridge: se_AddIngressGatewayBridgeRequest(input.IngressGatewayBridge, context),
144
- }),
145
- ...(input.Name != null && { name: input.Name }),
146
- ...(input.Outputs != null && { outputs: se___listOfAddBridgeOutputRequest(input.Outputs, context) }),
147
- ...(input.PlacementArn != null && { placementArn: input.PlacementArn }),
148
- ...(input.SourceFailoverConfig != null && {
149
- sourceFailoverConfig: se_FailoverConfig(input.SourceFailoverConfig, context),
150
- }),
151
- ...(input.Sources != null && { sources: se___listOfAddBridgeSourceRequest(input.Sources, context) }),
152
- });
138
+ body = JSON.stringify(take(input, {
139
+ egressGatewayBridge: [, (_) => se_AddEgressGatewayBridgeRequest(_, context), `EgressGatewayBridge`],
140
+ ingressGatewayBridge: [, (_) => se_AddIngressGatewayBridgeRequest(_, context), `IngressGatewayBridge`],
141
+ name: [, , `Name`],
142
+ outputs: [, (_) => se___listOfAddBridgeOutputRequest(_, context), `Outputs`],
143
+ placementArn: [, , `PlacementArn`],
144
+ sourceFailoverConfig: [, (_) => se_FailoverConfig(_, context), `SourceFailoverConfig`],
145
+ sources: [, (_) => se___listOfAddBridgeSourceRequest(_, context), `Sources`],
146
+ }));
153
147
  return new __HttpRequest({
154
148
  protocol,
155
149
  hostname,
@@ -167,22 +161,18 @@ export const se_CreateFlowCommand = async (input, context) => {
167
161
  };
168
162
  const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/flows";
169
163
  let body;
170
- body = JSON.stringify({
171
- ...(input.AvailabilityZone != null && { availabilityZone: input.AvailabilityZone }),
172
- ...(input.Entitlements != null && {
173
- entitlements: se___listOfGrantEntitlementRequest(input.Entitlements, context),
174
- }),
175
- ...(input.Maintenance != null && { maintenance: se_AddMaintenance(input.Maintenance, context) }),
176
- ...(input.MediaStreams != null && { mediaStreams: se___listOfAddMediaStreamRequest(input.MediaStreams, context) }),
177
- ...(input.Name != null && { name: input.Name }),
178
- ...(input.Outputs != null && { outputs: se___listOfAddOutputRequest(input.Outputs, context) }),
179
- ...(input.Source != null && { source: se_SetSourceRequest(input.Source, context) }),
180
- ...(input.SourceFailoverConfig != null && {
181
- sourceFailoverConfig: se_FailoverConfig(input.SourceFailoverConfig, context),
182
- }),
183
- ...(input.Sources != null && { sources: se___listOfSetSourceRequest(input.Sources, context) }),
184
- ...(input.VpcInterfaces != null && { vpcInterfaces: se___listOfVpcInterfaceRequest(input.VpcInterfaces, context) }),
185
- });
164
+ body = JSON.stringify(take(input, {
165
+ availabilityZone: [, , `AvailabilityZone`],
166
+ entitlements: [, (_) => se___listOfGrantEntitlementRequest(_, context), `Entitlements`],
167
+ maintenance: [, (_) => se_AddMaintenance(_, context), `Maintenance`],
168
+ mediaStreams: [, (_) => se___listOfAddMediaStreamRequest(_, context), `MediaStreams`],
169
+ name: [, , `Name`],
170
+ outputs: [, (_) => se___listOfAddOutputRequest(_, context), `Outputs`],
171
+ source: [, (_) => se_SetSourceRequest(_, context), `Source`],
172
+ sourceFailoverConfig: [, (_) => se_FailoverConfig(_, context), `SourceFailoverConfig`],
173
+ sources: [, (_) => se___listOfSetSourceRequest(_, context), `Sources`],
174
+ vpcInterfaces: [, (_) => se___listOfVpcInterfaceRequest(_, context), `VpcInterfaces`],
175
+ }));
186
176
  return new __HttpRequest({
187
177
  protocol,
188
178
  hostname,
@@ -200,11 +190,11 @@ export const se_CreateGatewayCommand = async (input, context) => {
200
190
  };
201
191
  const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/gateways";
202
192
  let body;
203
- body = JSON.stringify({
204
- ...(input.EgressCidrBlocks != null && { egressCidrBlocks: se___listOf__string(input.EgressCidrBlocks, context) }),
205
- ...(input.Name != null && { name: input.Name }),
206
- ...(input.Networks != null && { networks: se___listOfGatewayNetwork(input.Networks, context) }),
207
- });
193
+ body = JSON.stringify(take(input, {
194
+ egressCidrBlocks: [, (_) => _json(_), `EgressCidrBlocks`],
195
+ name: [, , `Name`],
196
+ networks: [, (_) => se___listOfGatewayNetwork(_, context), `Networks`],
197
+ }));
208
198
  return new __HttpRequest({
209
199
  protocol,
210
200
  hostname,
@@ -389,11 +379,9 @@ export const se_GrantFlowEntitlementsCommand = async (input, context) => {
389
379
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/flows/{FlowArn}/entitlements";
390
380
  resolvedPath = __resolvedPath(resolvedPath, input, "FlowArn", () => input.FlowArn, "{FlowArn}", false);
391
381
  let body;
392
- body = JSON.stringify({
393
- ...(input.Entitlements != null && {
394
- entitlements: se___listOfGrantEntitlementRequest(input.Entitlements, context),
395
- }),
396
- });
382
+ body = JSON.stringify(take(input, {
383
+ entitlements: [, (_) => se___listOfGrantEntitlementRequest(_, context), `Entitlements`],
384
+ }));
397
385
  return new __HttpRequest({
398
386
  protocol,
399
387
  hostname,
@@ -570,10 +558,10 @@ export const se_PurchaseOfferingCommand = async (input, context) => {
570
558
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/offerings/{OfferingArn}";
571
559
  resolvedPath = __resolvedPath(resolvedPath, input, "OfferingArn", () => input.OfferingArn, "{OfferingArn}", false);
572
560
  let body;
573
- body = JSON.stringify({
574
- ...(input.ReservationName != null && { reservationName: input.ReservationName }),
575
- ...(input.Start != null && { start: input.Start }),
576
- });
561
+ body = JSON.stringify(take(input, {
562
+ reservationName: [, , `ReservationName`],
563
+ start: [, , `Start`],
564
+ }));
577
565
  return new __HttpRequest({
578
566
  protocol,
579
567
  hostname,
@@ -748,9 +736,9 @@ export const se_TagResourceCommand = async (input, context) => {
748
736
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{ResourceArn}";
749
737
  resolvedPath = __resolvedPath(resolvedPath, input, "ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
750
738
  let body;
751
- body = JSON.stringify({
752
- ...(input.Tags != null && { tags: se___mapOf__string(input.Tags, context) }),
753
- });
739
+ body = JSON.stringify(take(input, {
740
+ tags: [, (_) => _json(_), `Tags`],
741
+ }));
754
742
  return new __HttpRequest({
755
743
  protocol,
756
744
  hostname,
@@ -792,17 +780,11 @@ export const se_UpdateBridgeCommand = async (input, context) => {
792
780
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/bridges/{BridgeArn}";
793
781
  resolvedPath = __resolvedPath(resolvedPath, input, "BridgeArn", () => input.BridgeArn, "{BridgeArn}", false);
794
782
  let body;
795
- body = JSON.stringify({
796
- ...(input.EgressGatewayBridge != null && {
797
- egressGatewayBridge: se_UpdateEgressGatewayBridgeRequest(input.EgressGatewayBridge, context),
798
- }),
799
- ...(input.IngressGatewayBridge != null && {
800
- ingressGatewayBridge: se_UpdateIngressGatewayBridgeRequest(input.IngressGatewayBridge, context),
801
- }),
802
- ...(input.SourceFailoverConfig != null && {
803
- sourceFailoverConfig: se_UpdateFailoverConfig(input.SourceFailoverConfig, context),
804
- }),
805
- });
783
+ body = JSON.stringify(take(input, {
784
+ egressGatewayBridge: [, (_) => se_UpdateEgressGatewayBridgeRequest(_, context), `EgressGatewayBridge`],
785
+ ingressGatewayBridge: [, (_) => se_UpdateIngressGatewayBridgeRequest(_, context), `IngressGatewayBridge`],
786
+ sourceFailoverConfig: [, (_) => se_UpdateFailoverConfig(_, context), `SourceFailoverConfig`],
787
+ }));
806
788
  return new __HttpRequest({
807
789
  protocol,
808
790
  hostname,
@@ -823,11 +805,9 @@ export const se_UpdateBridgeOutputCommand = async (input, context) => {
823
805
  resolvedPath = __resolvedPath(resolvedPath, input, "BridgeArn", () => input.BridgeArn, "{BridgeArn}", false);
824
806
  resolvedPath = __resolvedPath(resolvedPath, input, "OutputName", () => input.OutputName, "{OutputName}", false);
825
807
  let body;
826
- body = JSON.stringify({
827
- ...(input.NetworkOutput != null && {
828
- networkOutput: se_UpdateBridgeNetworkOutputRequest(input.NetworkOutput, context),
829
- }),
830
- });
808
+ body = JSON.stringify(take(input, {
809
+ networkOutput: [, (_) => se_UpdateBridgeNetworkOutputRequest(_, context), `NetworkOutput`],
810
+ }));
831
811
  return new __HttpRequest({
832
812
  protocol,
833
813
  hostname,
@@ -848,12 +828,10 @@ export const se_UpdateBridgeSourceCommand = async (input, context) => {
848
828
  resolvedPath = __resolvedPath(resolvedPath, input, "BridgeArn", () => input.BridgeArn, "{BridgeArn}", false);
849
829
  resolvedPath = __resolvedPath(resolvedPath, input, "SourceName", () => input.SourceName, "{SourceName}", false);
850
830
  let body;
851
- body = JSON.stringify({
852
- ...(input.FlowSource != null && { flowSource: se_UpdateBridgeFlowSourceRequest(input.FlowSource, context) }),
853
- ...(input.NetworkSource != null && {
854
- networkSource: se_UpdateBridgeNetworkSourceRequest(input.NetworkSource, context),
855
- }),
856
- });
831
+ body = JSON.stringify(take(input, {
832
+ flowSource: [, (_) => se_UpdateBridgeFlowSourceRequest(_, context), `FlowSource`],
833
+ networkSource: [, (_) => se_UpdateBridgeNetworkSourceRequest(_, context), `NetworkSource`],
834
+ }));
857
835
  return new __HttpRequest({
858
836
  protocol,
859
837
  hostname,
@@ -872,9 +850,9 @@ export const se_UpdateBridgeStateCommand = async (input, context) => {
872
850
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/bridges/{BridgeArn}/state";
873
851
  resolvedPath = __resolvedPath(resolvedPath, input, "BridgeArn", () => input.BridgeArn, "{BridgeArn}", false);
874
852
  let body;
875
- body = JSON.stringify({
876
- ...(input.DesiredState != null && { desiredState: input.DesiredState }),
877
- });
853
+ body = JSON.stringify(take(input, {
854
+ desiredState: [, , `DesiredState`],
855
+ }));
878
856
  return new __HttpRequest({
879
857
  protocol,
880
858
  hostname,
@@ -893,12 +871,10 @@ export const se_UpdateFlowCommand = async (input, context) => {
893
871
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/flows/{FlowArn}";
894
872
  resolvedPath = __resolvedPath(resolvedPath, input, "FlowArn", () => input.FlowArn, "{FlowArn}", false);
895
873
  let body;
896
- body = JSON.stringify({
897
- ...(input.Maintenance != null && { maintenance: se_UpdateMaintenance(input.Maintenance, context) }),
898
- ...(input.SourceFailoverConfig != null && {
899
- sourceFailoverConfig: se_UpdateFailoverConfig(input.SourceFailoverConfig, context),
900
- }),
901
- });
874
+ body = JSON.stringify(take(input, {
875
+ maintenance: [, (_) => se_UpdateMaintenance(_, context), `Maintenance`],
876
+ sourceFailoverConfig: [, (_) => se_UpdateFailoverConfig(_, context), `SourceFailoverConfig`],
877
+ }));
902
878
  return new __HttpRequest({
903
879
  protocol,
904
880
  hostname,
@@ -919,12 +895,12 @@ export const se_UpdateFlowEntitlementCommand = async (input, context) => {
919
895
  resolvedPath = __resolvedPath(resolvedPath, input, "EntitlementArn", () => input.EntitlementArn, "{EntitlementArn}", false);
920
896
  resolvedPath = __resolvedPath(resolvedPath, input, "FlowArn", () => input.FlowArn, "{FlowArn}", false);
921
897
  let body;
922
- body = JSON.stringify({
923
- ...(input.Description != null && { description: input.Description }),
924
- ...(input.Encryption != null && { encryption: se_UpdateEncryption(input.Encryption, context) }),
925
- ...(input.EntitlementStatus != null && { entitlementStatus: input.EntitlementStatus }),
926
- ...(input.Subscribers != null && { subscribers: se___listOf__string(input.Subscribers, context) }),
927
- });
898
+ body = JSON.stringify(take(input, {
899
+ description: [, , `Description`],
900
+ encryption: [, (_) => se_UpdateEncryption(_, context), `Encryption`],
901
+ entitlementStatus: [, , `EntitlementStatus`],
902
+ subscribers: [, (_) => _json(_), `Subscribers`],
903
+ }));
928
904
  return new __HttpRequest({
929
905
  protocol,
930
906
  hostname,
@@ -945,13 +921,13 @@ export const se_UpdateFlowMediaStreamCommand = async (input, context) => {
945
921
  resolvedPath = __resolvedPath(resolvedPath, input, "FlowArn", () => input.FlowArn, "{FlowArn}", false);
946
922
  resolvedPath = __resolvedPath(resolvedPath, input, "MediaStreamName", () => input.MediaStreamName, "{MediaStreamName}", false);
947
923
  let body;
948
- body = JSON.stringify({
949
- ...(input.Attributes != null && { attributes: se_MediaStreamAttributesRequest(input.Attributes, context) }),
950
- ...(input.ClockRate != null && { clockRate: input.ClockRate }),
951
- ...(input.Description != null && { description: input.Description }),
952
- ...(input.MediaStreamType != null && { mediaStreamType: input.MediaStreamType }),
953
- ...(input.VideoFormat != null && { videoFormat: input.VideoFormat }),
954
- });
924
+ body = JSON.stringify(take(input, {
925
+ attributes: [, (_) => se_MediaStreamAttributesRequest(_, context), `Attributes`],
926
+ clockRate: [, , `ClockRate`],
927
+ description: [, , `Description`],
928
+ mediaStreamType: [, , `MediaStreamType`],
929
+ videoFormat: [, , `VideoFormat`],
930
+ }));
955
931
  return new __HttpRequest({
956
932
  protocol,
957
933
  hostname,
@@ -971,27 +947,27 @@ export const se_UpdateFlowOutputCommand = async (input, context) => {
971
947
  resolvedPath = __resolvedPath(resolvedPath, input, "FlowArn", () => input.FlowArn, "{FlowArn}", false);
972
948
  resolvedPath = __resolvedPath(resolvedPath, input, "OutputArn", () => input.OutputArn, "{OutputArn}", false);
973
949
  let body;
974
- body = JSON.stringify({
975
- ...(input.CidrAllowList != null && { cidrAllowList: se___listOf__string(input.CidrAllowList, context) }),
976
- ...(input.Description != null && { description: input.Description }),
977
- ...(input.Destination != null && { destination: input.Destination }),
978
- ...(input.Encryption != null && { encryption: se_UpdateEncryption(input.Encryption, context) }),
979
- ...(input.MaxLatency != null && { maxLatency: input.MaxLatency }),
980
- ...(input.MediaStreamOutputConfigurations != null && {
981
- mediaStreamOutputConfigurations: se___listOfMediaStreamOutputConfigurationRequest(input.MediaStreamOutputConfigurations, context),
982
- }),
983
- ...(input.MinLatency != null && { minLatency: input.MinLatency }),
984
- ...(input.Port != null && { port: input.Port }),
985
- ...(input.Protocol != null && { protocol: input.Protocol }),
986
- ...(input.RemoteId != null && { remoteId: input.RemoteId }),
987
- ...(input.SenderControlPort != null && { senderControlPort: input.SenderControlPort }),
988
- ...(input.SenderIpAddress != null && { senderIpAddress: input.SenderIpAddress }),
989
- ...(input.SmoothingLatency != null && { smoothingLatency: input.SmoothingLatency }),
990
- ...(input.StreamId != null && { streamId: input.StreamId }),
991
- ...(input.VpcInterfaceAttachment != null && {
992
- vpcInterfaceAttachment: se_VpcInterfaceAttachment(input.VpcInterfaceAttachment, context),
993
- }),
994
- });
950
+ body = JSON.stringify(take(input, {
951
+ cidrAllowList: [, (_) => _json(_), `CidrAllowList`],
952
+ description: [, , `Description`],
953
+ destination: [, , `Destination`],
954
+ encryption: [, (_) => se_UpdateEncryption(_, context), `Encryption`],
955
+ maxLatency: [, , `MaxLatency`],
956
+ mediaStreamOutputConfigurations: [
957
+ ,
958
+ (_) => se___listOfMediaStreamOutputConfigurationRequest(_, context),
959
+ `MediaStreamOutputConfigurations`,
960
+ ],
961
+ minLatency: [, , `MinLatency`],
962
+ port: [, , `Port`],
963
+ protocol: [, , `Protocol`],
964
+ remoteId: [, , `RemoteId`],
965
+ senderControlPort: [, , `SenderControlPort`],
966
+ senderIpAddress: [, , `SenderIpAddress`],
967
+ smoothingLatency: [, , `SmoothingLatency`],
968
+ streamId: [, , `StreamId`],
969
+ vpcInterfaceAttachment: [, (_) => se_VpcInterfaceAttachment(_, context), `VpcInterfaceAttachment`],
970
+ }));
995
971
  return new __HttpRequest({
996
972
  protocol,
997
973
  hostname,
@@ -1011,30 +987,30 @@ export const se_UpdateFlowSourceCommand = async (input, context) => {
1011
987
  resolvedPath = __resolvedPath(resolvedPath, input, "FlowArn", () => input.FlowArn, "{FlowArn}", false);
1012
988
  resolvedPath = __resolvedPath(resolvedPath, input, "SourceArn", () => input.SourceArn, "{SourceArn}", false);
1013
989
  let body;
1014
- body = JSON.stringify({
1015
- ...(input.Decryption != null && { decryption: se_UpdateEncryption(input.Decryption, context) }),
1016
- ...(input.Description != null && { description: input.Description }),
1017
- ...(input.EntitlementArn != null && { entitlementArn: input.EntitlementArn }),
1018
- ...(input.GatewayBridgeSource != null && {
1019
- gatewayBridgeSource: se_UpdateGatewayBridgeSourceRequest(input.GatewayBridgeSource, context),
1020
- }),
1021
- ...(input.IngestPort != null && { ingestPort: input.IngestPort }),
1022
- ...(input.MaxBitrate != null && { maxBitrate: input.MaxBitrate }),
1023
- ...(input.MaxLatency != null && { maxLatency: input.MaxLatency }),
1024
- ...(input.MaxSyncBuffer != null && { maxSyncBuffer: input.MaxSyncBuffer }),
1025
- ...(input.MediaStreamSourceConfigurations != null && {
1026
- mediaStreamSourceConfigurations: se___listOfMediaStreamSourceConfigurationRequest(input.MediaStreamSourceConfigurations, context),
1027
- }),
1028
- ...(input.MinLatency != null && { minLatency: input.MinLatency }),
1029
- ...(input.Protocol != null && { protocol: input.Protocol }),
1030
- ...(input.SenderControlPort != null && { senderControlPort: input.SenderControlPort }),
1031
- ...(input.SenderIpAddress != null && { senderIpAddress: input.SenderIpAddress }),
1032
- ...(input.SourceListenerAddress != null && { sourceListenerAddress: input.SourceListenerAddress }),
1033
- ...(input.SourceListenerPort != null && { sourceListenerPort: input.SourceListenerPort }),
1034
- ...(input.StreamId != null && { streamId: input.StreamId }),
1035
- ...(input.VpcInterfaceName != null && { vpcInterfaceName: input.VpcInterfaceName }),
1036
- ...(input.WhitelistCidr != null && { whitelistCidr: input.WhitelistCidr }),
1037
- });
990
+ body = JSON.stringify(take(input, {
991
+ decryption: [, (_) => se_UpdateEncryption(_, context), `Decryption`],
992
+ description: [, , `Description`],
993
+ entitlementArn: [, , `EntitlementArn`],
994
+ gatewayBridgeSource: [, (_) => se_UpdateGatewayBridgeSourceRequest(_, context), `GatewayBridgeSource`],
995
+ ingestPort: [, , `IngestPort`],
996
+ maxBitrate: [, , `MaxBitrate`],
997
+ maxLatency: [, , `MaxLatency`],
998
+ maxSyncBuffer: [, , `MaxSyncBuffer`],
999
+ mediaStreamSourceConfigurations: [
1000
+ ,
1001
+ (_) => se___listOfMediaStreamSourceConfigurationRequest(_, context),
1002
+ `MediaStreamSourceConfigurations`,
1003
+ ],
1004
+ minLatency: [, , `MinLatency`],
1005
+ protocol: [, , `Protocol`],
1006
+ senderControlPort: [, , `SenderControlPort`],
1007
+ senderIpAddress: [, , `SenderIpAddress`],
1008
+ sourceListenerAddress: [, , `SourceListenerAddress`],
1009
+ sourceListenerPort: [, , `SourceListenerPort`],
1010
+ streamId: [, , `StreamId`],
1011
+ vpcInterfaceName: [, , `VpcInterfaceName`],
1012
+ whitelistCidr: [, , `WhitelistCidr`],
1013
+ }));
1038
1014
  return new __HttpRequest({
1039
1015
  protocol,
1040
1016
  hostname,
@@ -1054,9 +1030,9 @@ export const se_UpdateGatewayInstanceCommand = async (input, context) => {
1054
1030
  "/v1/gateway-instances/{GatewayInstanceArn}";
1055
1031
  resolvedPath = __resolvedPath(resolvedPath, input, "GatewayInstanceArn", () => input.GatewayInstanceArn, "{GatewayInstanceArn}", false);
1056
1032
  let body;
1057
- body = JSON.stringify({
1058
- ...(input.BridgePlacement != null && { bridgePlacement: input.BridgePlacement }),
1059
- });
1033
+ body = JSON.stringify(take(input, {
1034
+ bridgePlacement: [, , `BridgePlacement`],
1035
+ }));
1060
1036
  return new __HttpRequest({
1061
1037
  protocol,
1062
1038
  hostname,
@@ -1075,12 +1051,11 @@ export const de_AddBridgeOutputsCommand = async (output, context) => {
1075
1051
  $metadata: deserializeMetadata(output),
1076
1052
  });
1077
1053
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1078
- if (data.bridgeArn != null) {
1079
- contents.BridgeArn = __expectString(data.bridgeArn);
1080
- }
1081
- if (data.outputs != null) {
1082
- contents.Outputs = de___listOfBridgeOutput(data.outputs, context);
1083
- }
1054
+ const doc = take(data, {
1055
+ BridgeArn: [, __expectString, `bridgeArn`],
1056
+ Outputs: [, (_) => de___listOfBridgeOutput(_, context), `outputs`],
1057
+ });
1058
+ Object.assign(contents, doc);
1084
1059
  return contents;
1085
1060
  };
1086
1061
  const de_AddBridgeOutputsCommandError = async (output, context) => {
@@ -1113,10 +1088,9 @@ const de_AddBridgeOutputsCommandError = async (output, context) => {
1113
1088
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1114
1089
  default:
1115
1090
  const parsedBody = parsedOutput.body;
1116
- throwDefaultError({
1091
+ return throwDefaultError({
1117
1092
  output,
1118
1093
  parsedBody,
1119
- exceptionCtor: __BaseException,
1120
1094
  errorCode,
1121
1095
  });
1122
1096
  }
@@ -1129,12 +1103,11 @@ export const de_AddBridgeSourcesCommand = async (output, context) => {
1129
1103
  $metadata: deserializeMetadata(output),
1130
1104
  });
1131
1105
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1132
- if (data.bridgeArn != null) {
1133
- contents.BridgeArn = __expectString(data.bridgeArn);
1134
- }
1135
- if (data.sources != null) {
1136
- contents.Sources = de___listOfBridgeSource(data.sources, context);
1137
- }
1106
+ const doc = take(data, {
1107
+ BridgeArn: [, __expectString, `bridgeArn`],
1108
+ Sources: [, (_) => de___listOfBridgeSource(_, context), `sources`],
1109
+ });
1110
+ Object.assign(contents, doc);
1138
1111
  return contents;
1139
1112
  };
1140
1113
  const de_AddBridgeSourcesCommandError = async (output, context) => {
@@ -1167,10 +1140,9 @@ const de_AddBridgeSourcesCommandError = async (output, context) => {
1167
1140
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1168
1141
  default:
1169
1142
  const parsedBody = parsedOutput.body;
1170
- throwDefaultError({
1143
+ return throwDefaultError({
1171
1144
  output,
1172
1145
  parsedBody,
1173
- exceptionCtor: __BaseException,
1174
1146
  errorCode,
1175
1147
  });
1176
1148
  }
@@ -1183,12 +1155,11 @@ export const de_AddFlowMediaStreamsCommand = async (output, context) => {
1183
1155
  $metadata: deserializeMetadata(output),
1184
1156
  });
1185
1157
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1186
- if (data.flowArn != null) {
1187
- contents.FlowArn = __expectString(data.flowArn);
1188
- }
1189
- if (data.mediaStreams != null) {
1190
- contents.MediaStreams = de___listOfMediaStream(data.mediaStreams, context);
1191
- }
1158
+ const doc = take(data, {
1159
+ FlowArn: [, __expectString, `flowArn`],
1160
+ MediaStreams: [, (_) => de___listOfMediaStream(_, context), `mediaStreams`],
1161
+ });
1162
+ Object.assign(contents, doc);
1192
1163
  return contents;
1193
1164
  };
1194
1165
  const de_AddFlowMediaStreamsCommandError = async (output, context) => {
@@ -1218,10 +1189,9 @@ const de_AddFlowMediaStreamsCommandError = async (output, context) => {
1218
1189
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1219
1190
  default:
1220
1191
  const parsedBody = parsedOutput.body;
1221
- throwDefaultError({
1192
+ return throwDefaultError({
1222
1193
  output,
1223
1194
  parsedBody,
1224
- exceptionCtor: __BaseException,
1225
1195
  errorCode,
1226
1196
  });
1227
1197
  }
@@ -1234,12 +1204,11 @@ export const de_AddFlowOutputsCommand = async (output, context) => {
1234
1204
  $metadata: deserializeMetadata(output),
1235
1205
  });
1236
1206
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1237
- if (data.flowArn != null) {
1238
- contents.FlowArn = __expectString(data.flowArn);
1239
- }
1240
- if (data.outputs != null) {
1241
- contents.Outputs = de___listOfOutput(data.outputs, context);
1242
- }
1207
+ const doc = take(data, {
1208
+ FlowArn: [, __expectString, `flowArn`],
1209
+ Outputs: [, (_) => de___listOfOutput(_, context), `outputs`],
1210
+ });
1211
+ Object.assign(contents, doc);
1243
1212
  return contents;
1244
1213
  };
1245
1214
  const de_AddFlowOutputsCommandError = async (output, context) => {
@@ -1272,10 +1241,9 @@ const de_AddFlowOutputsCommandError = async (output, context) => {
1272
1241
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1273
1242
  default:
1274
1243
  const parsedBody = parsedOutput.body;
1275
- throwDefaultError({
1244
+ return throwDefaultError({
1276
1245
  output,
1277
1246
  parsedBody,
1278
- exceptionCtor: __BaseException,
1279
1247
  errorCode,
1280
1248
  });
1281
1249
  }
@@ -1288,12 +1256,11 @@ export const de_AddFlowSourcesCommand = async (output, context) => {
1288
1256
  $metadata: deserializeMetadata(output),
1289
1257
  });
1290
1258
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1291
- if (data.flowArn != null) {
1292
- contents.FlowArn = __expectString(data.flowArn);
1293
- }
1294
- if (data.sources != null) {
1295
- contents.Sources = de___listOfSource(data.sources, context);
1296
- }
1259
+ const doc = take(data, {
1260
+ FlowArn: [, __expectString, `flowArn`],
1261
+ Sources: [, (_) => de___listOfSource(_, context), `sources`],
1262
+ });
1263
+ Object.assign(contents, doc);
1297
1264
  return contents;
1298
1265
  };
1299
1266
  const de_AddFlowSourcesCommandError = async (output, context) => {
@@ -1323,10 +1290,9 @@ const de_AddFlowSourcesCommandError = async (output, context) => {
1323
1290
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1324
1291
  default:
1325
1292
  const parsedBody = parsedOutput.body;
1326
- throwDefaultError({
1293
+ return throwDefaultError({
1327
1294
  output,
1328
1295
  parsedBody,
1329
- exceptionCtor: __BaseException,
1330
1296
  errorCode,
1331
1297
  });
1332
1298
  }
@@ -1339,12 +1305,11 @@ export const de_AddFlowVpcInterfacesCommand = async (output, context) => {
1339
1305
  $metadata: deserializeMetadata(output),
1340
1306
  });
1341
1307
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1342
- if (data.flowArn != null) {
1343
- contents.FlowArn = __expectString(data.flowArn);
1344
- }
1345
- if (data.vpcInterfaces != null) {
1346
- contents.VpcInterfaces = de___listOfVpcInterface(data.vpcInterfaces, context);
1347
- }
1308
+ const doc = take(data, {
1309
+ FlowArn: [, __expectString, `flowArn`],
1310
+ VpcInterfaces: [, (_) => de___listOfVpcInterface(_, context), `vpcInterfaces`],
1311
+ });
1312
+ Object.assign(contents, doc);
1348
1313
  return contents;
1349
1314
  };
1350
1315
  const de_AddFlowVpcInterfacesCommandError = async (output, context) => {
@@ -1374,10 +1339,9 @@ const de_AddFlowVpcInterfacesCommandError = async (output, context) => {
1374
1339
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1375
1340
  default:
1376
1341
  const parsedBody = parsedOutput.body;
1377
- throwDefaultError({
1342
+ return throwDefaultError({
1378
1343
  output,
1379
1344
  parsedBody,
1380
- exceptionCtor: __BaseException,
1381
1345
  errorCode,
1382
1346
  });
1383
1347
  }
@@ -1390,9 +1354,10 @@ export const de_CreateBridgeCommand = async (output, context) => {
1390
1354
  $metadata: deserializeMetadata(output),
1391
1355
  });
1392
1356
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1393
- if (data.bridge != null) {
1394
- contents.Bridge = de_Bridge(data.bridge, context);
1395
- }
1357
+ const doc = take(data, {
1358
+ Bridge: [, (_) => de_Bridge(_, context), `bridge`],
1359
+ });
1360
+ Object.assign(contents, doc);
1396
1361
  return contents;
1397
1362
  };
1398
1363
  const de_CreateBridgeCommandError = async (output, context) => {
@@ -1425,10 +1390,9 @@ const de_CreateBridgeCommandError = async (output, context) => {
1425
1390
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1426
1391
  default:
1427
1392
  const parsedBody = parsedOutput.body;
1428
- throwDefaultError({
1393
+ return throwDefaultError({
1429
1394
  output,
1430
1395
  parsedBody,
1431
- exceptionCtor: __BaseException,
1432
1396
  errorCode,
1433
1397
  });
1434
1398
  }
@@ -1441,9 +1405,10 @@ export const de_CreateFlowCommand = async (output, context) => {
1441
1405
  $metadata: deserializeMetadata(output),
1442
1406
  });
1443
1407
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1444
- if (data.flow != null) {
1445
- contents.Flow = de_Flow(data.flow, context);
1446
- }
1408
+ const doc = take(data, {
1409
+ Flow: [, (_) => de_Flow(_, context), `flow`],
1410
+ });
1411
+ Object.assign(contents, doc);
1447
1412
  return contents;
1448
1413
  };
1449
1414
  const de_CreateFlowCommandError = async (output, context) => {
@@ -1473,10 +1438,9 @@ const de_CreateFlowCommandError = async (output, context) => {
1473
1438
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1474
1439
  default:
1475
1440
  const parsedBody = parsedOutput.body;
1476
- throwDefaultError({
1441
+ return throwDefaultError({
1477
1442
  output,
1478
1443
  parsedBody,
1479
- exceptionCtor: __BaseException,
1480
1444
  errorCode,
1481
1445
  });
1482
1446
  }
@@ -1489,9 +1453,10 @@ export const de_CreateGatewayCommand = async (output, context) => {
1489
1453
  $metadata: deserializeMetadata(output),
1490
1454
  });
1491
1455
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1492
- if (data.gateway != null) {
1493
- contents.Gateway = de_Gateway(data.gateway, context);
1494
- }
1456
+ const doc = take(data, {
1457
+ Gateway: [, (_) => de_Gateway(_, context), `gateway`],
1458
+ });
1459
+ Object.assign(contents, doc);
1495
1460
  return contents;
1496
1461
  };
1497
1462
  const de_CreateGatewayCommandError = async (output, context) => {
@@ -1524,10 +1489,9 @@ const de_CreateGatewayCommandError = async (output, context) => {
1524
1489
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1525
1490
  default:
1526
1491
  const parsedBody = parsedOutput.body;
1527
- throwDefaultError({
1492
+ return throwDefaultError({
1528
1493
  output,
1529
1494
  parsedBody,
1530
- exceptionCtor: __BaseException,
1531
1495
  errorCode,
1532
1496
  });
1533
1497
  }
@@ -1540,9 +1504,10 @@ export const de_DeleteBridgeCommand = async (output, context) => {
1540
1504
  $metadata: deserializeMetadata(output),
1541
1505
  });
1542
1506
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1543
- if (data.bridgeArn != null) {
1544
- contents.BridgeArn = __expectString(data.bridgeArn);
1545
- }
1507
+ const doc = take(data, {
1508
+ BridgeArn: [, __expectString, `bridgeArn`],
1509
+ });
1510
+ Object.assign(contents, doc);
1546
1511
  return contents;
1547
1512
  };
1548
1513
  const de_DeleteBridgeCommandError = async (output, context) => {
@@ -1575,10 +1540,9 @@ const de_DeleteBridgeCommandError = async (output, context) => {
1575
1540
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1576
1541
  default:
1577
1542
  const parsedBody = parsedOutput.body;
1578
- throwDefaultError({
1543
+ return throwDefaultError({
1579
1544
  output,
1580
1545
  parsedBody,
1581
- exceptionCtor: __BaseException,
1582
1546
  errorCode,
1583
1547
  });
1584
1548
  }
@@ -1591,12 +1555,11 @@ export const de_DeleteFlowCommand = async (output, context) => {
1591
1555
  $metadata: deserializeMetadata(output),
1592
1556
  });
1593
1557
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1594
- if (data.flowArn != null) {
1595
- contents.FlowArn = __expectString(data.flowArn);
1596
- }
1597
- if (data.status != null) {
1598
- contents.Status = __expectString(data.status);
1599
- }
1558
+ const doc = take(data, {
1559
+ FlowArn: [, __expectString, `flowArn`],
1560
+ Status: [, __expectString, `status`],
1561
+ });
1562
+ Object.assign(contents, doc);
1600
1563
  return contents;
1601
1564
  };
1602
1565
  const de_DeleteFlowCommandError = async (output, context) => {
@@ -1626,10 +1589,9 @@ const de_DeleteFlowCommandError = async (output, context) => {
1626
1589
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1627
1590
  default:
1628
1591
  const parsedBody = parsedOutput.body;
1629
- throwDefaultError({
1592
+ return throwDefaultError({
1630
1593
  output,
1631
1594
  parsedBody,
1632
- exceptionCtor: __BaseException,
1633
1595
  errorCode,
1634
1596
  });
1635
1597
  }
@@ -1642,9 +1604,10 @@ export const de_DeleteGatewayCommand = async (output, context) => {
1642
1604
  $metadata: deserializeMetadata(output),
1643
1605
  });
1644
1606
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1645
- if (data.gatewayArn != null) {
1646
- contents.GatewayArn = __expectString(data.gatewayArn);
1647
- }
1607
+ const doc = take(data, {
1608
+ GatewayArn: [, __expectString, `gatewayArn`],
1609
+ });
1610
+ Object.assign(contents, doc);
1648
1611
  return contents;
1649
1612
  };
1650
1613
  const de_DeleteGatewayCommandError = async (output, context) => {
@@ -1677,10 +1640,9 @@ const de_DeleteGatewayCommandError = async (output, context) => {
1677
1640
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1678
1641
  default:
1679
1642
  const parsedBody = parsedOutput.body;
1680
- throwDefaultError({
1643
+ return throwDefaultError({
1681
1644
  output,
1682
1645
  parsedBody,
1683
- exceptionCtor: __BaseException,
1684
1646
  errorCode,
1685
1647
  });
1686
1648
  }
@@ -1693,12 +1655,11 @@ export const de_DeregisterGatewayInstanceCommand = async (output, context) => {
1693
1655
  $metadata: deserializeMetadata(output),
1694
1656
  });
1695
1657
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1696
- if (data.gatewayInstanceArn != null) {
1697
- contents.GatewayInstanceArn = __expectString(data.gatewayInstanceArn);
1698
- }
1699
- if (data.instanceState != null) {
1700
- contents.InstanceState = __expectString(data.instanceState);
1701
- }
1658
+ const doc = take(data, {
1659
+ GatewayInstanceArn: [, __expectString, `gatewayInstanceArn`],
1660
+ InstanceState: [, __expectString, `instanceState`],
1661
+ });
1662
+ Object.assign(contents, doc);
1702
1663
  return contents;
1703
1664
  };
1704
1665
  const de_DeregisterGatewayInstanceCommandError = async (output, context) => {
@@ -1731,10 +1692,9 @@ const de_DeregisterGatewayInstanceCommandError = async (output, context) => {
1731
1692
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1732
1693
  default:
1733
1694
  const parsedBody = parsedOutput.body;
1734
- throwDefaultError({
1695
+ return throwDefaultError({
1735
1696
  output,
1736
1697
  parsedBody,
1737
- exceptionCtor: __BaseException,
1738
1698
  errorCode,
1739
1699
  });
1740
1700
  }
@@ -1747,9 +1707,10 @@ export const de_DescribeBridgeCommand = async (output, context) => {
1747
1707
  $metadata: deserializeMetadata(output),
1748
1708
  });
1749
1709
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1750
- if (data.bridge != null) {
1751
- contents.Bridge = de_Bridge(data.bridge, context);
1752
- }
1710
+ const doc = take(data, {
1711
+ Bridge: [, (_) => de_Bridge(_, context), `bridge`],
1712
+ });
1713
+ Object.assign(contents, doc);
1753
1714
  return contents;
1754
1715
  };
1755
1716
  const de_DescribeBridgeCommandError = async (output, context) => {
@@ -1782,10 +1743,9 @@ const de_DescribeBridgeCommandError = async (output, context) => {
1782
1743
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1783
1744
  default:
1784
1745
  const parsedBody = parsedOutput.body;
1785
- throwDefaultError({
1746
+ return throwDefaultError({
1786
1747
  output,
1787
1748
  parsedBody,
1788
- exceptionCtor: __BaseException,
1789
1749
  errorCode,
1790
1750
  });
1791
1751
  }
@@ -1798,12 +1758,11 @@ export const de_DescribeFlowCommand = async (output, context) => {
1798
1758
  $metadata: deserializeMetadata(output),
1799
1759
  });
1800
1760
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1801
- if (data.flow != null) {
1802
- contents.Flow = de_Flow(data.flow, context);
1803
- }
1804
- if (data.messages != null) {
1805
- contents.Messages = de_Messages(data.messages, context);
1806
- }
1761
+ const doc = take(data, {
1762
+ Flow: [, (_) => de_Flow(_, context), `flow`],
1763
+ Messages: [, (_) => de_Messages(_, context), `messages`],
1764
+ });
1765
+ Object.assign(contents, doc);
1807
1766
  return contents;
1808
1767
  };
1809
1768
  const de_DescribeFlowCommandError = async (output, context) => {
@@ -1833,10 +1792,9 @@ const de_DescribeFlowCommandError = async (output, context) => {
1833
1792
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1834
1793
  default:
1835
1794
  const parsedBody = parsedOutput.body;
1836
- throwDefaultError({
1795
+ return throwDefaultError({
1837
1796
  output,
1838
1797
  parsedBody,
1839
- exceptionCtor: __BaseException,
1840
1798
  errorCode,
1841
1799
  });
1842
1800
  }
@@ -1849,9 +1807,10 @@ export const de_DescribeGatewayCommand = async (output, context) => {
1849
1807
  $metadata: deserializeMetadata(output),
1850
1808
  });
1851
1809
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1852
- if (data.gateway != null) {
1853
- contents.Gateway = de_Gateway(data.gateway, context);
1854
- }
1810
+ const doc = take(data, {
1811
+ Gateway: [, (_) => de_Gateway(_, context), `gateway`],
1812
+ });
1813
+ Object.assign(contents, doc);
1855
1814
  return contents;
1856
1815
  };
1857
1816
  const de_DescribeGatewayCommandError = async (output, context) => {
@@ -1884,10 +1843,9 @@ const de_DescribeGatewayCommandError = async (output, context) => {
1884
1843
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1885
1844
  default:
1886
1845
  const parsedBody = parsedOutput.body;
1887
- throwDefaultError({
1846
+ return throwDefaultError({
1888
1847
  output,
1889
1848
  parsedBody,
1890
- exceptionCtor: __BaseException,
1891
1849
  errorCode,
1892
1850
  });
1893
1851
  }
@@ -1900,9 +1858,10 @@ export const de_DescribeGatewayInstanceCommand = async (output, context) => {
1900
1858
  $metadata: deserializeMetadata(output),
1901
1859
  });
1902
1860
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1903
- if (data.gatewayInstance != null) {
1904
- contents.GatewayInstance = de_GatewayInstance(data.gatewayInstance, context);
1905
- }
1861
+ const doc = take(data, {
1862
+ GatewayInstance: [, (_) => de_GatewayInstance(_, context), `gatewayInstance`],
1863
+ });
1864
+ Object.assign(contents, doc);
1906
1865
  return contents;
1907
1866
  };
1908
1867
  const de_DescribeGatewayInstanceCommandError = async (output, context) => {
@@ -1935,10 +1894,9 @@ const de_DescribeGatewayInstanceCommandError = async (output, context) => {
1935
1894
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1936
1895
  default:
1937
1896
  const parsedBody = parsedOutput.body;
1938
- throwDefaultError({
1897
+ return throwDefaultError({
1939
1898
  output,
1940
1899
  parsedBody,
1941
- exceptionCtor: __BaseException,
1942
1900
  errorCode,
1943
1901
  });
1944
1902
  }
@@ -1951,9 +1909,10 @@ export const de_DescribeOfferingCommand = async (output, context) => {
1951
1909
  $metadata: deserializeMetadata(output),
1952
1910
  });
1953
1911
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1954
- if (data.offering != null) {
1955
- contents.Offering = de_Offering(data.offering, context);
1956
- }
1912
+ const doc = take(data, {
1913
+ Offering: [, (_) => de_Offering(_, context), `offering`],
1914
+ });
1915
+ Object.assign(contents, doc);
1957
1916
  return contents;
1958
1917
  };
1959
1918
  const de_DescribeOfferingCommandError = async (output, context) => {
@@ -1980,10 +1939,9 @@ const de_DescribeOfferingCommandError = async (output, context) => {
1980
1939
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1981
1940
  default:
1982
1941
  const parsedBody = parsedOutput.body;
1983
- throwDefaultError({
1942
+ return throwDefaultError({
1984
1943
  output,
1985
1944
  parsedBody,
1986
- exceptionCtor: __BaseException,
1987
1945
  errorCode,
1988
1946
  });
1989
1947
  }
@@ -1996,9 +1954,10 @@ export const de_DescribeReservationCommand = async (output, context) => {
1996
1954
  $metadata: deserializeMetadata(output),
1997
1955
  });
1998
1956
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1999
- if (data.reservation != null) {
2000
- contents.Reservation = de_Reservation(data.reservation, context);
2001
- }
1957
+ const doc = take(data, {
1958
+ Reservation: [, (_) => de_Reservation(_, context), `reservation`],
1959
+ });
1960
+ Object.assign(contents, doc);
2002
1961
  return contents;
2003
1962
  };
2004
1963
  const de_DescribeReservationCommandError = async (output, context) => {
@@ -2025,10 +1984,9 @@ const de_DescribeReservationCommandError = async (output, context) => {
2025
1984
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
2026
1985
  default:
2027
1986
  const parsedBody = parsedOutput.body;
2028
- throwDefaultError({
1987
+ return throwDefaultError({
2029
1988
  output,
2030
1989
  parsedBody,
2031
- exceptionCtor: __BaseException,
2032
1990
  errorCode,
2033
1991
  });
2034
1992
  }
@@ -2041,12 +1999,11 @@ export const de_GrantFlowEntitlementsCommand = async (output, context) => {
2041
1999
  $metadata: deserializeMetadata(output),
2042
2000
  });
2043
2001
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
2044
- if (data.entitlements != null) {
2045
- contents.Entitlements = de___listOfEntitlement(data.entitlements, context);
2046
- }
2047
- if (data.flowArn != null) {
2048
- contents.FlowArn = __expectString(data.flowArn);
2049
- }
2002
+ const doc = take(data, {
2003
+ Entitlements: [, (_) => de___listOfEntitlement(_, context), `entitlements`],
2004
+ FlowArn: [, __expectString, `flowArn`],
2005
+ });
2006
+ Object.assign(contents, doc);
2050
2007
  return contents;
2051
2008
  };
2052
2009
  const de_GrantFlowEntitlementsCommandError = async (output, context) => {
@@ -2079,10 +2036,9 @@ const de_GrantFlowEntitlementsCommandError = async (output, context) => {
2079
2036
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
2080
2037
  default:
2081
2038
  const parsedBody = parsedOutput.body;
2082
- throwDefaultError({
2039
+ return throwDefaultError({
2083
2040
  output,
2084
2041
  parsedBody,
2085
- exceptionCtor: __BaseException,
2086
2042
  errorCode,
2087
2043
  });
2088
2044
  }
@@ -2095,12 +2051,11 @@ export const de_ListBridgesCommand = async (output, context) => {
2095
2051
  $metadata: deserializeMetadata(output),
2096
2052
  });
2097
2053
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
2098
- if (data.bridges != null) {
2099
- contents.Bridges = de___listOfListedBridge(data.bridges, context);
2100
- }
2101
- if (data.nextToken != null) {
2102
- contents.NextToken = __expectString(data.nextToken);
2103
- }
2054
+ const doc = take(data, {
2055
+ Bridges: [, (_) => de___listOfListedBridge(_, context), `bridges`],
2056
+ NextToken: [, __expectString, `nextToken`],
2057
+ });
2058
+ Object.assign(contents, doc);
2104
2059
  return contents;
2105
2060
  };
2106
2061
  const de_ListBridgesCommandError = async (output, context) => {
@@ -2127,10 +2082,9 @@ const de_ListBridgesCommandError = async (output, context) => {
2127
2082
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
2128
2083
  default:
2129
2084
  const parsedBody = parsedOutput.body;
2130
- throwDefaultError({
2085
+ return throwDefaultError({
2131
2086
  output,
2132
2087
  parsedBody,
2133
- exceptionCtor: __BaseException,
2134
2088
  errorCode,
2135
2089
  });
2136
2090
  }
@@ -2143,12 +2097,11 @@ export const de_ListEntitlementsCommand = async (output, context) => {
2143
2097
  $metadata: deserializeMetadata(output),
2144
2098
  });
2145
2099
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
2146
- if (data.entitlements != null) {
2147
- contents.Entitlements = de___listOfListedEntitlement(data.entitlements, context);
2148
- }
2149
- if (data.nextToken != null) {
2150
- contents.NextToken = __expectString(data.nextToken);
2151
- }
2100
+ const doc = take(data, {
2101
+ Entitlements: [, (_) => de___listOfListedEntitlement(_, context), `entitlements`],
2102
+ NextToken: [, __expectString, `nextToken`],
2103
+ });
2104
+ Object.assign(contents, doc);
2152
2105
  return contents;
2153
2106
  };
2154
2107
  const de_ListEntitlementsCommandError = async (output, context) => {
@@ -2172,10 +2125,9 @@ const de_ListEntitlementsCommandError = async (output, context) => {
2172
2125
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
2173
2126
  default:
2174
2127
  const parsedBody = parsedOutput.body;
2175
- throwDefaultError({
2128
+ return throwDefaultError({
2176
2129
  output,
2177
2130
  parsedBody,
2178
- exceptionCtor: __BaseException,
2179
2131
  errorCode,
2180
2132
  });
2181
2133
  }
@@ -2188,12 +2140,11 @@ export const de_ListFlowsCommand = async (output, context) => {
2188
2140
  $metadata: deserializeMetadata(output),
2189
2141
  });
2190
2142
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
2191
- if (data.flows != null) {
2192
- contents.Flows = de___listOfListedFlow(data.flows, context);
2193
- }
2194
- if (data.nextToken != null) {
2195
- contents.NextToken = __expectString(data.nextToken);
2196
- }
2143
+ const doc = take(data, {
2144
+ Flows: [, (_) => de___listOfListedFlow(_, context), `flows`],
2145
+ NextToken: [, __expectString, `nextToken`],
2146
+ });
2147
+ Object.assign(contents, doc);
2197
2148
  return contents;
2198
2149
  };
2199
2150
  const de_ListFlowsCommandError = async (output, context) => {
@@ -2217,10 +2168,9 @@ const de_ListFlowsCommandError = async (output, context) => {
2217
2168
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
2218
2169
  default:
2219
2170
  const parsedBody = parsedOutput.body;
2220
- throwDefaultError({
2171
+ return throwDefaultError({
2221
2172
  output,
2222
2173
  parsedBody,
2223
- exceptionCtor: __BaseException,
2224
2174
  errorCode,
2225
2175
  });
2226
2176
  }
@@ -2233,12 +2183,11 @@ export const de_ListGatewayInstancesCommand = async (output, context) => {
2233
2183
  $metadata: deserializeMetadata(output),
2234
2184
  });
2235
2185
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
2236
- if (data.instances != null) {
2237
- contents.Instances = de___listOfListedGatewayInstance(data.instances, context);
2238
- }
2239
- if (data.nextToken != null) {
2240
- contents.NextToken = __expectString(data.nextToken);
2241
- }
2186
+ const doc = take(data, {
2187
+ Instances: [, (_) => de___listOfListedGatewayInstance(_, context), `instances`],
2188
+ NextToken: [, __expectString, `nextToken`],
2189
+ });
2190
+ Object.assign(contents, doc);
2242
2191
  return contents;
2243
2192
  };
2244
2193
  const de_ListGatewayInstancesCommandError = async (output, context) => {
@@ -2265,10 +2214,9 @@ const de_ListGatewayInstancesCommandError = async (output, context) => {
2265
2214
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
2266
2215
  default:
2267
2216
  const parsedBody = parsedOutput.body;
2268
- throwDefaultError({
2217
+ return throwDefaultError({
2269
2218
  output,
2270
2219
  parsedBody,
2271
- exceptionCtor: __BaseException,
2272
2220
  errorCode,
2273
2221
  });
2274
2222
  }
@@ -2281,12 +2229,11 @@ export const de_ListGatewaysCommand = async (output, context) => {
2281
2229
  $metadata: deserializeMetadata(output),
2282
2230
  });
2283
2231
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
2284
- if (data.gateways != null) {
2285
- contents.Gateways = de___listOfListedGateway(data.gateways, context);
2286
- }
2287
- if (data.nextToken != null) {
2288
- contents.NextToken = __expectString(data.nextToken);
2289
- }
2232
+ const doc = take(data, {
2233
+ Gateways: [, (_) => de___listOfListedGateway(_, context), `gateways`],
2234
+ NextToken: [, __expectString, `nextToken`],
2235
+ });
2236
+ Object.assign(contents, doc);
2290
2237
  return contents;
2291
2238
  };
2292
2239
  const de_ListGatewaysCommandError = async (output, context) => {
@@ -2313,10 +2260,9 @@ const de_ListGatewaysCommandError = async (output, context) => {
2313
2260
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
2314
2261
  default:
2315
2262
  const parsedBody = parsedOutput.body;
2316
- throwDefaultError({
2263
+ return throwDefaultError({
2317
2264
  output,
2318
2265
  parsedBody,
2319
- exceptionCtor: __BaseException,
2320
2266
  errorCode,
2321
2267
  });
2322
2268
  }
@@ -2329,12 +2275,11 @@ export const de_ListOfferingsCommand = async (output, context) => {
2329
2275
  $metadata: deserializeMetadata(output),
2330
2276
  });
2331
2277
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
2332
- if (data.nextToken != null) {
2333
- contents.NextToken = __expectString(data.nextToken);
2334
- }
2335
- if (data.offerings != null) {
2336
- contents.Offerings = de___listOfOffering(data.offerings, context);
2337
- }
2278
+ const doc = take(data, {
2279
+ NextToken: [, __expectString, `nextToken`],
2280
+ Offerings: [, (_) => de___listOfOffering(_, context), `offerings`],
2281
+ });
2282
+ Object.assign(contents, doc);
2338
2283
  return contents;
2339
2284
  };
2340
2285
  const de_ListOfferingsCommandError = async (output, context) => {
@@ -2358,10 +2303,9 @@ const de_ListOfferingsCommandError = async (output, context) => {
2358
2303
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
2359
2304
  default:
2360
2305
  const parsedBody = parsedOutput.body;
2361
- throwDefaultError({
2306
+ return throwDefaultError({
2362
2307
  output,
2363
2308
  parsedBody,
2364
- exceptionCtor: __BaseException,
2365
2309
  errorCode,
2366
2310
  });
2367
2311
  }
@@ -2374,12 +2318,11 @@ export const de_ListReservationsCommand = async (output, context) => {
2374
2318
  $metadata: deserializeMetadata(output),
2375
2319
  });
2376
2320
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
2377
- if (data.nextToken != null) {
2378
- contents.NextToken = __expectString(data.nextToken);
2379
- }
2380
- if (data.reservations != null) {
2381
- contents.Reservations = de___listOfReservation(data.reservations, context);
2382
- }
2321
+ const doc = take(data, {
2322
+ NextToken: [, __expectString, `nextToken`],
2323
+ Reservations: [, (_) => de___listOfReservation(_, context), `reservations`],
2324
+ });
2325
+ Object.assign(contents, doc);
2383
2326
  return contents;
2384
2327
  };
2385
2328
  const de_ListReservationsCommandError = async (output, context) => {
@@ -2403,10 +2346,9 @@ const de_ListReservationsCommandError = async (output, context) => {
2403
2346
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
2404
2347
  default:
2405
2348
  const parsedBody = parsedOutput.body;
2406
- throwDefaultError({
2349
+ return throwDefaultError({
2407
2350
  output,
2408
2351
  parsedBody,
2409
- exceptionCtor: __BaseException,
2410
2352
  errorCode,
2411
2353
  });
2412
2354
  }
@@ -2419,9 +2361,10 @@ export const de_ListTagsForResourceCommand = async (output, context) => {
2419
2361
  $metadata: deserializeMetadata(output),
2420
2362
  });
2421
2363
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
2422
- if (data.tags != null) {
2423
- contents.Tags = de___mapOf__string(data.tags, context);
2424
- }
2364
+ const doc = take(data, {
2365
+ Tags: [, _json, `tags`],
2366
+ });
2367
+ Object.assign(contents, doc);
2425
2368
  return contents;
2426
2369
  };
2427
2370
  const de_ListTagsForResourceCommandError = async (output, context) => {
@@ -2442,10 +2385,9 @@ const de_ListTagsForResourceCommandError = async (output, context) => {
2442
2385
  throw await de_NotFoundExceptionRes(parsedOutput, context);
2443
2386
  default:
2444
2387
  const parsedBody = parsedOutput.body;
2445
- throwDefaultError({
2388
+ return throwDefaultError({
2446
2389
  output,
2447
2390
  parsedBody,
2448
- exceptionCtor: __BaseException,
2449
2391
  errorCode,
2450
2392
  });
2451
2393
  }
@@ -2458,9 +2400,10 @@ export const de_PurchaseOfferingCommand = async (output, context) => {
2458
2400
  $metadata: deserializeMetadata(output),
2459
2401
  });
2460
2402
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
2461
- if (data.reservation != null) {
2462
- contents.Reservation = de_Reservation(data.reservation, context);
2463
- }
2403
+ const doc = take(data, {
2404
+ Reservation: [, (_) => de_Reservation(_, context), `reservation`],
2405
+ });
2406
+ Object.assign(contents, doc);
2464
2407
  return contents;
2465
2408
  };
2466
2409
  const de_PurchaseOfferingCommandError = async (output, context) => {
@@ -2490,10 +2433,9 @@ const de_PurchaseOfferingCommandError = async (output, context) => {
2490
2433
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
2491
2434
  default:
2492
2435
  const parsedBody = parsedOutput.body;
2493
- throwDefaultError({
2436
+ return throwDefaultError({
2494
2437
  output,
2495
2438
  parsedBody,
2496
- exceptionCtor: __BaseException,
2497
2439
  errorCode,
2498
2440
  });
2499
2441
  }
@@ -2506,12 +2448,11 @@ export const de_RemoveBridgeOutputCommand = async (output, context) => {
2506
2448
  $metadata: deserializeMetadata(output),
2507
2449
  });
2508
2450
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
2509
- if (data.bridgeArn != null) {
2510
- contents.BridgeArn = __expectString(data.bridgeArn);
2511
- }
2512
- if (data.outputName != null) {
2513
- contents.OutputName = __expectString(data.outputName);
2514
- }
2451
+ const doc = take(data, {
2452
+ BridgeArn: [, __expectString, `bridgeArn`],
2453
+ OutputName: [, __expectString, `outputName`],
2454
+ });
2455
+ Object.assign(contents, doc);
2515
2456
  return contents;
2516
2457
  };
2517
2458
  const de_RemoveBridgeOutputCommandError = async (output, context) => {
@@ -2544,10 +2485,9 @@ const de_RemoveBridgeOutputCommandError = async (output, context) => {
2544
2485
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
2545
2486
  default:
2546
2487
  const parsedBody = parsedOutput.body;
2547
- throwDefaultError({
2488
+ return throwDefaultError({
2548
2489
  output,
2549
2490
  parsedBody,
2550
- exceptionCtor: __BaseException,
2551
2491
  errorCode,
2552
2492
  });
2553
2493
  }
@@ -2560,12 +2500,11 @@ export const de_RemoveBridgeSourceCommand = async (output, context) => {
2560
2500
  $metadata: deserializeMetadata(output),
2561
2501
  });
2562
2502
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
2563
- if (data.bridgeArn != null) {
2564
- contents.BridgeArn = __expectString(data.bridgeArn);
2565
- }
2566
- if (data.sourceName != null) {
2567
- contents.SourceName = __expectString(data.sourceName);
2568
- }
2503
+ const doc = take(data, {
2504
+ BridgeArn: [, __expectString, `bridgeArn`],
2505
+ SourceName: [, __expectString, `sourceName`],
2506
+ });
2507
+ Object.assign(contents, doc);
2569
2508
  return contents;
2570
2509
  };
2571
2510
  const de_RemoveBridgeSourceCommandError = async (output, context) => {
@@ -2598,10 +2537,9 @@ const de_RemoveBridgeSourceCommandError = async (output, context) => {
2598
2537
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
2599
2538
  default:
2600
2539
  const parsedBody = parsedOutput.body;
2601
- throwDefaultError({
2540
+ return throwDefaultError({
2602
2541
  output,
2603
2542
  parsedBody,
2604
- exceptionCtor: __BaseException,
2605
2543
  errorCode,
2606
2544
  });
2607
2545
  }
@@ -2614,12 +2552,11 @@ export const de_RemoveFlowMediaStreamCommand = async (output, context) => {
2614
2552
  $metadata: deserializeMetadata(output),
2615
2553
  });
2616
2554
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
2617
- if (data.flowArn != null) {
2618
- contents.FlowArn = __expectString(data.flowArn);
2619
- }
2620
- if (data.mediaStreamName != null) {
2621
- contents.MediaStreamName = __expectString(data.mediaStreamName);
2622
- }
2555
+ const doc = take(data, {
2556
+ FlowArn: [, __expectString, `flowArn`],
2557
+ MediaStreamName: [, __expectString, `mediaStreamName`],
2558
+ });
2559
+ Object.assign(contents, doc);
2623
2560
  return contents;
2624
2561
  };
2625
2562
  const de_RemoveFlowMediaStreamCommandError = async (output, context) => {
@@ -2649,10 +2586,9 @@ const de_RemoveFlowMediaStreamCommandError = async (output, context) => {
2649
2586
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
2650
2587
  default:
2651
2588
  const parsedBody = parsedOutput.body;
2652
- throwDefaultError({
2589
+ return throwDefaultError({
2653
2590
  output,
2654
2591
  parsedBody,
2655
- exceptionCtor: __BaseException,
2656
2592
  errorCode,
2657
2593
  });
2658
2594
  }
@@ -2665,12 +2601,11 @@ export const de_RemoveFlowOutputCommand = async (output, context) => {
2665
2601
  $metadata: deserializeMetadata(output),
2666
2602
  });
2667
2603
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
2668
- if (data.flowArn != null) {
2669
- contents.FlowArn = __expectString(data.flowArn);
2670
- }
2671
- if (data.outputArn != null) {
2672
- contents.OutputArn = __expectString(data.outputArn);
2673
- }
2604
+ const doc = take(data, {
2605
+ FlowArn: [, __expectString, `flowArn`],
2606
+ OutputArn: [, __expectString, `outputArn`],
2607
+ });
2608
+ Object.assign(contents, doc);
2674
2609
  return contents;
2675
2610
  };
2676
2611
  const de_RemoveFlowOutputCommandError = async (output, context) => {
@@ -2700,10 +2635,9 @@ const de_RemoveFlowOutputCommandError = async (output, context) => {
2700
2635
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
2701
2636
  default:
2702
2637
  const parsedBody = parsedOutput.body;
2703
- throwDefaultError({
2638
+ return throwDefaultError({
2704
2639
  output,
2705
2640
  parsedBody,
2706
- exceptionCtor: __BaseException,
2707
2641
  errorCode,
2708
2642
  });
2709
2643
  }
@@ -2716,12 +2650,11 @@ export const de_RemoveFlowSourceCommand = async (output, context) => {
2716
2650
  $metadata: deserializeMetadata(output),
2717
2651
  });
2718
2652
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
2719
- if (data.flowArn != null) {
2720
- contents.FlowArn = __expectString(data.flowArn);
2721
- }
2722
- if (data.sourceArn != null) {
2723
- contents.SourceArn = __expectString(data.sourceArn);
2724
- }
2653
+ const doc = take(data, {
2654
+ FlowArn: [, __expectString, `flowArn`],
2655
+ SourceArn: [, __expectString, `sourceArn`],
2656
+ });
2657
+ Object.assign(contents, doc);
2725
2658
  return contents;
2726
2659
  };
2727
2660
  const de_RemoveFlowSourceCommandError = async (output, context) => {
@@ -2751,10 +2684,9 @@ const de_RemoveFlowSourceCommandError = async (output, context) => {
2751
2684
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
2752
2685
  default:
2753
2686
  const parsedBody = parsedOutput.body;
2754
- throwDefaultError({
2687
+ return throwDefaultError({
2755
2688
  output,
2756
2689
  parsedBody,
2757
- exceptionCtor: __BaseException,
2758
2690
  errorCode,
2759
2691
  });
2760
2692
  }
@@ -2767,15 +2699,12 @@ export const de_RemoveFlowVpcInterfaceCommand = async (output, context) => {
2767
2699
  $metadata: deserializeMetadata(output),
2768
2700
  });
2769
2701
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
2770
- if (data.flowArn != null) {
2771
- contents.FlowArn = __expectString(data.flowArn);
2772
- }
2773
- if (data.nonDeletedNetworkInterfaceIds != null) {
2774
- contents.NonDeletedNetworkInterfaceIds = de___listOf__string(data.nonDeletedNetworkInterfaceIds, context);
2775
- }
2776
- if (data.vpcInterfaceName != null) {
2777
- contents.VpcInterfaceName = __expectString(data.vpcInterfaceName);
2778
- }
2702
+ const doc = take(data, {
2703
+ FlowArn: [, __expectString, `flowArn`],
2704
+ NonDeletedNetworkInterfaceIds: [, _json, `nonDeletedNetworkInterfaceIds`],
2705
+ VpcInterfaceName: [, __expectString, `vpcInterfaceName`],
2706
+ });
2707
+ Object.assign(contents, doc);
2779
2708
  return contents;
2780
2709
  };
2781
2710
  const de_RemoveFlowVpcInterfaceCommandError = async (output, context) => {
@@ -2805,10 +2734,9 @@ const de_RemoveFlowVpcInterfaceCommandError = async (output, context) => {
2805
2734
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
2806
2735
  default:
2807
2736
  const parsedBody = parsedOutput.body;
2808
- throwDefaultError({
2737
+ return throwDefaultError({
2809
2738
  output,
2810
2739
  parsedBody,
2811
- exceptionCtor: __BaseException,
2812
2740
  errorCode,
2813
2741
  });
2814
2742
  }
@@ -2821,12 +2749,11 @@ export const de_RevokeFlowEntitlementCommand = async (output, context) => {
2821
2749
  $metadata: deserializeMetadata(output),
2822
2750
  });
2823
2751
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
2824
- if (data.entitlementArn != null) {
2825
- contents.EntitlementArn = __expectString(data.entitlementArn);
2826
- }
2827
- if (data.flowArn != null) {
2828
- contents.FlowArn = __expectString(data.flowArn);
2829
- }
2752
+ const doc = take(data, {
2753
+ EntitlementArn: [, __expectString, `entitlementArn`],
2754
+ FlowArn: [, __expectString, `flowArn`],
2755
+ });
2756
+ Object.assign(contents, doc);
2830
2757
  return contents;
2831
2758
  };
2832
2759
  const de_RevokeFlowEntitlementCommandError = async (output, context) => {
@@ -2856,10 +2783,9 @@ const de_RevokeFlowEntitlementCommandError = async (output, context) => {
2856
2783
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
2857
2784
  default:
2858
2785
  const parsedBody = parsedOutput.body;
2859
- throwDefaultError({
2786
+ return throwDefaultError({
2860
2787
  output,
2861
2788
  parsedBody,
2862
- exceptionCtor: __BaseException,
2863
2789
  errorCode,
2864
2790
  });
2865
2791
  }
@@ -2872,12 +2798,11 @@ export const de_StartFlowCommand = async (output, context) => {
2872
2798
  $metadata: deserializeMetadata(output),
2873
2799
  });
2874
2800
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
2875
- if (data.flowArn != null) {
2876
- contents.FlowArn = __expectString(data.flowArn);
2877
- }
2878
- if (data.status != null) {
2879
- contents.Status = __expectString(data.status);
2880
- }
2801
+ const doc = take(data, {
2802
+ FlowArn: [, __expectString, `flowArn`],
2803
+ Status: [, __expectString, `status`],
2804
+ });
2805
+ Object.assign(contents, doc);
2881
2806
  return contents;
2882
2807
  };
2883
2808
  const de_StartFlowCommandError = async (output, context) => {
@@ -2907,10 +2832,9 @@ const de_StartFlowCommandError = async (output, context) => {
2907
2832
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
2908
2833
  default:
2909
2834
  const parsedBody = parsedOutput.body;
2910
- throwDefaultError({
2835
+ return throwDefaultError({
2911
2836
  output,
2912
2837
  parsedBody,
2913
- exceptionCtor: __BaseException,
2914
2838
  errorCode,
2915
2839
  });
2916
2840
  }
@@ -2923,12 +2847,11 @@ export const de_StopFlowCommand = async (output, context) => {
2923
2847
  $metadata: deserializeMetadata(output),
2924
2848
  });
2925
2849
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
2926
- if (data.flowArn != null) {
2927
- contents.FlowArn = __expectString(data.flowArn);
2928
- }
2929
- if (data.status != null) {
2930
- contents.Status = __expectString(data.status);
2931
- }
2850
+ const doc = take(data, {
2851
+ FlowArn: [, __expectString, `flowArn`],
2852
+ Status: [, __expectString, `status`],
2853
+ });
2854
+ Object.assign(contents, doc);
2932
2855
  return contents;
2933
2856
  };
2934
2857
  const de_StopFlowCommandError = async (output, context) => {
@@ -2958,10 +2881,9 @@ const de_StopFlowCommandError = async (output, context) => {
2958
2881
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
2959
2882
  default:
2960
2883
  const parsedBody = parsedOutput.body;
2961
- throwDefaultError({
2884
+ return throwDefaultError({
2962
2885
  output,
2963
2886
  parsedBody,
2964
- exceptionCtor: __BaseException,
2965
2887
  errorCode,
2966
2888
  });
2967
2889
  }
@@ -2994,10 +2916,9 @@ const de_TagResourceCommandError = async (output, context) => {
2994
2916
  throw await de_NotFoundExceptionRes(parsedOutput, context);
2995
2917
  default:
2996
2918
  const parsedBody = parsedOutput.body;
2997
- throwDefaultError({
2919
+ return throwDefaultError({
2998
2920
  output,
2999
2921
  parsedBody,
3000
- exceptionCtor: __BaseException,
3001
2922
  errorCode,
3002
2923
  });
3003
2924
  }
@@ -3030,10 +2951,9 @@ const de_UntagResourceCommandError = async (output, context) => {
3030
2951
  throw await de_NotFoundExceptionRes(parsedOutput, context);
3031
2952
  default:
3032
2953
  const parsedBody = parsedOutput.body;
3033
- throwDefaultError({
2954
+ return throwDefaultError({
3034
2955
  output,
3035
2956
  parsedBody,
3036
- exceptionCtor: __BaseException,
3037
2957
  errorCode,
3038
2958
  });
3039
2959
  }
@@ -3046,9 +2966,10 @@ export const de_UpdateBridgeCommand = async (output, context) => {
3046
2966
  $metadata: deserializeMetadata(output),
3047
2967
  });
3048
2968
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
3049
- if (data.bridge != null) {
3050
- contents.Bridge = de_Bridge(data.bridge, context);
3051
- }
2969
+ const doc = take(data, {
2970
+ Bridge: [, (_) => de_Bridge(_, context), `bridge`],
2971
+ });
2972
+ Object.assign(contents, doc);
3052
2973
  return contents;
3053
2974
  };
3054
2975
  const de_UpdateBridgeCommandError = async (output, context) => {
@@ -3081,10 +3002,9 @@ const de_UpdateBridgeCommandError = async (output, context) => {
3081
3002
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
3082
3003
  default:
3083
3004
  const parsedBody = parsedOutput.body;
3084
- throwDefaultError({
3005
+ return throwDefaultError({
3085
3006
  output,
3086
3007
  parsedBody,
3087
- exceptionCtor: __BaseException,
3088
3008
  errorCode,
3089
3009
  });
3090
3010
  }
@@ -3097,12 +3017,11 @@ export const de_UpdateBridgeOutputCommand = async (output, context) => {
3097
3017
  $metadata: deserializeMetadata(output),
3098
3018
  });
3099
3019
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
3100
- if (data.bridgeArn != null) {
3101
- contents.BridgeArn = __expectString(data.bridgeArn);
3102
- }
3103
- if (data.output != null) {
3104
- contents.Output = de_BridgeOutput(data.output, context);
3105
- }
3020
+ const doc = take(data, {
3021
+ BridgeArn: [, __expectString, `bridgeArn`],
3022
+ Output: [, (_) => de_BridgeOutput(_, context), `output`],
3023
+ });
3024
+ Object.assign(contents, doc);
3106
3025
  return contents;
3107
3026
  };
3108
3027
  const de_UpdateBridgeOutputCommandError = async (output, context) => {
@@ -3135,10 +3054,9 @@ const de_UpdateBridgeOutputCommandError = async (output, context) => {
3135
3054
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
3136
3055
  default:
3137
3056
  const parsedBody = parsedOutput.body;
3138
- throwDefaultError({
3057
+ return throwDefaultError({
3139
3058
  output,
3140
3059
  parsedBody,
3141
- exceptionCtor: __BaseException,
3142
3060
  errorCode,
3143
3061
  });
3144
3062
  }
@@ -3151,12 +3069,11 @@ export const de_UpdateBridgeSourceCommand = async (output, context) => {
3151
3069
  $metadata: deserializeMetadata(output),
3152
3070
  });
3153
3071
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
3154
- if (data.bridgeArn != null) {
3155
- contents.BridgeArn = __expectString(data.bridgeArn);
3156
- }
3157
- if (data.source != null) {
3158
- contents.Source = de_BridgeSource(data.source, context);
3159
- }
3072
+ const doc = take(data, {
3073
+ BridgeArn: [, __expectString, `bridgeArn`],
3074
+ Source: [, (_) => de_BridgeSource(_, context), `source`],
3075
+ });
3076
+ Object.assign(contents, doc);
3160
3077
  return contents;
3161
3078
  };
3162
3079
  const de_UpdateBridgeSourceCommandError = async (output, context) => {
@@ -3189,10 +3106,9 @@ const de_UpdateBridgeSourceCommandError = async (output, context) => {
3189
3106
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
3190
3107
  default:
3191
3108
  const parsedBody = parsedOutput.body;
3192
- throwDefaultError({
3109
+ return throwDefaultError({
3193
3110
  output,
3194
3111
  parsedBody,
3195
- exceptionCtor: __BaseException,
3196
3112
  errorCode,
3197
3113
  });
3198
3114
  }
@@ -3205,12 +3121,11 @@ export const de_UpdateBridgeStateCommand = async (output, context) => {
3205
3121
  $metadata: deserializeMetadata(output),
3206
3122
  });
3207
3123
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
3208
- if (data.bridgeArn != null) {
3209
- contents.BridgeArn = __expectString(data.bridgeArn);
3210
- }
3211
- if (data.desiredState != null) {
3212
- contents.DesiredState = __expectString(data.desiredState);
3213
- }
3124
+ const doc = take(data, {
3125
+ BridgeArn: [, __expectString, `bridgeArn`],
3126
+ DesiredState: [, __expectString, `desiredState`],
3127
+ });
3128
+ Object.assign(contents, doc);
3214
3129
  return contents;
3215
3130
  };
3216
3131
  const de_UpdateBridgeStateCommandError = async (output, context) => {
@@ -3243,10 +3158,9 @@ const de_UpdateBridgeStateCommandError = async (output, context) => {
3243
3158
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
3244
3159
  default:
3245
3160
  const parsedBody = parsedOutput.body;
3246
- throwDefaultError({
3161
+ return throwDefaultError({
3247
3162
  output,
3248
3163
  parsedBody,
3249
- exceptionCtor: __BaseException,
3250
3164
  errorCode,
3251
3165
  });
3252
3166
  }
@@ -3259,9 +3173,10 @@ export const de_UpdateFlowCommand = async (output, context) => {
3259
3173
  $metadata: deserializeMetadata(output),
3260
3174
  });
3261
3175
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
3262
- if (data.flow != null) {
3263
- contents.Flow = de_Flow(data.flow, context);
3264
- }
3176
+ const doc = take(data, {
3177
+ Flow: [, (_) => de_Flow(_, context), `flow`],
3178
+ });
3179
+ Object.assign(contents, doc);
3265
3180
  return contents;
3266
3181
  };
3267
3182
  const de_UpdateFlowCommandError = async (output, context) => {
@@ -3291,10 +3206,9 @@ const de_UpdateFlowCommandError = async (output, context) => {
3291
3206
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
3292
3207
  default:
3293
3208
  const parsedBody = parsedOutput.body;
3294
- throwDefaultError({
3209
+ return throwDefaultError({
3295
3210
  output,
3296
3211
  parsedBody,
3297
- exceptionCtor: __BaseException,
3298
3212
  errorCode,
3299
3213
  });
3300
3214
  }
@@ -3307,12 +3221,11 @@ export const de_UpdateFlowEntitlementCommand = async (output, context) => {
3307
3221
  $metadata: deserializeMetadata(output),
3308
3222
  });
3309
3223
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
3310
- if (data.entitlement != null) {
3311
- contents.Entitlement = de_Entitlement(data.entitlement, context);
3312
- }
3313
- if (data.flowArn != null) {
3314
- contents.FlowArn = __expectString(data.flowArn);
3315
- }
3224
+ const doc = take(data, {
3225
+ Entitlement: [, (_) => de_Entitlement(_, context), `entitlement`],
3226
+ FlowArn: [, __expectString, `flowArn`],
3227
+ });
3228
+ Object.assign(contents, doc);
3316
3229
  return contents;
3317
3230
  };
3318
3231
  const de_UpdateFlowEntitlementCommandError = async (output, context) => {
@@ -3342,10 +3255,9 @@ const de_UpdateFlowEntitlementCommandError = async (output, context) => {
3342
3255
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
3343
3256
  default:
3344
3257
  const parsedBody = parsedOutput.body;
3345
- throwDefaultError({
3258
+ return throwDefaultError({
3346
3259
  output,
3347
3260
  parsedBody,
3348
- exceptionCtor: __BaseException,
3349
3261
  errorCode,
3350
3262
  });
3351
3263
  }
@@ -3358,12 +3270,11 @@ export const de_UpdateFlowMediaStreamCommand = async (output, context) => {
3358
3270
  $metadata: deserializeMetadata(output),
3359
3271
  });
3360
3272
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
3361
- if (data.flowArn != null) {
3362
- contents.FlowArn = __expectString(data.flowArn);
3363
- }
3364
- if (data.mediaStream != null) {
3365
- contents.MediaStream = de_MediaStream(data.mediaStream, context);
3366
- }
3273
+ const doc = take(data, {
3274
+ FlowArn: [, __expectString, `flowArn`],
3275
+ MediaStream: [, (_) => de_MediaStream(_, context), `mediaStream`],
3276
+ });
3277
+ Object.assign(contents, doc);
3367
3278
  return contents;
3368
3279
  };
3369
3280
  const de_UpdateFlowMediaStreamCommandError = async (output, context) => {
@@ -3393,10 +3304,9 @@ const de_UpdateFlowMediaStreamCommandError = async (output, context) => {
3393
3304
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
3394
3305
  default:
3395
3306
  const parsedBody = parsedOutput.body;
3396
- throwDefaultError({
3307
+ return throwDefaultError({
3397
3308
  output,
3398
3309
  parsedBody,
3399
- exceptionCtor: __BaseException,
3400
3310
  errorCode,
3401
3311
  });
3402
3312
  }
@@ -3409,12 +3319,11 @@ export const de_UpdateFlowOutputCommand = async (output, context) => {
3409
3319
  $metadata: deserializeMetadata(output),
3410
3320
  });
3411
3321
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
3412
- if (data.flowArn != null) {
3413
- contents.FlowArn = __expectString(data.flowArn);
3414
- }
3415
- if (data.output != null) {
3416
- contents.Output = de_Output(data.output, context);
3417
- }
3322
+ const doc = take(data, {
3323
+ FlowArn: [, __expectString, `flowArn`],
3324
+ Output: [, (_) => de_Output(_, context), `output`],
3325
+ });
3326
+ Object.assign(contents, doc);
3418
3327
  return contents;
3419
3328
  };
3420
3329
  const de_UpdateFlowOutputCommandError = async (output, context) => {
@@ -3444,10 +3353,9 @@ const de_UpdateFlowOutputCommandError = async (output, context) => {
3444
3353
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
3445
3354
  default:
3446
3355
  const parsedBody = parsedOutput.body;
3447
- throwDefaultError({
3356
+ return throwDefaultError({
3448
3357
  output,
3449
3358
  parsedBody,
3450
- exceptionCtor: __BaseException,
3451
3359
  errorCode,
3452
3360
  });
3453
3361
  }
@@ -3460,12 +3368,11 @@ export const de_UpdateFlowSourceCommand = async (output, context) => {
3460
3368
  $metadata: deserializeMetadata(output),
3461
3369
  });
3462
3370
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
3463
- if (data.flowArn != null) {
3464
- contents.FlowArn = __expectString(data.flowArn);
3465
- }
3466
- if (data.source != null) {
3467
- contents.Source = de_Source(data.source, context);
3468
- }
3371
+ const doc = take(data, {
3372
+ FlowArn: [, __expectString, `flowArn`],
3373
+ Source: [, (_) => de_Source(_, context), `source`],
3374
+ });
3375
+ Object.assign(contents, doc);
3469
3376
  return contents;
3470
3377
  };
3471
3378
  const de_UpdateFlowSourceCommandError = async (output, context) => {
@@ -3495,10 +3402,9 @@ const de_UpdateFlowSourceCommandError = async (output, context) => {
3495
3402
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
3496
3403
  default:
3497
3404
  const parsedBody = parsedOutput.body;
3498
- throwDefaultError({
3405
+ return throwDefaultError({
3499
3406
  output,
3500
3407
  parsedBody,
3501
- exceptionCtor: __BaseException,
3502
3408
  errorCode,
3503
3409
  });
3504
3410
  }
@@ -3511,12 +3417,11 @@ export const de_UpdateGatewayInstanceCommand = async (output, context) => {
3511
3417
  $metadata: deserializeMetadata(output),
3512
3418
  });
3513
3419
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
3514
- if (data.bridgePlacement != null) {
3515
- contents.BridgePlacement = __expectString(data.bridgePlacement);
3516
- }
3517
- if (data.gatewayInstanceArn != null) {
3518
- contents.GatewayInstanceArn = __expectString(data.gatewayInstanceArn);
3519
- }
3420
+ const doc = take(data, {
3421
+ BridgePlacement: [, __expectString, `bridgePlacement`],
3422
+ GatewayInstanceArn: [, __expectString, `gatewayInstanceArn`],
3423
+ });
3424
+ Object.assign(contents, doc);
3520
3425
  return contents;
3521
3426
  };
3522
3427
  const de_UpdateGatewayInstanceCommandError = async (output, context) => {
@@ -3549,21 +3454,21 @@ const de_UpdateGatewayInstanceCommandError = async (output, context) => {
3549
3454
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
3550
3455
  default:
3551
3456
  const parsedBody = parsedOutput.body;
3552
- throwDefaultError({
3457
+ return throwDefaultError({
3553
3458
  output,
3554
3459
  parsedBody,
3555
- exceptionCtor: __BaseException,
3556
3460
  errorCode,
3557
3461
  });
3558
3462
  }
3559
3463
  };
3560
- const map = __map;
3464
+ const throwDefaultError = withBaseException(__BaseException);
3561
3465
  const de_AddFlowOutputs420ExceptionRes = async (parsedOutput, context) => {
3562
3466
  const contents = map({});
3563
3467
  const data = parsedOutput.body;
3564
- if (data.message != null) {
3565
- contents.Message = __expectString(data.message);
3566
- }
3468
+ const doc = take(data, {
3469
+ Message: [, __expectString, `message`],
3470
+ });
3471
+ Object.assign(contents, doc);
3567
3472
  const exception = new AddFlowOutputs420Exception({
3568
3473
  $metadata: deserializeMetadata(parsedOutput),
3569
3474
  ...contents,
@@ -3573,9 +3478,10 @@ const de_AddFlowOutputs420ExceptionRes = async (parsedOutput, context) => {
3573
3478
  const de_BadRequestExceptionRes = async (parsedOutput, context) => {
3574
3479
  const contents = map({});
3575
3480
  const data = parsedOutput.body;
3576
- if (data.message != null) {
3577
- contents.Message = __expectString(data.message);
3578
- }
3481
+ const doc = take(data, {
3482
+ Message: [, __expectString, `message`],
3483
+ });
3484
+ Object.assign(contents, doc);
3579
3485
  const exception = new BadRequestException({
3580
3486
  $metadata: deserializeMetadata(parsedOutput),
3581
3487
  ...contents,
@@ -3585,9 +3491,10 @@ const de_BadRequestExceptionRes = async (parsedOutput, context) => {
3585
3491
  const de_ConflictExceptionRes = async (parsedOutput, context) => {
3586
3492
  const contents = map({});
3587
3493
  const data = parsedOutput.body;
3588
- if (data.message != null) {
3589
- contents.Message = __expectString(data.message);
3590
- }
3494
+ const doc = take(data, {
3495
+ Message: [, __expectString, `message`],
3496
+ });
3497
+ Object.assign(contents, doc);
3591
3498
  const exception = new ConflictException({
3592
3499
  $metadata: deserializeMetadata(parsedOutput),
3593
3500
  ...contents,
@@ -3597,9 +3504,10 @@ const de_ConflictExceptionRes = async (parsedOutput, context) => {
3597
3504
  const de_CreateBridge420ExceptionRes = async (parsedOutput, context) => {
3598
3505
  const contents = map({});
3599
3506
  const data = parsedOutput.body;
3600
- if (data.message != null) {
3601
- contents.Message = __expectString(data.message);
3602
- }
3507
+ const doc = take(data, {
3508
+ Message: [, __expectString, `message`],
3509
+ });
3510
+ Object.assign(contents, doc);
3603
3511
  const exception = new CreateBridge420Exception({
3604
3512
  $metadata: deserializeMetadata(parsedOutput),
3605
3513
  ...contents,
@@ -3609,9 +3517,10 @@ const de_CreateBridge420ExceptionRes = async (parsedOutput, context) => {
3609
3517
  const de_CreateFlow420ExceptionRes = async (parsedOutput, context) => {
3610
3518
  const contents = map({});
3611
3519
  const data = parsedOutput.body;
3612
- if (data.message != null) {
3613
- contents.Message = __expectString(data.message);
3614
- }
3520
+ const doc = take(data, {
3521
+ Message: [, __expectString, `message`],
3522
+ });
3523
+ Object.assign(contents, doc);
3615
3524
  const exception = new CreateFlow420Exception({
3616
3525
  $metadata: deserializeMetadata(parsedOutput),
3617
3526
  ...contents,
@@ -3621,9 +3530,10 @@ const de_CreateFlow420ExceptionRes = async (parsedOutput, context) => {
3621
3530
  const de_CreateGateway420ExceptionRes = async (parsedOutput, context) => {
3622
3531
  const contents = map({});
3623
3532
  const data = parsedOutput.body;
3624
- if (data.message != null) {
3625
- contents.Message = __expectString(data.message);
3626
- }
3533
+ const doc = take(data, {
3534
+ Message: [, __expectString, `message`],
3535
+ });
3536
+ Object.assign(contents, doc);
3627
3537
  const exception = new CreateGateway420Exception({
3628
3538
  $metadata: deserializeMetadata(parsedOutput),
3629
3539
  ...contents,
@@ -3633,9 +3543,10 @@ const de_CreateGateway420ExceptionRes = async (parsedOutput, context) => {
3633
3543
  const de_ForbiddenExceptionRes = async (parsedOutput, context) => {
3634
3544
  const contents = map({});
3635
3545
  const data = parsedOutput.body;
3636
- if (data.message != null) {
3637
- contents.Message = __expectString(data.message);
3638
- }
3546
+ const doc = take(data, {
3547
+ Message: [, __expectString, `message`],
3548
+ });
3549
+ Object.assign(contents, doc);
3639
3550
  const exception = new ForbiddenException({
3640
3551
  $metadata: deserializeMetadata(parsedOutput),
3641
3552
  ...contents,
@@ -3645,9 +3556,10 @@ const de_ForbiddenExceptionRes = async (parsedOutput, context) => {
3645
3556
  const de_GrantFlowEntitlements420ExceptionRes = async (parsedOutput, context) => {
3646
3557
  const contents = map({});
3647
3558
  const data = parsedOutput.body;
3648
- if (data.message != null) {
3649
- contents.Message = __expectString(data.message);
3650
- }
3559
+ const doc = take(data, {
3560
+ Message: [, __expectString, `message`],
3561
+ });
3562
+ Object.assign(contents, doc);
3651
3563
  const exception = new GrantFlowEntitlements420Exception({
3652
3564
  $metadata: deserializeMetadata(parsedOutput),
3653
3565
  ...contents,
@@ -3657,9 +3569,10 @@ const de_GrantFlowEntitlements420ExceptionRes = async (parsedOutput, context) =>
3657
3569
  const de_InternalServerErrorExceptionRes = async (parsedOutput, context) => {
3658
3570
  const contents = map({});
3659
3571
  const data = parsedOutput.body;
3660
- if (data.message != null) {
3661
- contents.Message = __expectString(data.message);
3662
- }
3572
+ const doc = take(data, {
3573
+ Message: [, __expectString, `message`],
3574
+ });
3575
+ Object.assign(contents, doc);
3663
3576
  const exception = new InternalServerErrorException({
3664
3577
  $metadata: deserializeMetadata(parsedOutput),
3665
3578
  ...contents,
@@ -3669,9 +3582,10 @@ const de_InternalServerErrorExceptionRes = async (parsedOutput, context) => {
3669
3582
  const de_NotFoundExceptionRes = async (parsedOutput, context) => {
3670
3583
  const contents = map({});
3671
3584
  const data = parsedOutput.body;
3672
- if (data.message != null) {
3673
- contents.Message = __expectString(data.message);
3674
- }
3585
+ const doc = take(data, {
3586
+ Message: [, __expectString, `message`],
3587
+ });
3588
+ Object.assign(contents, doc);
3675
3589
  const exception = new NotFoundException({
3676
3590
  $metadata: deserializeMetadata(parsedOutput),
3677
3591
  ...contents,
@@ -3681,9 +3595,10 @@ const de_NotFoundExceptionRes = async (parsedOutput, context) => {
3681
3595
  const de_ServiceUnavailableExceptionRes = async (parsedOutput, context) => {
3682
3596
  const contents = map({});
3683
3597
  const data = parsedOutput.body;
3684
- if (data.message != null) {
3685
- contents.Message = __expectString(data.message);
3686
- }
3598
+ const doc = take(data, {
3599
+ Message: [, __expectString, `message`],
3600
+ });
3601
+ Object.assign(contents, doc);
3687
3602
  const exception = new ServiceUnavailableException({
3688
3603
  $metadata: deserializeMetadata(parsedOutput),
3689
3604
  ...contents,
@@ -3693,22 +3608,16 @@ const de_ServiceUnavailableExceptionRes = async (parsedOutput, context) => {
3693
3608
  const de_TooManyRequestsExceptionRes = async (parsedOutput, context) => {
3694
3609
  const contents = map({});
3695
3610
  const data = parsedOutput.body;
3696
- if (data.message != null) {
3697
- contents.Message = __expectString(data.message);
3698
- }
3611
+ const doc = take(data, {
3612
+ Message: [, __expectString, `message`],
3613
+ });
3614
+ Object.assign(contents, doc);
3699
3615
  const exception = new TooManyRequestsException({
3700
3616
  $metadata: deserializeMetadata(parsedOutput),
3701
3617
  ...contents,
3702
3618
  });
3703
3619
  return __decorateServiceException(exception, parsedOutput.body);
3704
3620
  };
3705
- const se___listOf__string = (input, context) => {
3706
- return input
3707
- .filter((e) => e != null)
3708
- .map((entry) => {
3709
- return entry;
3710
- });
3711
- };
3712
3621
  const se___listOfAddBridgeOutputRequest = (input, context) => {
3713
3622
  return input
3714
3623
  .filter((e) => e != null)
@@ -3793,369 +3702,315 @@ const se___listOfVpcInterfaceRequest = (input, context) => {
3793
3702
  return se_VpcInterfaceRequest(entry, context);
3794
3703
  });
3795
3704
  };
3796
- const se___mapOf__string = (input, context) => {
3797
- return Object.entries(input).reduce((acc, [key, value]) => {
3798
- if (value === null) {
3799
- return acc;
3800
- }
3801
- acc[key] = value;
3802
- return acc;
3803
- }, {});
3804
- };
3805
3705
  const se_AddBridgeFlowSourceRequest = (input, context) => {
3806
- return {
3807
- ...(input.FlowArn != null && { flowArn: input.FlowArn }),
3808
- ...(input.FlowVpcInterfaceAttachment != null && {
3809
- flowVpcInterfaceAttachment: se_VpcInterfaceAttachment(input.FlowVpcInterfaceAttachment, context),
3810
- }),
3811
- ...(input.Name != null && { name: input.Name }),
3812
- };
3706
+ return take(input, {
3707
+ flowArn: [, , `FlowArn`],
3708
+ flowVpcInterfaceAttachment: [, (_) => se_VpcInterfaceAttachment(_, context), `FlowVpcInterfaceAttachment`],
3709
+ name: [, , `Name`],
3710
+ });
3813
3711
  };
3814
3712
  const se_AddBridgeNetworkOutputRequest = (input, context) => {
3815
- return {
3816
- ...(input.IpAddress != null && { ipAddress: input.IpAddress }),
3817
- ...(input.Name != null && { name: input.Name }),
3818
- ...(input.NetworkName != null && { networkName: input.NetworkName }),
3819
- ...(input.Port != null && { port: input.Port }),
3820
- ...(input.Protocol != null && { protocol: input.Protocol }),
3821
- ...(input.Ttl != null && { ttl: input.Ttl }),
3822
- };
3713
+ return take(input, {
3714
+ ipAddress: [, , `IpAddress`],
3715
+ name: [, , `Name`],
3716
+ networkName: [, , `NetworkName`],
3717
+ port: [, , `Port`],
3718
+ protocol: [, , `Protocol`],
3719
+ ttl: [, , `Ttl`],
3720
+ });
3823
3721
  };
3824
3722
  const se_AddBridgeNetworkSourceRequest = (input, context) => {
3825
- return {
3826
- ...(input.MulticastIp != null && { multicastIp: input.MulticastIp }),
3827
- ...(input.Name != null && { name: input.Name }),
3828
- ...(input.NetworkName != null && { networkName: input.NetworkName }),
3829
- ...(input.Port != null && { port: input.Port }),
3830
- ...(input.Protocol != null && { protocol: input.Protocol }),
3831
- };
3723
+ return take(input, {
3724
+ multicastIp: [, , `MulticastIp`],
3725
+ name: [, , `Name`],
3726
+ networkName: [, , `NetworkName`],
3727
+ port: [, , `Port`],
3728
+ protocol: [, , `Protocol`],
3729
+ });
3832
3730
  };
3833
3731
  const se_AddBridgeOutputRequest = (input, context) => {
3834
- return {
3835
- ...(input.NetworkOutput != null && {
3836
- networkOutput: se_AddBridgeNetworkOutputRequest(input.NetworkOutput, context),
3837
- }),
3838
- };
3732
+ return take(input, {
3733
+ networkOutput: [, (_) => se_AddBridgeNetworkOutputRequest(_, context), `NetworkOutput`],
3734
+ });
3839
3735
  };
3840
3736
  const se_AddBridgeSourceRequest = (input, context) => {
3841
- return {
3842
- ...(input.FlowSource != null && { flowSource: se_AddBridgeFlowSourceRequest(input.FlowSource, context) }),
3843
- ...(input.NetworkSource != null && {
3844
- networkSource: se_AddBridgeNetworkSourceRequest(input.NetworkSource, context),
3845
- }),
3846
- };
3737
+ return take(input, {
3738
+ flowSource: [, (_) => se_AddBridgeFlowSourceRequest(_, context), `FlowSource`],
3739
+ networkSource: [, (_) => se_AddBridgeNetworkSourceRequest(_, context), `NetworkSource`],
3740
+ });
3847
3741
  };
3848
3742
  const se_AddEgressGatewayBridgeRequest = (input, context) => {
3849
- return {
3850
- ...(input.MaxBitrate != null && { maxBitrate: input.MaxBitrate }),
3851
- };
3743
+ return take(input, {
3744
+ maxBitrate: [, , `MaxBitrate`],
3745
+ });
3852
3746
  };
3853
3747
  const se_AddIngressGatewayBridgeRequest = (input, context) => {
3854
- return {
3855
- ...(input.MaxBitrate != null && { maxBitrate: input.MaxBitrate }),
3856
- ...(input.MaxOutputs != null && { maxOutputs: input.MaxOutputs }),
3857
- };
3748
+ return take(input, {
3749
+ maxBitrate: [, , `MaxBitrate`],
3750
+ maxOutputs: [, , `MaxOutputs`],
3751
+ });
3858
3752
  };
3859
3753
  const se_AddMaintenance = (input, context) => {
3860
- return {
3861
- ...(input.MaintenanceDay != null && { maintenanceDay: input.MaintenanceDay }),
3862
- ...(input.MaintenanceStartHour != null && { maintenanceStartHour: input.MaintenanceStartHour }),
3863
- };
3754
+ return take(input, {
3755
+ maintenanceDay: [, , `MaintenanceDay`],
3756
+ maintenanceStartHour: [, , `MaintenanceStartHour`],
3757
+ });
3864
3758
  };
3865
3759
  const se_AddMediaStreamRequest = (input, context) => {
3866
- return {
3867
- ...(input.Attributes != null && { attributes: se_MediaStreamAttributesRequest(input.Attributes, context) }),
3868
- ...(input.ClockRate != null && { clockRate: input.ClockRate }),
3869
- ...(input.Description != null && { description: input.Description }),
3870
- ...(input.MediaStreamId != null && { mediaStreamId: input.MediaStreamId }),
3871
- ...(input.MediaStreamName != null && { mediaStreamName: input.MediaStreamName }),
3872
- ...(input.MediaStreamType != null && { mediaStreamType: input.MediaStreamType }),
3873
- ...(input.VideoFormat != null && { videoFormat: input.VideoFormat }),
3874
- };
3760
+ return take(input, {
3761
+ attributes: [, (_) => se_MediaStreamAttributesRequest(_, context), `Attributes`],
3762
+ clockRate: [, , `ClockRate`],
3763
+ description: [, , `Description`],
3764
+ mediaStreamId: [, , `MediaStreamId`],
3765
+ mediaStreamName: [, , `MediaStreamName`],
3766
+ mediaStreamType: [, , `MediaStreamType`],
3767
+ videoFormat: [, , `VideoFormat`],
3768
+ });
3875
3769
  };
3876
3770
  const se_AddOutputRequest = (input, context) => {
3877
- return {
3878
- ...(input.CidrAllowList != null && { cidrAllowList: se___listOf__string(input.CidrAllowList, context) }),
3879
- ...(input.Description != null && { description: input.Description }),
3880
- ...(input.Destination != null && { destination: input.Destination }),
3881
- ...(input.Encryption != null && { encryption: se_Encryption(input.Encryption, context) }),
3882
- ...(input.MaxLatency != null && { maxLatency: input.MaxLatency }),
3883
- ...(input.MediaStreamOutputConfigurations != null && {
3884
- mediaStreamOutputConfigurations: se___listOfMediaStreamOutputConfigurationRequest(input.MediaStreamOutputConfigurations, context),
3885
- }),
3886
- ...(input.MinLatency != null && { minLatency: input.MinLatency }),
3887
- ...(input.Name != null && { name: input.Name }),
3888
- ...(input.Port != null && { port: input.Port }),
3889
- ...(input.Protocol != null && { protocol: input.Protocol }),
3890
- ...(input.RemoteId != null && { remoteId: input.RemoteId }),
3891
- ...(input.SenderControlPort != null && { senderControlPort: input.SenderControlPort }),
3892
- ...(input.SmoothingLatency != null && { smoothingLatency: input.SmoothingLatency }),
3893
- ...(input.StreamId != null && { streamId: input.StreamId }),
3894
- ...(input.VpcInterfaceAttachment != null && {
3895
- vpcInterfaceAttachment: se_VpcInterfaceAttachment(input.VpcInterfaceAttachment, context),
3896
- }),
3897
- };
3771
+ return take(input, {
3772
+ cidrAllowList: [, _json, `CidrAllowList`],
3773
+ description: [, , `Description`],
3774
+ destination: [, , `Destination`],
3775
+ encryption: [, (_) => se_Encryption(_, context), `Encryption`],
3776
+ maxLatency: [, , `MaxLatency`],
3777
+ mediaStreamOutputConfigurations: [
3778
+ ,
3779
+ (_) => se___listOfMediaStreamOutputConfigurationRequest(_, context),
3780
+ `MediaStreamOutputConfigurations`,
3781
+ ],
3782
+ minLatency: [, , `MinLatency`],
3783
+ name: [, , `Name`],
3784
+ port: [, , `Port`],
3785
+ protocol: [, , `Protocol`],
3786
+ remoteId: [, , `RemoteId`],
3787
+ senderControlPort: [, , `SenderControlPort`],
3788
+ smoothingLatency: [, , `SmoothingLatency`],
3789
+ streamId: [, , `StreamId`],
3790
+ vpcInterfaceAttachment: [, (_) => se_VpcInterfaceAttachment(_, context), `VpcInterfaceAttachment`],
3791
+ });
3898
3792
  };
3899
3793
  const se_DestinationConfigurationRequest = (input, context) => {
3900
- return {
3901
- ...(input.DestinationIp != null && { destinationIp: input.DestinationIp }),
3902
- ...(input.DestinationPort != null && { destinationPort: input.DestinationPort }),
3903
- ...(input.Interface != null && { interface: se_InterfaceRequest(input.Interface, context) }),
3904
- };
3794
+ return take(input, {
3795
+ destinationIp: [, , `DestinationIp`],
3796
+ destinationPort: [, , `DestinationPort`],
3797
+ interface: [, (_) => se_InterfaceRequest(_, context), `Interface`],
3798
+ });
3905
3799
  };
3906
3800
  const se_EncodingParametersRequest = (input, context) => {
3907
- return {
3908
- ...(input.CompressionFactor != null && { compressionFactor: __serializeFloat(input.CompressionFactor) }),
3909
- ...(input.EncoderProfile != null && { encoderProfile: input.EncoderProfile }),
3910
- };
3801
+ return take(input, {
3802
+ compressionFactor: [, __serializeFloat, `CompressionFactor`],
3803
+ encoderProfile: [, , `EncoderProfile`],
3804
+ });
3911
3805
  };
3912
3806
  const se_Encryption = (input, context) => {
3913
- return {
3914
- ...(input.Algorithm != null && { algorithm: input.Algorithm }),
3915
- ...(input.ConstantInitializationVector != null && {
3916
- constantInitializationVector: input.ConstantInitializationVector,
3917
- }),
3918
- ...(input.DeviceId != null && { deviceId: input.DeviceId }),
3919
- ...(input.KeyType != null && { keyType: input.KeyType }),
3920
- ...(input.Region != null && { region: input.Region }),
3921
- ...(input.ResourceId != null && { resourceId: input.ResourceId }),
3922
- ...(input.RoleArn != null && { roleArn: input.RoleArn }),
3923
- ...(input.SecretArn != null && { secretArn: input.SecretArn }),
3924
- ...(input.Url != null && { url: input.Url }),
3925
- };
3807
+ return take(input, {
3808
+ algorithm: [, , `Algorithm`],
3809
+ constantInitializationVector: [, , `ConstantInitializationVector`],
3810
+ deviceId: [, , `DeviceId`],
3811
+ keyType: [, , `KeyType`],
3812
+ region: [, , `Region`],
3813
+ resourceId: [, , `ResourceId`],
3814
+ roleArn: [, , `RoleArn`],
3815
+ secretArn: [, , `SecretArn`],
3816
+ url: [, , `Url`],
3817
+ });
3926
3818
  };
3927
3819
  const se_FailoverConfig = (input, context) => {
3928
- return {
3929
- ...(input.FailoverMode != null && { failoverMode: input.FailoverMode }),
3930
- ...(input.RecoveryWindow != null && { recoveryWindow: input.RecoveryWindow }),
3931
- ...(input.SourcePriority != null && { sourcePriority: se_SourcePriority(input.SourcePriority, context) }),
3932
- ...(input.State != null && { state: input.State }),
3933
- };
3820
+ return take(input, {
3821
+ failoverMode: [, , `FailoverMode`],
3822
+ recoveryWindow: [, , `RecoveryWindow`],
3823
+ sourcePriority: [, (_) => se_SourcePriority(_, context), `SourcePriority`],
3824
+ state: [, , `State`],
3825
+ });
3934
3826
  };
3935
3827
  const se_FmtpRequest = (input, context) => {
3936
- return {
3937
- ...(input.ChannelOrder != null && { channelOrder: input.ChannelOrder }),
3938
- ...(input.Colorimetry != null && { colorimetry: input.Colorimetry }),
3939
- ...(input.ExactFramerate != null && { exactFramerate: input.ExactFramerate }),
3940
- ...(input.Par != null && { par: input.Par }),
3941
- ...(input.Range != null && { range: input.Range }),
3942
- ...(input.ScanMode != null && { scanMode: input.ScanMode }),
3943
- ...(input.Tcs != null && { tcs: input.Tcs }),
3944
- };
3828
+ return take(input, {
3829
+ channelOrder: [, , `ChannelOrder`],
3830
+ colorimetry: [, , `Colorimetry`],
3831
+ exactFramerate: [, , `ExactFramerate`],
3832
+ par: [, , `Par`],
3833
+ range: [, , `Range`],
3834
+ scanMode: [, , `ScanMode`],
3835
+ tcs: [, , `Tcs`],
3836
+ });
3945
3837
  };
3946
3838
  const se_GatewayNetwork = (input, context) => {
3947
- return {
3948
- ...(input.CidrBlock != null && { cidrBlock: input.CidrBlock }),
3949
- ...(input.Name != null && { name: input.Name }),
3950
- };
3839
+ return take(input, {
3840
+ cidrBlock: [, , `CidrBlock`],
3841
+ name: [, , `Name`],
3842
+ });
3951
3843
  };
3952
3844
  const se_GrantEntitlementRequest = (input, context) => {
3953
- return {
3954
- ...(input.DataTransferSubscriberFeePercent != null && {
3955
- dataTransferSubscriberFeePercent: input.DataTransferSubscriberFeePercent,
3956
- }),
3957
- ...(input.Description != null && { description: input.Description }),
3958
- ...(input.Encryption != null && { encryption: se_Encryption(input.Encryption, context) }),
3959
- ...(input.EntitlementStatus != null && { entitlementStatus: input.EntitlementStatus }),
3960
- ...(input.Name != null && { name: input.Name }),
3961
- ...(input.Subscribers != null && { subscribers: se___listOf__string(input.Subscribers, context) }),
3962
- };
3845
+ return take(input, {
3846
+ dataTransferSubscriberFeePercent: [, , `DataTransferSubscriberFeePercent`],
3847
+ description: [, , `Description`],
3848
+ encryption: [, (_) => se_Encryption(_, context), `Encryption`],
3849
+ entitlementStatus: [, , `EntitlementStatus`],
3850
+ name: [, , `Name`],
3851
+ subscribers: [, _json, `Subscribers`],
3852
+ });
3963
3853
  };
3964
3854
  const se_InputConfigurationRequest = (input, context) => {
3965
- return {
3966
- ...(input.InputPort != null && { inputPort: input.InputPort }),
3967
- ...(input.Interface != null && { interface: se_InterfaceRequest(input.Interface, context) }),
3968
- };
3855
+ return take(input, {
3856
+ inputPort: [, , `InputPort`],
3857
+ interface: [, (_) => se_InterfaceRequest(_, context), `Interface`],
3858
+ });
3969
3859
  };
3970
3860
  const se_InterfaceRequest = (input, context) => {
3971
- return {
3972
- ...(input.Name != null && { name: input.Name }),
3973
- };
3861
+ return take(input, {
3862
+ name: [, , `Name`],
3863
+ });
3974
3864
  };
3975
3865
  const se_MediaStreamAttributesRequest = (input, context) => {
3976
- return {
3977
- ...(input.Fmtp != null && { fmtp: se_FmtpRequest(input.Fmtp, context) }),
3978
- ...(input.Lang != null && { lang: input.Lang }),
3979
- };
3866
+ return take(input, {
3867
+ fmtp: [, (_) => se_FmtpRequest(_, context), `Fmtp`],
3868
+ lang: [, , `Lang`],
3869
+ });
3980
3870
  };
3981
3871
  const se_MediaStreamOutputConfigurationRequest = (input, context) => {
3982
- return {
3983
- ...(input.DestinationConfigurations != null && {
3984
- destinationConfigurations: se___listOfDestinationConfigurationRequest(input.DestinationConfigurations, context),
3985
- }),
3986
- ...(input.EncodingName != null && { encodingName: input.EncodingName }),
3987
- ...(input.EncodingParameters != null && {
3988
- encodingParameters: se_EncodingParametersRequest(input.EncodingParameters, context),
3989
- }),
3990
- ...(input.MediaStreamName != null && { mediaStreamName: input.MediaStreamName }),
3991
- };
3872
+ return take(input, {
3873
+ destinationConfigurations: [
3874
+ ,
3875
+ (_) => se___listOfDestinationConfigurationRequest(_, context),
3876
+ `DestinationConfigurations`,
3877
+ ],
3878
+ encodingName: [, , `EncodingName`],
3879
+ encodingParameters: [, (_) => se_EncodingParametersRequest(_, context), `EncodingParameters`],
3880
+ mediaStreamName: [, , `MediaStreamName`],
3881
+ });
3992
3882
  };
3993
3883
  const se_MediaStreamSourceConfigurationRequest = (input, context) => {
3994
- return {
3995
- ...(input.EncodingName != null && { encodingName: input.EncodingName }),
3996
- ...(input.InputConfigurations != null && {
3997
- inputConfigurations: se___listOfInputConfigurationRequest(input.InputConfigurations, context),
3998
- }),
3999
- ...(input.MediaStreamName != null && { mediaStreamName: input.MediaStreamName }),
4000
- };
3884
+ return take(input, {
3885
+ encodingName: [, , `EncodingName`],
3886
+ inputConfigurations: [, (_) => se___listOfInputConfigurationRequest(_, context), `InputConfigurations`],
3887
+ mediaStreamName: [, , `MediaStreamName`],
3888
+ });
4001
3889
  };
4002
3890
  const se_SetGatewayBridgeSourceRequest = (input, context) => {
4003
- return {
4004
- ...(input.BridgeArn != null && { bridgeArn: input.BridgeArn }),
4005
- ...(input.VpcInterfaceAttachment != null && {
4006
- vpcInterfaceAttachment: se_VpcInterfaceAttachment(input.VpcInterfaceAttachment, context),
4007
- }),
4008
- };
3891
+ return take(input, {
3892
+ bridgeArn: [, , `BridgeArn`],
3893
+ vpcInterfaceAttachment: [, (_) => se_VpcInterfaceAttachment(_, context), `VpcInterfaceAttachment`],
3894
+ });
4009
3895
  };
4010
3896
  const se_SetSourceRequest = (input, context) => {
4011
- return {
4012
- ...(input.Decryption != null && { decryption: se_Encryption(input.Decryption, context) }),
4013
- ...(input.Description != null && { description: input.Description }),
4014
- ...(input.EntitlementArn != null && { entitlementArn: input.EntitlementArn }),
4015
- ...(input.GatewayBridgeSource != null && {
4016
- gatewayBridgeSource: se_SetGatewayBridgeSourceRequest(input.GatewayBridgeSource, context),
4017
- }),
4018
- ...(input.IngestPort != null && { ingestPort: input.IngestPort }),
4019
- ...(input.MaxBitrate != null && { maxBitrate: input.MaxBitrate }),
4020
- ...(input.MaxLatency != null && { maxLatency: input.MaxLatency }),
4021
- ...(input.MaxSyncBuffer != null && { maxSyncBuffer: input.MaxSyncBuffer }),
4022
- ...(input.MediaStreamSourceConfigurations != null && {
4023
- mediaStreamSourceConfigurations: se___listOfMediaStreamSourceConfigurationRequest(input.MediaStreamSourceConfigurations, context),
4024
- }),
4025
- ...(input.MinLatency != null && { minLatency: input.MinLatency }),
4026
- ...(input.Name != null && { name: input.Name }),
4027
- ...(input.Protocol != null && { protocol: input.Protocol }),
4028
- ...(input.SenderControlPort != null && { senderControlPort: input.SenderControlPort }),
4029
- ...(input.SenderIpAddress != null && { senderIpAddress: input.SenderIpAddress }),
4030
- ...(input.SourceListenerAddress != null && { sourceListenerAddress: input.SourceListenerAddress }),
4031
- ...(input.SourceListenerPort != null && { sourceListenerPort: input.SourceListenerPort }),
4032
- ...(input.StreamId != null && { streamId: input.StreamId }),
4033
- ...(input.VpcInterfaceName != null && { vpcInterfaceName: input.VpcInterfaceName }),
4034
- ...(input.WhitelistCidr != null && { whitelistCidr: input.WhitelistCidr }),
4035
- };
3897
+ return take(input, {
3898
+ decryption: [, (_) => se_Encryption(_, context), `Decryption`],
3899
+ description: [, , `Description`],
3900
+ entitlementArn: [, , `EntitlementArn`],
3901
+ gatewayBridgeSource: [, (_) => se_SetGatewayBridgeSourceRequest(_, context), `GatewayBridgeSource`],
3902
+ ingestPort: [, , `IngestPort`],
3903
+ maxBitrate: [, , `MaxBitrate`],
3904
+ maxLatency: [, , `MaxLatency`],
3905
+ maxSyncBuffer: [, , `MaxSyncBuffer`],
3906
+ mediaStreamSourceConfigurations: [
3907
+ ,
3908
+ (_) => se___listOfMediaStreamSourceConfigurationRequest(_, context),
3909
+ `MediaStreamSourceConfigurations`,
3910
+ ],
3911
+ minLatency: [, , `MinLatency`],
3912
+ name: [, , `Name`],
3913
+ protocol: [, , `Protocol`],
3914
+ senderControlPort: [, , `SenderControlPort`],
3915
+ senderIpAddress: [, , `SenderIpAddress`],
3916
+ sourceListenerAddress: [, , `SourceListenerAddress`],
3917
+ sourceListenerPort: [, , `SourceListenerPort`],
3918
+ streamId: [, , `StreamId`],
3919
+ vpcInterfaceName: [, , `VpcInterfaceName`],
3920
+ whitelistCidr: [, , `WhitelistCidr`],
3921
+ });
4036
3922
  };
4037
3923
  const se_SourcePriority = (input, context) => {
4038
- return {
4039
- ...(input.PrimarySource != null && { primarySource: input.PrimarySource }),
4040
- };
3924
+ return take(input, {
3925
+ primarySource: [, , `PrimarySource`],
3926
+ });
4041
3927
  };
4042
3928
  const se_UpdateBridgeFlowSourceRequest = (input, context) => {
4043
- return {
4044
- ...(input.FlowArn != null && { flowArn: input.FlowArn }),
4045
- ...(input.FlowVpcInterfaceAttachment != null && {
4046
- flowVpcInterfaceAttachment: se_VpcInterfaceAttachment(input.FlowVpcInterfaceAttachment, context),
4047
- }),
4048
- };
3929
+ return take(input, {
3930
+ flowArn: [, , `FlowArn`],
3931
+ flowVpcInterfaceAttachment: [, (_) => se_VpcInterfaceAttachment(_, context), `FlowVpcInterfaceAttachment`],
3932
+ });
4049
3933
  };
4050
3934
  const se_UpdateBridgeNetworkOutputRequest = (input, context) => {
4051
- return {
4052
- ...(input.IpAddress != null && { ipAddress: input.IpAddress }),
4053
- ...(input.NetworkName != null && { networkName: input.NetworkName }),
4054
- ...(input.Port != null && { port: input.Port }),
4055
- ...(input.Protocol != null && { protocol: input.Protocol }),
4056
- ...(input.Ttl != null && { ttl: input.Ttl }),
4057
- };
3935
+ return take(input, {
3936
+ ipAddress: [, , `IpAddress`],
3937
+ networkName: [, , `NetworkName`],
3938
+ port: [, , `Port`],
3939
+ protocol: [, , `Protocol`],
3940
+ ttl: [, , `Ttl`],
3941
+ });
4058
3942
  };
4059
3943
  const se_UpdateBridgeNetworkSourceRequest = (input, context) => {
4060
- return {
4061
- ...(input.MulticastIp != null && { multicastIp: input.MulticastIp }),
4062
- ...(input.NetworkName != null && { networkName: input.NetworkName }),
4063
- ...(input.Port != null && { port: input.Port }),
4064
- ...(input.Protocol != null && { protocol: input.Protocol }),
4065
- };
3944
+ return take(input, {
3945
+ multicastIp: [, , `MulticastIp`],
3946
+ networkName: [, , `NetworkName`],
3947
+ port: [, , `Port`],
3948
+ protocol: [, , `Protocol`],
3949
+ });
4066
3950
  };
4067
3951
  const se_UpdateEgressGatewayBridgeRequest = (input, context) => {
4068
- return {
4069
- ...(input.MaxBitrate != null && { maxBitrate: input.MaxBitrate }),
4070
- };
3952
+ return take(input, {
3953
+ maxBitrate: [, , `MaxBitrate`],
3954
+ });
4071
3955
  };
4072
3956
  const se_UpdateEncryption = (input, context) => {
4073
- return {
4074
- ...(input.Algorithm != null && { algorithm: input.Algorithm }),
4075
- ...(input.ConstantInitializationVector != null && {
4076
- constantInitializationVector: input.ConstantInitializationVector,
4077
- }),
4078
- ...(input.DeviceId != null && { deviceId: input.DeviceId }),
4079
- ...(input.KeyType != null && { keyType: input.KeyType }),
4080
- ...(input.Region != null && { region: input.Region }),
4081
- ...(input.ResourceId != null && { resourceId: input.ResourceId }),
4082
- ...(input.RoleArn != null && { roleArn: input.RoleArn }),
4083
- ...(input.SecretArn != null && { secretArn: input.SecretArn }),
4084
- ...(input.Url != null && { url: input.Url }),
4085
- };
3957
+ return take(input, {
3958
+ algorithm: [, , `Algorithm`],
3959
+ constantInitializationVector: [, , `ConstantInitializationVector`],
3960
+ deviceId: [, , `DeviceId`],
3961
+ keyType: [, , `KeyType`],
3962
+ region: [, , `Region`],
3963
+ resourceId: [, , `ResourceId`],
3964
+ roleArn: [, , `RoleArn`],
3965
+ secretArn: [, , `SecretArn`],
3966
+ url: [, , `Url`],
3967
+ });
4086
3968
  };
4087
3969
  const se_UpdateFailoverConfig = (input, context) => {
4088
- return {
4089
- ...(input.FailoverMode != null && { failoverMode: input.FailoverMode }),
4090
- ...(input.RecoveryWindow != null && { recoveryWindow: input.RecoveryWindow }),
4091
- ...(input.SourcePriority != null && { sourcePriority: se_SourcePriority(input.SourcePriority, context) }),
4092
- ...(input.State != null && { state: input.State }),
4093
- };
3970
+ return take(input, {
3971
+ failoverMode: [, , `FailoverMode`],
3972
+ recoveryWindow: [, , `RecoveryWindow`],
3973
+ sourcePriority: [, (_) => se_SourcePriority(_, context), `SourcePriority`],
3974
+ state: [, , `State`],
3975
+ });
4094
3976
  };
4095
3977
  const se_UpdateGatewayBridgeSourceRequest = (input, context) => {
4096
- return {
4097
- ...(input.BridgeArn != null && { bridgeArn: input.BridgeArn }),
4098
- ...(input.VpcInterfaceAttachment != null && {
4099
- vpcInterfaceAttachment: se_VpcInterfaceAttachment(input.VpcInterfaceAttachment, context),
4100
- }),
4101
- };
3978
+ return take(input, {
3979
+ bridgeArn: [, , `BridgeArn`],
3980
+ vpcInterfaceAttachment: [, (_) => se_VpcInterfaceAttachment(_, context), `VpcInterfaceAttachment`],
3981
+ });
4102
3982
  };
4103
3983
  const se_UpdateIngressGatewayBridgeRequest = (input, context) => {
4104
- return {
4105
- ...(input.MaxBitrate != null && { maxBitrate: input.MaxBitrate }),
4106
- ...(input.MaxOutputs != null && { maxOutputs: input.MaxOutputs }),
4107
- };
3984
+ return take(input, {
3985
+ maxBitrate: [, , `MaxBitrate`],
3986
+ maxOutputs: [, , `MaxOutputs`],
3987
+ });
4108
3988
  };
4109
3989
  const se_UpdateMaintenance = (input, context) => {
4110
- return {
4111
- ...(input.MaintenanceDay != null && { maintenanceDay: input.MaintenanceDay }),
4112
- ...(input.MaintenanceScheduledDate != null && { maintenanceScheduledDate: input.MaintenanceScheduledDate }),
4113
- ...(input.MaintenanceStartHour != null && { maintenanceStartHour: input.MaintenanceStartHour }),
4114
- };
3990
+ return take(input, {
3991
+ maintenanceDay: [, , `MaintenanceDay`],
3992
+ maintenanceScheduledDate: [, , `MaintenanceScheduledDate`],
3993
+ maintenanceStartHour: [, , `MaintenanceStartHour`],
3994
+ });
4115
3995
  };
4116
3996
  const se_VpcInterfaceAttachment = (input, context) => {
4117
- return {
4118
- ...(input.VpcInterfaceName != null && { vpcInterfaceName: input.VpcInterfaceName }),
4119
- };
4120
- };
4121
- const se_VpcInterfaceRequest = (input, context) => {
4122
- return {
4123
- ...(input.Name != null && { name: input.Name }),
4124
- ...(input.NetworkInterfaceType != null && { networkInterfaceType: input.NetworkInterfaceType }),
4125
- ...(input.RoleArn != null && { roleArn: input.RoleArn }),
4126
- ...(input.SecurityGroupIds != null && { securityGroupIds: se___listOf__string(input.SecurityGroupIds, context) }),
4127
- ...(input.SubnetId != null && { subnetId: input.SubnetId }),
4128
- };
4129
- };
4130
- const de___listOf__integer = (output, context) => {
4131
- const retVal = (output || [])
4132
- .filter((e) => e != null)
4133
- .map((entry) => {
4134
- if (entry === null) {
4135
- return null;
4136
- }
4137
- return __expectInt32(entry);
3997
+ return take(input, {
3998
+ vpcInterfaceName: [, , `VpcInterfaceName`],
4138
3999
  });
4139
- return retVal;
4140
4000
  };
4141
- const de___listOf__string = (output, context) => {
4142
- const retVal = (output || [])
4143
- .filter((e) => e != null)
4144
- .map((entry) => {
4145
- if (entry === null) {
4146
- return null;
4147
- }
4148
- return __expectString(entry);
4001
+ const se_VpcInterfaceRequest = (input, context) => {
4002
+ return take(input, {
4003
+ name: [, , `Name`],
4004
+ networkInterfaceType: [, , `NetworkInterfaceType`],
4005
+ roleArn: [, , `RoleArn`],
4006
+ securityGroupIds: [, _json, `SecurityGroupIds`],
4007
+ subnetId: [, , `SubnetId`],
4149
4008
  });
4150
- return retVal;
4151
4009
  };
4152
4010
  const de___listOfBridgeOutput = (output, context) => {
4153
4011
  const retVal = (output || [])
4154
4012
  .filter((e) => e != null)
4155
4013
  .map((entry) => {
4156
- if (entry === null) {
4157
- return null;
4158
- }
4159
4014
  return de_BridgeOutput(entry, context);
4160
4015
  });
4161
4016
  return retVal;
@@ -4164,9 +4019,6 @@ const de___listOfBridgeSource = (output, context) => {
4164
4019
  const retVal = (output || [])
4165
4020
  .filter((e) => e != null)
4166
4021
  .map((entry) => {
4167
- if (entry === null) {
4168
- return null;
4169
- }
4170
4022
  return de_BridgeSource(entry, context);
4171
4023
  });
4172
4024
  return retVal;
@@ -4175,9 +4027,6 @@ const de___listOfDestinationConfiguration = (output, context) => {
4175
4027
  const retVal = (output || [])
4176
4028
  .filter((e) => e != null)
4177
4029
  .map((entry) => {
4178
- if (entry === null) {
4179
- return null;
4180
- }
4181
4030
  return de_DestinationConfiguration(entry, context);
4182
4031
  });
4183
4032
  return retVal;
@@ -4186,9 +4035,6 @@ const de___listOfEntitlement = (output, context) => {
4186
4035
  const retVal = (output || [])
4187
4036
  .filter((e) => e != null)
4188
4037
  .map((entry) => {
4189
- if (entry === null) {
4190
- return null;
4191
- }
4192
4038
  return de_Entitlement(entry, context);
4193
4039
  });
4194
4040
  return retVal;
@@ -4197,9 +4043,6 @@ const de___listOfGatewayNetwork = (output, context) => {
4197
4043
  const retVal = (output || [])
4198
4044
  .filter((e) => e != null)
4199
4045
  .map((entry) => {
4200
- if (entry === null) {
4201
- return null;
4202
- }
4203
4046
  return de_GatewayNetwork(entry, context);
4204
4047
  });
4205
4048
  return retVal;
@@ -4208,9 +4051,6 @@ const de___listOfInputConfiguration = (output, context) => {
4208
4051
  const retVal = (output || [])
4209
4052
  .filter((e) => e != null)
4210
4053
  .map((entry) => {
4211
- if (entry === null) {
4212
- return null;
4213
- }
4214
4054
  return de_InputConfiguration(entry, context);
4215
4055
  });
4216
4056
  return retVal;
@@ -4219,9 +4059,6 @@ const de___listOfListedBridge = (output, context) => {
4219
4059
  const retVal = (output || [])
4220
4060
  .filter((e) => e != null)
4221
4061
  .map((entry) => {
4222
- if (entry === null) {
4223
- return null;
4224
- }
4225
4062
  return de_ListedBridge(entry, context);
4226
4063
  });
4227
4064
  return retVal;
@@ -4230,9 +4067,6 @@ const de___listOfListedEntitlement = (output, context) => {
4230
4067
  const retVal = (output || [])
4231
4068
  .filter((e) => e != null)
4232
4069
  .map((entry) => {
4233
- if (entry === null) {
4234
- return null;
4235
- }
4236
4070
  return de_ListedEntitlement(entry, context);
4237
4071
  });
4238
4072
  return retVal;
@@ -4241,9 +4075,6 @@ const de___listOfListedFlow = (output, context) => {
4241
4075
  const retVal = (output || [])
4242
4076
  .filter((e) => e != null)
4243
4077
  .map((entry) => {
4244
- if (entry === null) {
4245
- return null;
4246
- }
4247
4078
  return de_ListedFlow(entry, context);
4248
4079
  });
4249
4080
  return retVal;
@@ -4252,9 +4083,6 @@ const de___listOfListedGateway = (output, context) => {
4252
4083
  const retVal = (output || [])
4253
4084
  .filter((e) => e != null)
4254
4085
  .map((entry) => {
4255
- if (entry === null) {
4256
- return null;
4257
- }
4258
4086
  return de_ListedGateway(entry, context);
4259
4087
  });
4260
4088
  return retVal;
@@ -4263,9 +4091,6 @@ const de___listOfListedGatewayInstance = (output, context) => {
4263
4091
  const retVal = (output || [])
4264
4092
  .filter((e) => e != null)
4265
4093
  .map((entry) => {
4266
- if (entry === null) {
4267
- return null;
4268
- }
4269
4094
  return de_ListedGatewayInstance(entry, context);
4270
4095
  });
4271
4096
  return retVal;
@@ -4274,9 +4099,6 @@ const de___listOfMediaStream = (output, context) => {
4274
4099
  const retVal = (output || [])
4275
4100
  .filter((e) => e != null)
4276
4101
  .map((entry) => {
4277
- if (entry === null) {
4278
- return null;
4279
- }
4280
4102
  return de_MediaStream(entry, context);
4281
4103
  });
4282
4104
  return retVal;
@@ -4285,9 +4107,6 @@ const de___listOfMediaStreamOutputConfiguration = (output, context) => {
4285
4107
  const retVal = (output || [])
4286
4108
  .filter((e) => e != null)
4287
4109
  .map((entry) => {
4288
- if (entry === null) {
4289
- return null;
4290
- }
4291
4110
  return de_MediaStreamOutputConfiguration(entry, context);
4292
4111
  });
4293
4112
  return retVal;
@@ -4296,9 +4115,6 @@ const de___listOfMediaStreamSourceConfiguration = (output, context) => {
4296
4115
  const retVal = (output || [])
4297
4116
  .filter((e) => e != null)
4298
4117
  .map((entry) => {
4299
- if (entry === null) {
4300
- return null;
4301
- }
4302
4118
  return de_MediaStreamSourceConfiguration(entry, context);
4303
4119
  });
4304
4120
  return retVal;
@@ -4307,9 +4123,6 @@ const de___listOfMessageDetail = (output, context) => {
4307
4123
  const retVal = (output || [])
4308
4124
  .filter((e) => e != null)
4309
4125
  .map((entry) => {
4310
- if (entry === null) {
4311
- return null;
4312
- }
4313
4126
  return de_MessageDetail(entry, context);
4314
4127
  });
4315
4128
  return retVal;
@@ -4318,9 +4131,6 @@ const de___listOfOffering = (output, context) => {
4318
4131
  const retVal = (output || [])
4319
4132
  .filter((e) => e != null)
4320
4133
  .map((entry) => {
4321
- if (entry === null) {
4322
- return null;
4323
- }
4324
4134
  return de_Offering(entry, context);
4325
4135
  });
4326
4136
  return retVal;
@@ -4329,9 +4139,6 @@ const de___listOfOutput = (output, context) => {
4329
4139
  const retVal = (output || [])
4330
4140
  .filter((e) => e != null)
4331
4141
  .map((entry) => {
4332
- if (entry === null) {
4333
- return null;
4334
- }
4335
4142
  return de_Output(entry, context);
4336
4143
  });
4337
4144
  return retVal;
@@ -4340,9 +4147,6 @@ const de___listOfReservation = (output, context) => {
4340
4147
  const retVal = (output || [])
4341
4148
  .filter((e) => e != null)
4342
4149
  .map((entry) => {
4343
- if (entry === null) {
4344
- return null;
4345
- }
4346
4150
  return de_Reservation(entry, context);
4347
4151
  });
4348
4152
  return retVal;
@@ -4351,9 +4155,6 @@ const de___listOfSource = (output, context) => {
4351
4155
  const retVal = (output || [])
4352
4156
  .filter((e) => e != null)
4353
4157
  .map((entry) => {
4354
- if (entry === null) {
4355
- return null;
4356
- }
4357
4158
  return de_Source(entry, context);
4358
4159
  });
4359
4160
  return retVal;
@@ -4362,438 +4163,416 @@ const de___listOfVpcInterface = (output, context) => {
4362
4163
  const retVal = (output || [])
4363
4164
  .filter((e) => e != null)
4364
4165
  .map((entry) => {
4365
- if (entry === null) {
4366
- return null;
4367
- }
4368
4166
  return de_VpcInterface(entry, context);
4369
4167
  });
4370
4168
  return retVal;
4371
4169
  };
4372
- const de___mapOf__string = (output, context) => {
4373
- return Object.entries(output).reduce((acc, [key, value]) => {
4374
- if (value === null) {
4375
- return acc;
4376
- }
4377
- acc[key] = __expectString(value);
4378
- return acc;
4379
- }, {});
4380
- };
4381
4170
  const de_Bridge = (output, context) => {
4382
- return {
4383
- BridgeArn: __expectString(output.bridgeArn),
4384
- BridgeMessages: output.bridgeMessages != null ? de___listOfMessageDetail(output.bridgeMessages, context) : undefined,
4385
- BridgeState: __expectString(output.bridgeState),
4386
- EgressGatewayBridge: output.egressGatewayBridge != null ? de_EgressGatewayBridge(output.egressGatewayBridge, context) : undefined,
4387
- IngressGatewayBridge: output.ingressGatewayBridge != null ? de_IngressGatewayBridge(output.ingressGatewayBridge, context) : undefined,
4388
- Name: __expectString(output.name),
4389
- Outputs: output.outputs != null ? de___listOfBridgeOutput(output.outputs, context) : undefined,
4390
- PlacementArn: __expectString(output.placementArn),
4391
- SourceFailoverConfig: output.sourceFailoverConfig != null ? de_FailoverConfig(output.sourceFailoverConfig, context) : undefined,
4392
- Sources: output.sources != null ? de___listOfBridgeSource(output.sources, context) : undefined,
4393
- };
4171
+ return take(output, {
4172
+ BridgeArn: [, __expectString, `bridgeArn`],
4173
+ BridgeMessages: (_) => [, de___listOfMessageDetail(_, context), `bridgeMessages`],
4174
+ BridgeState: [, __expectString, `bridgeState`],
4175
+ EgressGatewayBridge: (_) => [, de_EgressGatewayBridge(_, context), `egressGatewayBridge`],
4176
+ IngressGatewayBridge: (_) => [, de_IngressGatewayBridge(_, context), `ingressGatewayBridge`],
4177
+ Name: [, __expectString, `name`],
4178
+ Outputs: (_) => [, de___listOfBridgeOutput(_, context), `outputs`],
4179
+ PlacementArn: [, __expectString, `placementArn`],
4180
+ SourceFailoverConfig: (_) => [, de_FailoverConfig(_, context), `sourceFailoverConfig`],
4181
+ Sources: (_) => [, de___listOfBridgeSource(_, context), `sources`],
4182
+ });
4394
4183
  };
4395
4184
  const de_BridgeFlowOutput = (output, context) => {
4396
- return {
4397
- FlowArn: __expectString(output.flowArn),
4398
- FlowSourceArn: __expectString(output.flowSourceArn),
4399
- Name: __expectString(output.name),
4400
- };
4185
+ return take(output, {
4186
+ FlowArn: [, __expectString, `flowArn`],
4187
+ FlowSourceArn: [, __expectString, `flowSourceArn`],
4188
+ Name: [, __expectString, `name`],
4189
+ });
4401
4190
  };
4402
4191
  const de_BridgeFlowSource = (output, context) => {
4403
- return {
4404
- FlowArn: __expectString(output.flowArn),
4405
- FlowVpcInterfaceAttachment: output.flowVpcInterfaceAttachment != null
4406
- ? de_VpcInterfaceAttachment(output.flowVpcInterfaceAttachment, context)
4407
- : undefined,
4408
- Name: __expectString(output.name),
4409
- OutputArn: __expectString(output.outputArn),
4410
- };
4192
+ return take(output, {
4193
+ FlowArn: [, __expectString, `flowArn`],
4194
+ FlowVpcInterfaceAttachment: (_) => [, de_VpcInterfaceAttachment(_, context), `flowVpcInterfaceAttachment`],
4195
+ Name: [, __expectString, `name`],
4196
+ OutputArn: [, __expectString, `outputArn`],
4197
+ });
4411
4198
  };
4412
4199
  const de_BridgeNetworkOutput = (output, context) => {
4413
- return {
4414
- IpAddress: __expectString(output.ipAddress),
4415
- Name: __expectString(output.name),
4416
- NetworkName: __expectString(output.networkName),
4417
- Port: __expectInt32(output.port),
4418
- Protocol: __expectString(output.protocol),
4419
- Ttl: __expectInt32(output.ttl),
4420
- };
4200
+ return take(output, {
4201
+ IpAddress: [, __expectString, `ipAddress`],
4202
+ Name: [, __expectString, `name`],
4203
+ NetworkName: [, __expectString, `networkName`],
4204
+ Port: [, __expectInt32, `port`],
4205
+ Protocol: [, __expectString, `protocol`],
4206
+ Ttl: [, __expectInt32, `ttl`],
4207
+ });
4421
4208
  };
4422
4209
  const de_BridgeNetworkSource = (output, context) => {
4423
- return {
4424
- MulticastIp: __expectString(output.multicastIp),
4425
- Name: __expectString(output.name),
4426
- NetworkName: __expectString(output.networkName),
4427
- Port: __expectInt32(output.port),
4428
- Protocol: __expectString(output.protocol),
4429
- };
4210
+ return take(output, {
4211
+ MulticastIp: [, __expectString, `multicastIp`],
4212
+ Name: [, __expectString, `name`],
4213
+ NetworkName: [, __expectString, `networkName`],
4214
+ Port: [, __expectInt32, `port`],
4215
+ Protocol: [, __expectString, `protocol`],
4216
+ });
4430
4217
  };
4431
4218
  const de_BridgeOutput = (output, context) => {
4432
- return {
4433
- FlowOutput: output.flowOutput != null ? de_BridgeFlowOutput(output.flowOutput, context) : undefined,
4434
- NetworkOutput: output.networkOutput != null ? de_BridgeNetworkOutput(output.networkOutput, context) : undefined,
4435
- };
4219
+ return take(output, {
4220
+ FlowOutput: (_) => [, de_BridgeFlowOutput(_, context), `flowOutput`],
4221
+ NetworkOutput: (_) => [, de_BridgeNetworkOutput(_, context), `networkOutput`],
4222
+ });
4436
4223
  };
4437
4224
  const de_BridgeSource = (output, context) => {
4438
- return {
4439
- FlowSource: output.flowSource != null ? de_BridgeFlowSource(output.flowSource, context) : undefined,
4440
- NetworkSource: output.networkSource != null ? de_BridgeNetworkSource(output.networkSource, context) : undefined,
4441
- };
4225
+ return take(output, {
4226
+ FlowSource: (_) => [, de_BridgeFlowSource(_, context), `flowSource`],
4227
+ NetworkSource: (_) => [, de_BridgeNetworkSource(_, context), `networkSource`],
4228
+ });
4442
4229
  };
4443
4230
  const de_DestinationConfiguration = (output, context) => {
4444
- return {
4445
- DestinationIp: __expectString(output.destinationIp),
4446
- DestinationPort: __expectInt32(output.destinationPort),
4447
- Interface: output.interface != null ? de_Interface(output.interface, context) : undefined,
4448
- OutboundIp: __expectString(output.outboundIp),
4449
- };
4231
+ return take(output, {
4232
+ DestinationIp: [, __expectString, `destinationIp`],
4233
+ DestinationPort: [, __expectInt32, `destinationPort`],
4234
+ Interface: (_) => [, de_Interface(_, context), `interface`],
4235
+ OutboundIp: [, __expectString, `outboundIp`],
4236
+ });
4450
4237
  };
4451
4238
  const de_EgressGatewayBridge = (output, context) => {
4452
- return {
4453
- InstanceId: __expectString(output.instanceId),
4454
- MaxBitrate: __expectInt32(output.maxBitrate),
4455
- };
4239
+ return take(output, {
4240
+ InstanceId: [, __expectString, `instanceId`],
4241
+ MaxBitrate: [, __expectInt32, `maxBitrate`],
4242
+ });
4456
4243
  };
4457
4244
  const de_EncodingParameters = (output, context) => {
4458
- return {
4459
- CompressionFactor: __limitedParseDouble(output.compressionFactor),
4460
- EncoderProfile: __expectString(output.encoderProfile),
4461
- };
4245
+ return take(output, {
4246
+ CompressionFactor: [, __limitedParseDouble, `compressionFactor`],
4247
+ EncoderProfile: [, __expectString, `encoderProfile`],
4248
+ });
4462
4249
  };
4463
4250
  const de_Encryption = (output, context) => {
4464
- return {
4465
- Algorithm: __expectString(output.algorithm),
4466
- ConstantInitializationVector: __expectString(output.constantInitializationVector),
4467
- DeviceId: __expectString(output.deviceId),
4468
- KeyType: __expectString(output.keyType),
4469
- Region: __expectString(output.region),
4470
- ResourceId: __expectString(output.resourceId),
4471
- RoleArn: __expectString(output.roleArn),
4472
- SecretArn: __expectString(output.secretArn),
4473
- Url: __expectString(output.url),
4474
- };
4251
+ return take(output, {
4252
+ Algorithm: [, __expectString, `algorithm`],
4253
+ ConstantInitializationVector: [, __expectString, `constantInitializationVector`],
4254
+ DeviceId: [, __expectString, `deviceId`],
4255
+ KeyType: [, __expectString, `keyType`],
4256
+ Region: [, __expectString, `region`],
4257
+ ResourceId: [, __expectString, `resourceId`],
4258
+ RoleArn: [, __expectString, `roleArn`],
4259
+ SecretArn: [, __expectString, `secretArn`],
4260
+ Url: [, __expectString, `url`],
4261
+ });
4475
4262
  };
4476
4263
  const de_Entitlement = (output, context) => {
4477
- return {
4478
- DataTransferSubscriberFeePercent: __expectInt32(output.dataTransferSubscriberFeePercent),
4479
- Description: __expectString(output.description),
4480
- Encryption: output.encryption != null ? de_Encryption(output.encryption, context) : undefined,
4481
- EntitlementArn: __expectString(output.entitlementArn),
4482
- EntitlementStatus: __expectString(output.entitlementStatus),
4483
- Name: __expectString(output.name),
4484
- Subscribers: output.subscribers != null ? de___listOf__string(output.subscribers, context) : undefined,
4485
- };
4264
+ return take(output, {
4265
+ DataTransferSubscriberFeePercent: [, __expectInt32, `dataTransferSubscriberFeePercent`],
4266
+ Description: [, __expectString, `description`],
4267
+ Encryption: (_) => [, de_Encryption(_, context), `encryption`],
4268
+ EntitlementArn: [, __expectString, `entitlementArn`],
4269
+ EntitlementStatus: [, __expectString, `entitlementStatus`],
4270
+ Name: [, __expectString, `name`],
4271
+ Subscribers: [, _json, `subscribers`],
4272
+ });
4486
4273
  };
4487
4274
  const de_FailoverConfig = (output, context) => {
4488
- return {
4489
- FailoverMode: __expectString(output.failoverMode),
4490
- RecoveryWindow: __expectInt32(output.recoveryWindow),
4491
- SourcePriority: output.sourcePriority != null ? de_SourcePriority(output.sourcePriority, context) : undefined,
4492
- State: __expectString(output.state),
4493
- };
4275
+ return take(output, {
4276
+ FailoverMode: [, __expectString, `failoverMode`],
4277
+ RecoveryWindow: [, __expectInt32, `recoveryWindow`],
4278
+ SourcePriority: (_) => [, de_SourcePriority(_, context), `sourcePriority`],
4279
+ State: [, __expectString, `state`],
4280
+ });
4494
4281
  };
4495
4282
  const de_Flow = (output, context) => {
4496
- return {
4497
- AvailabilityZone: __expectString(output.availabilityZone),
4498
- Description: __expectString(output.description),
4499
- EgressIp: __expectString(output.egressIp),
4500
- Entitlements: output.entitlements != null ? de___listOfEntitlement(output.entitlements, context) : undefined,
4501
- FlowArn: __expectString(output.flowArn),
4502
- Maintenance: output.maintenance != null ? de_Maintenance(output.maintenance, context) : undefined,
4503
- MediaStreams: output.mediaStreams != null ? de___listOfMediaStream(output.mediaStreams, context) : undefined,
4504
- Name: __expectString(output.name),
4505
- Outputs: output.outputs != null ? de___listOfOutput(output.outputs, context) : undefined,
4506
- Source: output.source != null ? de_Source(output.source, context) : undefined,
4507
- SourceFailoverConfig: output.sourceFailoverConfig != null ? de_FailoverConfig(output.sourceFailoverConfig, context) : undefined,
4508
- Sources: output.sources != null ? de___listOfSource(output.sources, context) : undefined,
4509
- Status: __expectString(output.status),
4510
- VpcInterfaces: output.vpcInterfaces != null ? de___listOfVpcInterface(output.vpcInterfaces, context) : undefined,
4511
- };
4283
+ return take(output, {
4284
+ AvailabilityZone: [, __expectString, `availabilityZone`],
4285
+ Description: [, __expectString, `description`],
4286
+ EgressIp: [, __expectString, `egressIp`],
4287
+ Entitlements: (_) => [, de___listOfEntitlement(_, context), `entitlements`],
4288
+ FlowArn: [, __expectString, `flowArn`],
4289
+ Maintenance: (_) => [, de_Maintenance(_, context), `maintenance`],
4290
+ MediaStreams: (_) => [, de___listOfMediaStream(_, context), `mediaStreams`],
4291
+ Name: [, __expectString, `name`],
4292
+ Outputs: (_) => [, de___listOfOutput(_, context), `outputs`],
4293
+ Source: (_) => [, de_Source(_, context), `source`],
4294
+ SourceFailoverConfig: (_) => [, de_FailoverConfig(_, context), `sourceFailoverConfig`],
4295
+ Sources: (_) => [, de___listOfSource(_, context), `sources`],
4296
+ Status: [, __expectString, `status`],
4297
+ VpcInterfaces: (_) => [, de___listOfVpcInterface(_, context), `vpcInterfaces`],
4298
+ });
4512
4299
  };
4513
4300
  const de_Fmtp = (output, context) => {
4514
- return {
4515
- ChannelOrder: __expectString(output.channelOrder),
4516
- Colorimetry: __expectString(output.colorimetry),
4517
- ExactFramerate: __expectString(output.exactFramerate),
4518
- Par: __expectString(output.par),
4519
- Range: __expectString(output.range),
4520
- ScanMode: __expectString(output.scanMode),
4521
- Tcs: __expectString(output.tcs),
4522
- };
4301
+ return take(output, {
4302
+ ChannelOrder: [, __expectString, `channelOrder`],
4303
+ Colorimetry: [, __expectString, `colorimetry`],
4304
+ ExactFramerate: [, __expectString, `exactFramerate`],
4305
+ Par: [, __expectString, `par`],
4306
+ Range: [, __expectString, `range`],
4307
+ ScanMode: [, __expectString, `scanMode`],
4308
+ Tcs: [, __expectString, `tcs`],
4309
+ });
4523
4310
  };
4524
4311
  const de_Gateway = (output, context) => {
4525
- return {
4526
- EgressCidrBlocks: output.egressCidrBlocks != null ? de___listOf__string(output.egressCidrBlocks, context) : undefined,
4527
- GatewayArn: __expectString(output.gatewayArn),
4528
- GatewayMessages: output.gatewayMessages != null ? de___listOfMessageDetail(output.gatewayMessages, context) : undefined,
4529
- GatewayState: __expectString(output.gatewayState),
4530
- Name: __expectString(output.name),
4531
- Networks: output.networks != null ? de___listOfGatewayNetwork(output.networks, context) : undefined,
4532
- };
4312
+ return take(output, {
4313
+ EgressCidrBlocks: [, _json, `egressCidrBlocks`],
4314
+ GatewayArn: [, __expectString, `gatewayArn`],
4315
+ GatewayMessages: (_) => [, de___listOfMessageDetail(_, context), `gatewayMessages`],
4316
+ GatewayState: [, __expectString, `gatewayState`],
4317
+ Name: [, __expectString, `name`],
4318
+ Networks: (_) => [, de___listOfGatewayNetwork(_, context), `networks`],
4319
+ });
4533
4320
  };
4534
4321
  const de_GatewayBridgeSource = (output, context) => {
4535
- return {
4536
- BridgeArn: __expectString(output.bridgeArn),
4537
- VpcInterfaceAttachment: output.vpcInterfaceAttachment != null
4538
- ? de_VpcInterfaceAttachment(output.vpcInterfaceAttachment, context)
4539
- : undefined,
4540
- };
4322
+ return take(output, {
4323
+ BridgeArn: [, __expectString, `bridgeArn`],
4324
+ VpcInterfaceAttachment: (_) => [, de_VpcInterfaceAttachment(_, context), `vpcInterfaceAttachment`],
4325
+ });
4541
4326
  };
4542
4327
  const de_GatewayInstance = (output, context) => {
4543
- return {
4544
- BridgePlacement: __expectString(output.bridgePlacement),
4545
- ConnectionStatus: __expectString(output.connectionStatus),
4546
- GatewayArn: __expectString(output.gatewayArn),
4547
- GatewayInstanceArn: __expectString(output.gatewayInstanceArn),
4548
- InstanceId: __expectString(output.instanceId),
4549
- InstanceMessages: output.instanceMessages != null ? de___listOfMessageDetail(output.instanceMessages, context) : undefined,
4550
- InstanceState: __expectString(output.instanceState),
4551
- RunningBridgeCount: __expectInt32(output.runningBridgeCount),
4552
- };
4328
+ return take(output, {
4329
+ BridgePlacement: [, __expectString, `bridgePlacement`],
4330
+ ConnectionStatus: [, __expectString, `connectionStatus`],
4331
+ GatewayArn: [, __expectString, `gatewayArn`],
4332
+ GatewayInstanceArn: [, __expectString, `gatewayInstanceArn`],
4333
+ InstanceId: [, __expectString, `instanceId`],
4334
+ InstanceMessages: (_) => [, de___listOfMessageDetail(_, context), `instanceMessages`],
4335
+ InstanceState: [, __expectString, `instanceState`],
4336
+ RunningBridgeCount: [, __expectInt32, `runningBridgeCount`],
4337
+ });
4553
4338
  };
4554
4339
  const de_GatewayNetwork = (output, context) => {
4555
- return {
4556
- CidrBlock: __expectString(output.cidrBlock),
4557
- Name: __expectString(output.name),
4558
- };
4340
+ return take(output, {
4341
+ CidrBlock: [, __expectString, `cidrBlock`],
4342
+ Name: [, __expectString, `name`],
4343
+ });
4559
4344
  };
4560
4345
  const de_IngressGatewayBridge = (output, context) => {
4561
- return {
4562
- InstanceId: __expectString(output.instanceId),
4563
- MaxBitrate: __expectInt32(output.maxBitrate),
4564
- MaxOutputs: __expectInt32(output.maxOutputs),
4565
- };
4346
+ return take(output, {
4347
+ InstanceId: [, __expectString, `instanceId`],
4348
+ MaxBitrate: [, __expectInt32, `maxBitrate`],
4349
+ MaxOutputs: [, __expectInt32, `maxOutputs`],
4350
+ });
4566
4351
  };
4567
4352
  const de_InputConfiguration = (output, context) => {
4568
- return {
4569
- InputIp: __expectString(output.inputIp),
4570
- InputPort: __expectInt32(output.inputPort),
4571
- Interface: output.interface != null ? de_Interface(output.interface, context) : undefined,
4572
- };
4353
+ return take(output, {
4354
+ InputIp: [, __expectString, `inputIp`],
4355
+ InputPort: [, __expectInt32, `inputPort`],
4356
+ Interface: (_) => [, de_Interface(_, context), `interface`],
4357
+ });
4573
4358
  };
4574
4359
  const de_Interface = (output, context) => {
4575
- return {
4576
- Name: __expectString(output.name),
4577
- };
4360
+ return take(output, {
4361
+ Name: [, __expectString, `name`],
4362
+ });
4578
4363
  };
4579
4364
  const de_ListedBridge = (output, context) => {
4580
- return {
4581
- BridgeArn: __expectString(output.bridgeArn),
4582
- BridgeState: __expectString(output.bridgeState),
4583
- BridgeType: __expectString(output.bridgeType),
4584
- Name: __expectString(output.name),
4585
- PlacementArn: __expectString(output.placementArn),
4586
- };
4365
+ return take(output, {
4366
+ BridgeArn: [, __expectString, `bridgeArn`],
4367
+ BridgeState: [, __expectString, `bridgeState`],
4368
+ BridgeType: [, __expectString, `bridgeType`],
4369
+ Name: [, __expectString, `name`],
4370
+ PlacementArn: [, __expectString, `placementArn`],
4371
+ });
4587
4372
  };
4588
4373
  const de_ListedEntitlement = (output, context) => {
4589
- return {
4590
- DataTransferSubscriberFeePercent: __expectInt32(output.dataTransferSubscriberFeePercent),
4591
- EntitlementArn: __expectString(output.entitlementArn),
4592
- EntitlementName: __expectString(output.entitlementName),
4593
- };
4374
+ return take(output, {
4375
+ DataTransferSubscriberFeePercent: [, __expectInt32, `dataTransferSubscriberFeePercent`],
4376
+ EntitlementArn: [, __expectString, `entitlementArn`],
4377
+ EntitlementName: [, __expectString, `entitlementName`],
4378
+ });
4594
4379
  };
4595
4380
  const de_ListedFlow = (output, context) => {
4596
- return {
4597
- AvailabilityZone: __expectString(output.availabilityZone),
4598
- Description: __expectString(output.description),
4599
- FlowArn: __expectString(output.flowArn),
4600
- Maintenance: output.maintenance != null ? de_Maintenance(output.maintenance, context) : undefined,
4601
- Name: __expectString(output.name),
4602
- SourceType: __expectString(output.sourceType),
4603
- Status: __expectString(output.status),
4604
- };
4381
+ return take(output, {
4382
+ AvailabilityZone: [, __expectString, `availabilityZone`],
4383
+ Description: [, __expectString, `description`],
4384
+ FlowArn: [, __expectString, `flowArn`],
4385
+ Maintenance: (_) => [, de_Maintenance(_, context), `maintenance`],
4386
+ Name: [, __expectString, `name`],
4387
+ SourceType: [, __expectString, `sourceType`],
4388
+ Status: [, __expectString, `status`],
4389
+ });
4605
4390
  };
4606
4391
  const de_ListedGateway = (output, context) => {
4607
- return {
4608
- GatewayArn: __expectString(output.gatewayArn),
4609
- GatewayState: __expectString(output.gatewayState),
4610
- Name: __expectString(output.name),
4611
- };
4392
+ return take(output, {
4393
+ GatewayArn: [, __expectString, `gatewayArn`],
4394
+ GatewayState: [, __expectString, `gatewayState`],
4395
+ Name: [, __expectString, `name`],
4396
+ });
4612
4397
  };
4613
4398
  const de_ListedGatewayInstance = (output, context) => {
4614
- return {
4615
- GatewayArn: __expectString(output.gatewayArn),
4616
- GatewayInstanceArn: __expectString(output.gatewayInstanceArn),
4617
- InstanceId: __expectString(output.instanceId),
4618
- InstanceState: __expectString(output.instanceState),
4619
- };
4399
+ return take(output, {
4400
+ GatewayArn: [, __expectString, `gatewayArn`],
4401
+ GatewayInstanceArn: [, __expectString, `gatewayInstanceArn`],
4402
+ InstanceId: [, __expectString, `instanceId`],
4403
+ InstanceState: [, __expectString, `instanceState`],
4404
+ });
4620
4405
  };
4621
4406
  const de_Maintenance = (output, context) => {
4622
- return {
4623
- MaintenanceDay: __expectString(output.maintenanceDay),
4624
- MaintenanceDeadline: __expectString(output.maintenanceDeadline),
4625
- MaintenanceScheduledDate: __expectString(output.maintenanceScheduledDate),
4626
- MaintenanceStartHour: __expectString(output.maintenanceStartHour),
4627
- };
4407
+ return take(output, {
4408
+ MaintenanceDay: [, __expectString, `maintenanceDay`],
4409
+ MaintenanceDeadline: [, __expectString, `maintenanceDeadline`],
4410
+ MaintenanceScheduledDate: [, __expectString, `maintenanceScheduledDate`],
4411
+ MaintenanceStartHour: [, __expectString, `maintenanceStartHour`],
4412
+ });
4628
4413
  };
4629
4414
  const de_MediaStream = (output, context) => {
4630
- return {
4631
- Attributes: output.attributes != null ? de_MediaStreamAttributes(output.attributes, context) : undefined,
4632
- ClockRate: __expectInt32(output.clockRate),
4633
- Description: __expectString(output.description),
4634
- Fmt: __expectInt32(output.fmt),
4635
- MediaStreamId: __expectInt32(output.mediaStreamId),
4636
- MediaStreamName: __expectString(output.mediaStreamName),
4637
- MediaStreamType: __expectString(output.mediaStreamType),
4638
- VideoFormat: __expectString(output.videoFormat),
4639
- };
4415
+ return take(output, {
4416
+ Attributes: (_) => [, de_MediaStreamAttributes(_, context), `attributes`],
4417
+ ClockRate: [, __expectInt32, `clockRate`],
4418
+ Description: [, __expectString, `description`],
4419
+ Fmt: [, __expectInt32, `fmt`],
4420
+ MediaStreamId: [, __expectInt32, `mediaStreamId`],
4421
+ MediaStreamName: [, __expectString, `mediaStreamName`],
4422
+ MediaStreamType: [, __expectString, `mediaStreamType`],
4423
+ VideoFormat: [, __expectString, `videoFormat`],
4424
+ });
4640
4425
  };
4641
4426
  const de_MediaStreamAttributes = (output, context) => {
4642
- return {
4643
- Fmtp: output.fmtp != null ? de_Fmtp(output.fmtp, context) : undefined,
4644
- Lang: __expectString(output.lang),
4645
- };
4427
+ return take(output, {
4428
+ Fmtp: (_) => [, de_Fmtp(_, context), `fmtp`],
4429
+ Lang: [, __expectString, `lang`],
4430
+ });
4646
4431
  };
4647
4432
  const de_MediaStreamOutputConfiguration = (output, context) => {
4648
- return {
4649
- DestinationConfigurations: output.destinationConfigurations != null
4650
- ? de___listOfDestinationConfiguration(output.destinationConfigurations, context)
4651
- : undefined,
4652
- EncodingName: __expectString(output.encodingName),
4653
- EncodingParameters: output.encodingParameters != null ? de_EncodingParameters(output.encodingParameters, context) : undefined,
4654
- MediaStreamName: __expectString(output.mediaStreamName),
4655
- };
4433
+ return take(output, {
4434
+ DestinationConfigurations: (_) => [, de___listOfDestinationConfiguration(_, context), `destinationConfigurations`],
4435
+ EncodingName: [, __expectString, `encodingName`],
4436
+ EncodingParameters: (_) => [, de_EncodingParameters(_, context), `encodingParameters`],
4437
+ MediaStreamName: [, __expectString, `mediaStreamName`],
4438
+ });
4656
4439
  };
4657
4440
  const de_MediaStreamSourceConfiguration = (output, context) => {
4658
- return {
4659
- EncodingName: __expectString(output.encodingName),
4660
- InputConfigurations: output.inputConfigurations != null
4661
- ? de___listOfInputConfiguration(output.inputConfigurations, context)
4662
- : undefined,
4663
- MediaStreamName: __expectString(output.mediaStreamName),
4664
- };
4441
+ return take(output, {
4442
+ EncodingName: [, __expectString, `encodingName`],
4443
+ InputConfigurations: (_) => [, de___listOfInputConfiguration(_, context), `inputConfigurations`],
4444
+ MediaStreamName: [, __expectString, `mediaStreamName`],
4445
+ });
4665
4446
  };
4666
4447
  const de_MessageDetail = (output, context) => {
4667
- return {
4668
- Code: __expectString(output.code),
4669
- Message: __expectString(output.message),
4670
- ResourceName: __expectString(output.resourceName),
4671
- };
4448
+ return take(output, {
4449
+ Code: [, __expectString, `code`],
4450
+ Message: [, __expectString, `message`],
4451
+ ResourceName: [, __expectString, `resourceName`],
4452
+ });
4672
4453
  };
4673
4454
  const de_Messages = (output, context) => {
4674
- return {
4675
- Errors: output.errors != null ? de___listOf__string(output.errors, context) : undefined,
4676
- };
4455
+ return take(output, {
4456
+ Errors: [, _json, `errors`],
4457
+ });
4677
4458
  };
4678
4459
  const de_Offering = (output, context) => {
4679
- return {
4680
- CurrencyCode: __expectString(output.currencyCode),
4681
- Duration: __expectInt32(output.duration),
4682
- DurationUnits: __expectString(output.durationUnits),
4683
- OfferingArn: __expectString(output.offeringArn),
4684
- OfferingDescription: __expectString(output.offeringDescription),
4685
- PricePerUnit: __expectString(output.pricePerUnit),
4686
- PriceUnits: __expectString(output.priceUnits),
4687
- ResourceSpecification: output.resourceSpecification != null
4688
- ? de_ResourceSpecification(output.resourceSpecification, context)
4689
- : undefined,
4690
- };
4460
+ return take(output, {
4461
+ CurrencyCode: [, __expectString, `currencyCode`],
4462
+ Duration: [, __expectInt32, `duration`],
4463
+ DurationUnits: [, __expectString, `durationUnits`],
4464
+ OfferingArn: [, __expectString, `offeringArn`],
4465
+ OfferingDescription: [, __expectString, `offeringDescription`],
4466
+ PricePerUnit: [, __expectString, `pricePerUnit`],
4467
+ PriceUnits: [, __expectString, `priceUnits`],
4468
+ ResourceSpecification: (_) => [, de_ResourceSpecification(_, context), `resourceSpecification`],
4469
+ });
4691
4470
  };
4692
4471
  const de_Output = (output, context) => {
4693
- return {
4694
- BridgeArn: __expectString(output.bridgeArn),
4695
- BridgePorts: output.bridgePorts != null ? de___listOf__integer(output.bridgePorts, context) : undefined,
4696
- DataTransferSubscriberFeePercent: __expectInt32(output.dataTransferSubscriberFeePercent),
4697
- Description: __expectString(output.description),
4698
- Destination: __expectString(output.destination),
4699
- Encryption: output.encryption != null ? de_Encryption(output.encryption, context) : undefined,
4700
- EntitlementArn: __expectString(output.entitlementArn),
4701
- ListenerAddress: __expectString(output.listenerAddress),
4702
- MediaLiveInputArn: __expectString(output.mediaLiveInputArn),
4703
- MediaStreamOutputConfigurations: output.mediaStreamOutputConfigurations != null
4704
- ? de___listOfMediaStreamOutputConfiguration(output.mediaStreamOutputConfigurations, context)
4705
- : undefined,
4706
- Name: __expectString(output.name),
4707
- OutputArn: __expectString(output.outputArn),
4708
- Port: __expectInt32(output.port),
4709
- Transport: output.transport != null ? de_Transport(output.transport, context) : undefined,
4710
- VpcInterfaceAttachment: output.vpcInterfaceAttachment != null
4711
- ? de_VpcInterfaceAttachment(output.vpcInterfaceAttachment, context)
4712
- : undefined,
4713
- };
4472
+ return take(output, {
4473
+ BridgeArn: [, __expectString, `bridgeArn`],
4474
+ BridgePorts: [, _json, `bridgePorts`],
4475
+ DataTransferSubscriberFeePercent: [, __expectInt32, `dataTransferSubscriberFeePercent`],
4476
+ Description: [, __expectString, `description`],
4477
+ Destination: [, __expectString, `destination`],
4478
+ Encryption: (_) => [, de_Encryption(_, context), `encryption`],
4479
+ EntitlementArn: [, __expectString, `entitlementArn`],
4480
+ ListenerAddress: [, __expectString, `listenerAddress`],
4481
+ MediaLiveInputArn: [, __expectString, `mediaLiveInputArn`],
4482
+ MediaStreamOutputConfigurations: (_) => [
4483
+ ,
4484
+ de___listOfMediaStreamOutputConfiguration(_, context),
4485
+ `mediaStreamOutputConfigurations`,
4486
+ ],
4487
+ Name: [, __expectString, `name`],
4488
+ OutputArn: [, __expectString, `outputArn`],
4489
+ Port: [, __expectInt32, `port`],
4490
+ Transport: (_) => [, de_Transport(_, context), `transport`],
4491
+ VpcInterfaceAttachment: (_) => [, de_VpcInterfaceAttachment(_, context), `vpcInterfaceAttachment`],
4492
+ });
4714
4493
  };
4715
4494
  const de_Reservation = (output, context) => {
4716
- return {
4717
- CurrencyCode: __expectString(output.currencyCode),
4718
- Duration: __expectInt32(output.duration),
4719
- DurationUnits: __expectString(output.durationUnits),
4720
- End: __expectString(output.end),
4721
- OfferingArn: __expectString(output.offeringArn),
4722
- OfferingDescription: __expectString(output.offeringDescription),
4723
- PricePerUnit: __expectString(output.pricePerUnit),
4724
- PriceUnits: __expectString(output.priceUnits),
4725
- ReservationArn: __expectString(output.reservationArn),
4726
- ReservationName: __expectString(output.reservationName),
4727
- ReservationState: __expectString(output.reservationState),
4728
- ResourceSpecification: output.resourceSpecification != null
4729
- ? de_ResourceSpecification(output.resourceSpecification, context)
4730
- : undefined,
4731
- Start: __expectString(output.start),
4732
- };
4495
+ return take(output, {
4496
+ CurrencyCode: [, __expectString, `currencyCode`],
4497
+ Duration: [, __expectInt32, `duration`],
4498
+ DurationUnits: [, __expectString, `durationUnits`],
4499
+ End: [, __expectString, `end`],
4500
+ OfferingArn: [, __expectString, `offeringArn`],
4501
+ OfferingDescription: [, __expectString, `offeringDescription`],
4502
+ PricePerUnit: [, __expectString, `pricePerUnit`],
4503
+ PriceUnits: [, __expectString, `priceUnits`],
4504
+ ReservationArn: [, __expectString, `reservationArn`],
4505
+ ReservationName: [, __expectString, `reservationName`],
4506
+ ReservationState: [, __expectString, `reservationState`],
4507
+ ResourceSpecification: (_) => [, de_ResourceSpecification(_, context), `resourceSpecification`],
4508
+ Start: [, __expectString, `start`],
4509
+ });
4733
4510
  };
4734
4511
  const de_ResourceSpecification = (output, context) => {
4735
- return {
4736
- ReservedBitrate: __expectInt32(output.reservedBitrate),
4737
- ResourceType: __expectString(output.resourceType),
4738
- };
4512
+ return take(output, {
4513
+ ReservedBitrate: [, __expectInt32, `reservedBitrate`],
4514
+ ResourceType: [, __expectString, `resourceType`],
4515
+ });
4739
4516
  };
4740
4517
  const de_Source = (output, context) => {
4741
- return {
4742
- DataTransferSubscriberFeePercent: __expectInt32(output.dataTransferSubscriberFeePercent),
4743
- Decryption: output.decryption != null ? de_Encryption(output.decryption, context) : undefined,
4744
- Description: __expectString(output.description),
4745
- EntitlementArn: __expectString(output.entitlementArn),
4746
- GatewayBridgeSource: output.gatewayBridgeSource != null ? de_GatewayBridgeSource(output.gatewayBridgeSource, context) : undefined,
4747
- IngestIp: __expectString(output.ingestIp),
4748
- IngestPort: __expectInt32(output.ingestPort),
4749
- MediaStreamSourceConfigurations: output.mediaStreamSourceConfigurations != null
4750
- ? de___listOfMediaStreamSourceConfiguration(output.mediaStreamSourceConfigurations, context)
4751
- : undefined,
4752
- Name: __expectString(output.name),
4753
- SenderControlPort: __expectInt32(output.senderControlPort),
4754
- SenderIpAddress: __expectString(output.senderIpAddress),
4755
- SourceArn: __expectString(output.sourceArn),
4756
- Transport: output.transport != null ? de_Transport(output.transport, context) : undefined,
4757
- VpcInterfaceName: __expectString(output.vpcInterfaceName),
4758
- WhitelistCidr: __expectString(output.whitelistCidr),
4759
- };
4518
+ return take(output, {
4519
+ DataTransferSubscriberFeePercent: [, __expectInt32, `dataTransferSubscriberFeePercent`],
4520
+ Decryption: (_) => [, de_Encryption(_, context), `decryption`],
4521
+ Description: [, __expectString, `description`],
4522
+ EntitlementArn: [, __expectString, `entitlementArn`],
4523
+ GatewayBridgeSource: (_) => [, de_GatewayBridgeSource(_, context), `gatewayBridgeSource`],
4524
+ IngestIp: [, __expectString, `ingestIp`],
4525
+ IngestPort: [, __expectInt32, `ingestPort`],
4526
+ MediaStreamSourceConfigurations: (_) => [
4527
+ ,
4528
+ de___listOfMediaStreamSourceConfiguration(_, context),
4529
+ `mediaStreamSourceConfigurations`,
4530
+ ],
4531
+ Name: [, __expectString, `name`],
4532
+ SenderControlPort: [, __expectInt32, `senderControlPort`],
4533
+ SenderIpAddress: [, __expectString, `senderIpAddress`],
4534
+ SourceArn: [, __expectString, `sourceArn`],
4535
+ Transport: (_) => [, de_Transport(_, context), `transport`],
4536
+ VpcInterfaceName: [, __expectString, `vpcInterfaceName`],
4537
+ WhitelistCidr: [, __expectString, `whitelistCidr`],
4538
+ });
4760
4539
  };
4761
4540
  const de_SourcePriority = (output, context) => {
4762
- return {
4763
- PrimarySource: __expectString(output.primarySource),
4764
- };
4541
+ return take(output, {
4542
+ PrimarySource: [, __expectString, `primarySource`],
4543
+ });
4765
4544
  };
4766
4545
  const de_Transport = (output, context) => {
4767
- return {
4768
- CidrAllowList: output.cidrAllowList != null ? de___listOf__string(output.cidrAllowList, context) : undefined,
4769
- MaxBitrate: __expectInt32(output.maxBitrate),
4770
- MaxLatency: __expectInt32(output.maxLatency),
4771
- MaxSyncBuffer: __expectInt32(output.maxSyncBuffer),
4772
- MinLatency: __expectInt32(output.minLatency),
4773
- Protocol: __expectString(output.protocol),
4774
- RemoteId: __expectString(output.remoteId),
4775
- SenderControlPort: __expectInt32(output.senderControlPort),
4776
- SenderIpAddress: __expectString(output.senderIpAddress),
4777
- SmoothingLatency: __expectInt32(output.smoothingLatency),
4778
- SourceListenerAddress: __expectString(output.sourceListenerAddress),
4779
- SourceListenerPort: __expectInt32(output.sourceListenerPort),
4780
- StreamId: __expectString(output.streamId),
4781
- };
4546
+ return take(output, {
4547
+ CidrAllowList: [, _json, `cidrAllowList`],
4548
+ MaxBitrate: [, __expectInt32, `maxBitrate`],
4549
+ MaxLatency: [, __expectInt32, `maxLatency`],
4550
+ MaxSyncBuffer: [, __expectInt32, `maxSyncBuffer`],
4551
+ MinLatency: [, __expectInt32, `minLatency`],
4552
+ Protocol: [, __expectString, `protocol`],
4553
+ RemoteId: [, __expectString, `remoteId`],
4554
+ SenderControlPort: [, __expectInt32, `senderControlPort`],
4555
+ SenderIpAddress: [, __expectString, `senderIpAddress`],
4556
+ SmoothingLatency: [, __expectInt32, `smoothingLatency`],
4557
+ SourceListenerAddress: [, __expectString, `sourceListenerAddress`],
4558
+ SourceListenerPort: [, __expectInt32, `sourceListenerPort`],
4559
+ StreamId: [, __expectString, `streamId`],
4560
+ });
4782
4561
  };
4783
4562
  const de_VpcInterface = (output, context) => {
4784
- return {
4785
- Name: __expectString(output.name),
4786
- NetworkInterfaceIds: output.networkInterfaceIds != null ? de___listOf__string(output.networkInterfaceIds, context) : undefined,
4787
- NetworkInterfaceType: __expectString(output.networkInterfaceType),
4788
- RoleArn: __expectString(output.roleArn),
4789
- SecurityGroupIds: output.securityGroupIds != null ? de___listOf__string(output.securityGroupIds, context) : undefined,
4790
- SubnetId: __expectString(output.subnetId),
4791
- };
4563
+ return take(output, {
4564
+ Name: [, __expectString, `name`],
4565
+ NetworkInterfaceIds: [, _json, `networkInterfaceIds`],
4566
+ NetworkInterfaceType: [, __expectString, `networkInterfaceType`],
4567
+ RoleArn: [, __expectString, `roleArn`],
4568
+ SecurityGroupIds: [, _json, `securityGroupIds`],
4569
+ SubnetId: [, __expectString, `subnetId`],
4570
+ });
4792
4571
  };
4793
4572
  const de_VpcInterfaceAttachment = (output, context) => {
4794
- return {
4795
- VpcInterfaceName: __expectString(output.vpcInterfaceName),
4796
- };
4573
+ return take(output, {
4574
+ VpcInterfaceName: [, __expectString, `vpcInterfaceName`],
4575
+ });
4797
4576
  };
4798
4577
  const deserializeMetadata = (output) => ({
4799
4578
  httpStatusCode: output.statusCode,