@aws-sdk/client-apigatewayv2 3.312.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 +1188 -2268
  2. package/dist-es/protocols/Aws_restJson1.js +1096 -2176
  3. package/package.json +6 -6
package/dist-es/protocols/Aws_restJson1.js CHANGED
@@ -1,5 +1,5 @@
1
1
  import { HttpRequest as __HttpRequest } from "@aws-sdk/protocol-http";
2
- import { decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectInt32 as __expectInt32, expectNonNull as __expectNonNull, expectObject as __expectObject, expectString as __expectString, limitedParseDouble as __limitedParseDouble, map as __map, parseRfc3339DateTimeWithOffset as __parseRfc3339DateTimeWithOffset, resolvedPath as __resolvedPath, serializeFloat as __serializeFloat, throwDefaultError, } from "@aws-sdk/smithy-client";
2
+ import { _json, decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectInt32 as __expectInt32, expectNonNull as __expectNonNull, expectObject as __expectObject, expectString as __expectString, limitedParseDouble as __limitedParseDouble, map, parseRfc3339DateTimeWithOffset as __parseRfc3339DateTimeWithOffset, resolvedPath as __resolvedPath, serializeFloat as __serializeFloat, take, withBaseException, } from "@aws-sdk/smithy-client";
3
3
  import { ApiGatewayV2ServiceException as __BaseException } from "../models/ApiGatewayV2ServiceException";
4
4
  import { AccessDeniedException, BadRequestException, ConflictException, NotFoundException, TooManyRequestsException, } from "../models/models_0";
5
5
  export const se_CreateApiCommand = async (input, context) => {
@@ -9,21 +9,21 @@ export const se_CreateApiCommand = async (input, context) => {
9
9
  };
10
10
  const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v2/apis";
11
11
  let body;
12
- body = JSON.stringify({
13
- ...(input.ApiKeySelectionExpression != null && { apiKeySelectionExpression: input.ApiKeySelectionExpression }),
14
- ...(input.CorsConfiguration != null && { corsConfiguration: se_Cors(input.CorsConfiguration, context) }),
15
- ...(input.CredentialsArn != null && { credentialsArn: input.CredentialsArn }),
16
- ...(input.Description != null && { description: input.Description }),
17
- ...(input.DisableExecuteApiEndpoint != null && { disableExecuteApiEndpoint: input.DisableExecuteApiEndpoint }),
18
- ...(input.DisableSchemaValidation != null && { disableSchemaValidation: input.DisableSchemaValidation }),
19
- ...(input.Name != null && { name: input.Name }),
20
- ...(input.ProtocolType != null && { protocolType: input.ProtocolType }),
21
- ...(input.RouteKey != null && { routeKey: input.RouteKey }),
22
- ...(input.RouteSelectionExpression != null && { routeSelectionExpression: input.RouteSelectionExpression }),
23
- ...(input.Tags != null && { tags: se_Tags(input.Tags, context) }),
24
- ...(input.Target != null && { target: input.Target }),
25
- ...(input.Version != null && { version: input.Version }),
26
- });
12
+ body = JSON.stringify(take(input, {
13
+ apiKeySelectionExpression: [, , `ApiKeySelectionExpression`],
14
+ corsConfiguration: [, (_) => se_Cors(_, context), `CorsConfiguration`],
15
+ credentialsArn: [, , `CredentialsArn`],
16
+ description: [, , `Description`],
17
+ disableExecuteApiEndpoint: [, , `DisableExecuteApiEndpoint`],
18
+ disableSchemaValidation: [, , `DisableSchemaValidation`],
19
+ name: [, , `Name`],
20
+ protocolType: [, , `ProtocolType`],
21
+ routeKey: [, , `RouteKey`],
22
+ routeSelectionExpression: [, , `RouteSelectionExpression`],
23
+ tags: [, (_) => _json(_), `Tags`],
24
+ target: [, , `Target`],
25
+ version: [, , `Version`],
26
+ }));
27
27
  return new __HttpRequest({
28
28
  protocol,
29
29
  hostname,
@@ -42,11 +42,11 @@ export const se_CreateApiMappingCommand = async (input, context) => {
42
42
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v2/domainnames/{DomainName}/apimappings";
43
43
  resolvedPath = __resolvedPath(resolvedPath, input, "DomainName", () => input.DomainName, "{DomainName}", false);
44
44
  let body;
45
- body = JSON.stringify({
46
- ...(input.ApiId != null && { apiId: input.ApiId }),
47
- ...(input.ApiMappingKey != null && { apiMappingKey: input.ApiMappingKey }),
48
- ...(input.Stage != null && { stage: input.Stage }),
49
- });
45
+ body = JSON.stringify(take(input, {
46
+ apiId: [, , `ApiId`],
47
+ apiMappingKey: [, , `ApiMappingKey`],
48
+ stage: [, , `Stage`],
49
+ }));
50
50
  return new __HttpRequest({
51
51
  protocol,
52
52
  hostname,
@@ -65,24 +65,18 @@ export const se_CreateAuthorizerCommand = async (input, context) => {
65
65
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v2/apis/{ApiId}/authorizers";
66
66
  resolvedPath = __resolvedPath(resolvedPath, input, "ApiId", () => input.ApiId, "{ApiId}", false);
67
67
  let body;
68
- body = JSON.stringify({
69
- ...(input.AuthorizerCredentialsArn != null && { authorizerCredentialsArn: input.AuthorizerCredentialsArn }),
70
- ...(input.AuthorizerPayloadFormatVersion != null && {
71
- authorizerPayloadFormatVersion: input.AuthorizerPayloadFormatVersion,
72
- }),
73
- ...(input.AuthorizerResultTtlInSeconds != null && {
74
- authorizerResultTtlInSeconds: input.AuthorizerResultTtlInSeconds,
75
- }),
76
- ...(input.AuthorizerType != null && { authorizerType: input.AuthorizerType }),
77
- ...(input.AuthorizerUri != null && { authorizerUri: input.AuthorizerUri }),
78
- ...(input.EnableSimpleResponses != null && { enableSimpleResponses: input.EnableSimpleResponses }),
79
- ...(input.IdentitySource != null && { identitySource: se_IdentitySourceList(input.IdentitySource, context) }),
80
- ...(input.IdentityValidationExpression != null && {
81
- identityValidationExpression: input.IdentityValidationExpression,
82
- }),
83
- ...(input.JwtConfiguration != null && { jwtConfiguration: se_JWTConfiguration(input.JwtConfiguration, context) }),
84
- ...(input.Name != null && { name: input.Name }),
85
- });
68
+ body = JSON.stringify(take(input, {
69
+ authorizerCredentialsArn: [, , `AuthorizerCredentialsArn`],
70
+ authorizerPayloadFormatVersion: [, , `AuthorizerPayloadFormatVersion`],
71
+ authorizerResultTtlInSeconds: [, , `AuthorizerResultTtlInSeconds`],
72
+ authorizerType: [, , `AuthorizerType`],
73
+ authorizerUri: [, , `AuthorizerUri`],
74
+ enableSimpleResponses: [, , `EnableSimpleResponses`],
75
+ identitySource: [, (_) => _json(_), `IdentitySource`],
76
+ identityValidationExpression: [, , `IdentityValidationExpression`],
77
+ jwtConfiguration: [, (_) => se_JWTConfiguration(_, context), `JwtConfiguration`],
78
+ name: [, , `Name`],
79
+ }));
86
80
  return new __HttpRequest({
87
81
  protocol,
88
82
  hostname,
@@ -101,10 +95,10 @@ export const se_CreateDeploymentCommand = async (input, context) => {
101
95
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v2/apis/{ApiId}/deployments";
102
96
  resolvedPath = __resolvedPath(resolvedPath, input, "ApiId", () => input.ApiId, "{ApiId}", false);
103
97
  let body;
104
- body = JSON.stringify({
105
- ...(input.Description != null && { description: input.Description }),
106
- ...(input.StageName != null && { stageName: input.StageName }),
107
- });
98
+ body = JSON.stringify(take(input, {
99
+ description: [, , `Description`],
100
+ stageName: [, , `StageName`],
101
+ }));
108
102
  return new __HttpRequest({
109
103
  protocol,
110
104
  hostname,
@@ -122,16 +116,12 @@ export const se_CreateDomainNameCommand = async (input, context) => {
122
116
  };
123
117
  const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v2/domainnames";
124
118
  let body;
125
- body = JSON.stringify({
126
- ...(input.DomainName != null && { domainName: input.DomainName }),
127
- ...(input.DomainNameConfigurations != null && {
128
- domainNameConfigurations: se_DomainNameConfigurations(input.DomainNameConfigurations, context),
129
- }),
130
- ...(input.MutualTlsAuthentication != null && {
131
- mutualTlsAuthentication: se_MutualTlsAuthenticationInput(input.MutualTlsAuthentication, context),
132
- }),
133
- ...(input.Tags != null && { tags: se_Tags(input.Tags, context) }),
134
- });
119
+ body = JSON.stringify(take(input, {
120
+ domainName: [, , `DomainName`],
121
+ domainNameConfigurations: [, (_) => se_DomainNameConfigurations(_, context), `DomainNameConfigurations`],
122
+ mutualTlsAuthentication: [, (_) => se_MutualTlsAuthenticationInput(_, context), `MutualTlsAuthentication`],
123
+ tags: [, (_) => _json(_), `Tags`],
124
+ }));
135
125
  return new __HttpRequest({
136
126
  protocol,
137
127
  hostname,
@@ -150,31 +140,25 @@ export const se_CreateIntegrationCommand = async (input, context) => {
150
140
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v2/apis/{ApiId}/integrations";
151
141
  resolvedPath = __resolvedPath(resolvedPath, input, "ApiId", () => input.ApiId, "{ApiId}", false);
152
142
  let body;
153
- body = JSON.stringify({
154
- ...(input.ConnectionId != null && { connectionId: input.ConnectionId }),
155
- ...(input.ConnectionType != null && { connectionType: input.ConnectionType }),
156
- ...(input.ContentHandlingStrategy != null && { contentHandlingStrategy: input.ContentHandlingStrategy }),
157
- ...(input.CredentialsArn != null && { credentialsArn: input.CredentialsArn }),
158
- ...(input.Description != null && { description: input.Description }),
159
- ...(input.IntegrationMethod != null && { integrationMethod: input.IntegrationMethod }),
160
- ...(input.IntegrationSubtype != null && { integrationSubtype: input.IntegrationSubtype }),
161
- ...(input.IntegrationType != null && { integrationType: input.IntegrationType }),
162
- ...(input.IntegrationUri != null && { integrationUri: input.IntegrationUri }),
163
- ...(input.PassthroughBehavior != null && { passthroughBehavior: input.PassthroughBehavior }),
164
- ...(input.PayloadFormatVersion != null && { payloadFormatVersion: input.PayloadFormatVersion }),
165
- ...(input.RequestParameters != null && {
166
- requestParameters: se_IntegrationParameters(input.RequestParameters, context),
167
- }),
168
- ...(input.RequestTemplates != null && { requestTemplates: se_TemplateMap(input.RequestTemplates, context) }),
169
- ...(input.ResponseParameters != null && {
170
- responseParameters: se_ResponseParameters(input.ResponseParameters, context),
171
- }),
172
- ...(input.TemplateSelectionExpression != null && {
173
- templateSelectionExpression: input.TemplateSelectionExpression,
174
- }),
175
- ...(input.TimeoutInMillis != null && { timeoutInMillis: input.TimeoutInMillis }),
176
- ...(input.TlsConfig != null && { tlsConfig: se_TlsConfigInput(input.TlsConfig, context) }),
177
- });
143
+ body = JSON.stringify(take(input, {
144
+ connectionId: [, , `ConnectionId`],
145
+ connectionType: [, , `ConnectionType`],
146
+ contentHandlingStrategy: [, , `ContentHandlingStrategy`],
147
+ credentialsArn: [, , `CredentialsArn`],
148
+ description: [, , `Description`],
149
+ integrationMethod: [, , `IntegrationMethod`],
150
+ integrationSubtype: [, , `IntegrationSubtype`],
151
+ integrationType: [, , `IntegrationType`],
152
+ integrationUri: [, , `IntegrationUri`],
153
+ passthroughBehavior: [, , `PassthroughBehavior`],
154
+ payloadFormatVersion: [, , `PayloadFormatVersion`],
155
+ requestParameters: [, (_) => _json(_), `RequestParameters`],
156
+ requestTemplates: [, (_) => _json(_), `RequestTemplates`],
157
+ responseParameters: [, (_) => _json(_), `ResponseParameters`],
158
+ templateSelectionExpression: [, , `TemplateSelectionExpression`],
159
+ timeoutInMillis: [, , `TimeoutInMillis`],
160
+ tlsConfig: [, (_) => se_TlsConfigInput(_, context), `TlsConfig`],
161
+ }));
178
162
  return new __HttpRequest({
179
163
  protocol,
180
164
  hostname,
@@ -195,17 +179,13 @@ export const se_CreateIntegrationResponseCommand = async (input, context) => {
195
179
  resolvedPath = __resolvedPath(resolvedPath, input, "ApiId", () => input.ApiId, "{ApiId}", false);
196
180
  resolvedPath = __resolvedPath(resolvedPath, input, "IntegrationId", () => input.IntegrationId, "{IntegrationId}", false);
197
181
  let body;
198
- body = JSON.stringify({
199
- ...(input.ContentHandlingStrategy != null && { contentHandlingStrategy: input.ContentHandlingStrategy }),
200
- ...(input.IntegrationResponseKey != null && { integrationResponseKey: input.IntegrationResponseKey }),
201
- ...(input.ResponseParameters != null && {
202
- responseParameters: se_IntegrationParameters(input.ResponseParameters, context),
203
- }),
204
- ...(input.ResponseTemplates != null && { responseTemplates: se_TemplateMap(input.ResponseTemplates, context) }),
205
- ...(input.TemplateSelectionExpression != null && {
206
- templateSelectionExpression: input.TemplateSelectionExpression,
207
- }),
208
- });
182
+ body = JSON.stringify(take(input, {
183
+ contentHandlingStrategy: [, , `ContentHandlingStrategy`],
184
+ integrationResponseKey: [, , `IntegrationResponseKey`],
185
+ responseParameters: [, (_) => _json(_), `ResponseParameters`],
186
+ responseTemplates: [, (_) => _json(_), `ResponseTemplates`],
187
+ templateSelectionExpression: [, , `TemplateSelectionExpression`],
188
+ }));
209
189
  return new __HttpRequest({
210
190
  protocol,
211
191
  hostname,
@@ -224,12 +204,12 @@ export const se_CreateModelCommand = async (input, context) => {
224
204
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v2/apis/{ApiId}/models";
225
205
  resolvedPath = __resolvedPath(resolvedPath, input, "ApiId", () => input.ApiId, "{ApiId}", false);
226
206
  let body;
227
- body = JSON.stringify({
228
- ...(input.ContentType != null && { contentType: input.ContentType }),
229
- ...(input.Description != null && { description: input.Description }),
230
- ...(input.Name != null && { name: input.Name }),
231
- ...(input.Schema != null && { schema: input.Schema }),
232
- });
207
+ body = JSON.stringify(take(input, {
208
+ contentType: [, , `ContentType`],
209
+ description: [, , `Description`],
210
+ name: [, , `Name`],
211
+ schema: [, , `Schema`],
212
+ }));
233
213
  return new __HttpRequest({
234
214
  protocol,
235
215
  hostname,
@@ -248,23 +228,19 @@ export const se_CreateRouteCommand = async (input, context) => {
248
228
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v2/apis/{ApiId}/routes";
249
229
  resolvedPath = __resolvedPath(resolvedPath, input, "ApiId", () => input.ApiId, "{ApiId}", false);
250
230
  let body;
251
- body = JSON.stringify({
252
- ...(input.ApiKeyRequired != null && { apiKeyRequired: input.ApiKeyRequired }),
253
- ...(input.AuthorizationScopes != null && {
254
- authorizationScopes: se_AuthorizationScopes(input.AuthorizationScopes, context),
255
- }),
256
- ...(input.AuthorizationType != null && { authorizationType: input.AuthorizationType }),
257
- ...(input.AuthorizerId != null && { authorizerId: input.AuthorizerId }),
258
- ...(input.ModelSelectionExpression != null && { modelSelectionExpression: input.ModelSelectionExpression }),
259
- ...(input.OperationName != null && { operationName: input.OperationName }),
260
- ...(input.RequestModels != null && { requestModels: se_RouteModels(input.RequestModels, context) }),
261
- ...(input.RequestParameters != null && { requestParameters: se_RouteParameters(input.RequestParameters, context) }),
262
- ...(input.RouteKey != null && { routeKey: input.RouteKey }),
263
- ...(input.RouteResponseSelectionExpression != null && {
264
- routeResponseSelectionExpression: input.RouteResponseSelectionExpression,
265
- }),
266
- ...(input.Target != null && { target: input.Target }),
267
- });
231
+ body = JSON.stringify(take(input, {
232
+ apiKeyRequired: [, , `ApiKeyRequired`],
233
+ authorizationScopes: [, (_) => _json(_), `AuthorizationScopes`],
234
+ authorizationType: [, , `AuthorizationType`],
235
+ authorizerId: [, , `AuthorizerId`],
236
+ modelSelectionExpression: [, , `ModelSelectionExpression`],
237
+ operationName: [, , `OperationName`],
238
+ requestModels: [, (_) => _json(_), `RequestModels`],
239
+ requestParameters: [, (_) => se_RouteParameters(_, context), `RequestParameters`],
240
+ routeKey: [, , `RouteKey`],
241
+ routeResponseSelectionExpression: [, , `RouteResponseSelectionExpression`],
242
+ target: [, , `Target`],
243
+ }));
268
244
  return new __HttpRequest({
269
245
  protocol,
270
246
  hostname,
@@ -285,14 +261,12 @@ export const se_CreateRouteResponseCommand = async (input, context) => {
285
261
  resolvedPath = __resolvedPath(resolvedPath, input, "ApiId", () => input.ApiId, "{ApiId}", false);
286
262
  resolvedPath = __resolvedPath(resolvedPath, input, "RouteId", () => input.RouteId, "{RouteId}", false);
287
263
  let body;
288
- body = JSON.stringify({
289
- ...(input.ModelSelectionExpression != null && { modelSelectionExpression: input.ModelSelectionExpression }),
290
- ...(input.ResponseModels != null && { responseModels: se_RouteModels(input.ResponseModels, context) }),
291
- ...(input.ResponseParameters != null && {
292
- responseParameters: se_RouteParameters(input.ResponseParameters, context),
293
- }),
294
- ...(input.RouteResponseKey != null && { routeResponseKey: input.RouteResponseKey }),
295
- });
264
+ body = JSON.stringify(take(input, {
265
+ modelSelectionExpression: [, , `ModelSelectionExpression`],
266
+ responseModels: [, (_) => _json(_), `ResponseModels`],
267
+ responseParameters: [, (_) => se_RouteParameters(_, context), `ResponseParameters`],
268
+ routeResponseKey: [, , `RouteResponseKey`],
269
+ }));
296
270
  return new __HttpRequest({
297
271
  protocol,
298
272
  hostname,
@@ -311,22 +285,18 @@ export const se_CreateStageCommand = async (input, context) => {
311
285
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v2/apis/{ApiId}/stages";
312
286
  resolvedPath = __resolvedPath(resolvedPath, input, "ApiId", () => input.ApiId, "{ApiId}", false);
313
287
  let body;
314
- body = JSON.stringify({
315
- ...(input.AccessLogSettings != null && {
316
- accessLogSettings: se_AccessLogSettings(input.AccessLogSettings, context),
317
- }),
318
- ...(input.AutoDeploy != null && { autoDeploy: input.AutoDeploy }),
319
- ...(input.ClientCertificateId != null && { clientCertificateId: input.ClientCertificateId }),
320
- ...(input.DefaultRouteSettings != null && {
321
- defaultRouteSettings: se_RouteSettings(input.DefaultRouteSettings, context),
322
- }),
323
- ...(input.DeploymentId != null && { deploymentId: input.DeploymentId }),
324
- ...(input.Description != null && { description: input.Description }),
325
- ...(input.RouteSettings != null && { routeSettings: se_RouteSettingsMap(input.RouteSettings, context) }),
326
- ...(input.StageName != null && { stageName: input.StageName }),
327
- ...(input.StageVariables != null && { stageVariables: se_StageVariablesMap(input.StageVariables, context) }),
328
- ...(input.Tags != null && { tags: se_Tags(input.Tags, context) }),
329
- });
288
+ body = JSON.stringify(take(input, {
289
+ accessLogSettings: [, (_) => se_AccessLogSettings(_, context), `AccessLogSettings`],
290
+ autoDeploy: [, , `AutoDeploy`],
291
+ clientCertificateId: [, , `ClientCertificateId`],
292
+ defaultRouteSettings: [, (_) => se_RouteSettings(_, context), `DefaultRouteSettings`],
293
+ deploymentId: [, , `DeploymentId`],
294
+ description: [, , `Description`],
295
+ routeSettings: [, (_) => se_RouteSettingsMap(_, context), `RouteSettings`],
296
+ stageName: [, , `StageName`],
297
+ stageVariables: [, (_) => _json(_), `StageVariables`],
298
+ tags: [, (_) => _json(_), `Tags`],
299
+ }));
330
300
  return new __HttpRequest({
331
301
  protocol,
332
302
  hostname,
@@ -344,14 +314,12 @@ export const se_CreateVpcLinkCommand = async (input, context) => {
344
314
  };
345
315
  const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v2/vpclinks";
346
316
  let body;
347
- body = JSON.stringify({
348
- ...(input.Name != null && { name: input.Name }),
349
- ...(input.SecurityGroupIds != null && {
350
- securityGroupIds: se_SecurityGroupIdList(input.SecurityGroupIds, context),
351
- }),
352
- ...(input.SubnetIds != null && { subnetIds: se_SubnetIdList(input.SubnetIds, context) }),
353
- ...(input.Tags != null && { tags: se_Tags(input.Tags, context) }),
354
- });
317
+ body = JSON.stringify(take(input, {
318
+ name: [, , `Name`],
319
+ securityGroupIds: [, (_) => _json(_), `SecurityGroupIds`],
320
+ subnetIds: [, (_) => _json(_), `SubnetIds`],
321
+ tags: [, (_) => _json(_), `Tags`],
322
+ }));
355
323
  return new __HttpRequest({
356
324
  protocol,
357
325
  hostname,
@@ -1174,9 +1142,9 @@ export const se_ImportApiCommand = async (input, context) => {
1174
1142
  failOnWarnings: [() => input.FailOnWarnings !== void 0, () => input.FailOnWarnings.toString()],
1175
1143
  });
1176
1144
  let body;
1177
- body = JSON.stringify({
1178
- ...(input.Body != null && { body: input.Body }),
1179
- });
1145
+ body = JSON.stringify(take(input, {
1146
+ body: [, , `Body`],
1147
+ }));
1180
1148
  return new __HttpRequest({
1181
1149
  protocol,
1182
1150
  hostname,
@@ -1200,9 +1168,9 @@ export const se_ReimportApiCommand = async (input, context) => {
1200
1168
  failOnWarnings: [() => input.FailOnWarnings !== void 0, () => input.FailOnWarnings.toString()],
1201
1169
  });
1202
1170
  let body;
1203
- body = JSON.stringify({
1204
- ...(input.Body != null && { body: input.Body }),
1205
- });
1171
+ body = JSON.stringify(take(input, {
1172
+ body: [, , `Body`],
1173
+ }));
1206
1174
  return new __HttpRequest({
1207
1175
  protocol,
1208
1176
  hostname,
@@ -1240,9 +1208,9 @@ export const se_TagResourceCommand = async (input, context) => {
1240
1208
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v2/tags/{ResourceArn}";
1241
1209
  resolvedPath = __resolvedPath(resolvedPath, input, "ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
1242
1210
  let body;
1243
- body = JSON.stringify({
1244
- ...(input.Tags != null && { tags: se_Tags(input.Tags, context) }),
1245
- });
1211
+ body = JSON.stringify(take(input, {
1212
+ tags: [, (_) => _json(_), `Tags`],
1213
+ }));
1246
1214
  return new __HttpRequest({
1247
1215
  protocol,
1248
1216
  hostname,
@@ -1284,19 +1252,19 @@ export const se_UpdateApiCommand = async (input, context) => {
1284
1252
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v2/apis/{ApiId}";
1285
1253
  resolvedPath = __resolvedPath(resolvedPath, input, "ApiId", () => input.ApiId, "{ApiId}", false);
1286
1254
  let body;
1287
- body = JSON.stringify({
1288
- ...(input.ApiKeySelectionExpression != null && { apiKeySelectionExpression: input.ApiKeySelectionExpression }),
1289
- ...(input.CorsConfiguration != null && { corsConfiguration: se_Cors(input.CorsConfiguration, context) }),
1290
- ...(input.CredentialsArn != null && { credentialsArn: input.CredentialsArn }),
1291
- ...(input.Description != null && { description: input.Description }),
1292
- ...(input.DisableExecuteApiEndpoint != null && { disableExecuteApiEndpoint: input.DisableExecuteApiEndpoint }),
1293
- ...(input.DisableSchemaValidation != null && { disableSchemaValidation: input.DisableSchemaValidation }),
1294
- ...(input.Name != null && { name: input.Name }),
1295
- ...(input.RouteKey != null && { routeKey: input.RouteKey }),
1296
- ...(input.RouteSelectionExpression != null && { routeSelectionExpression: input.RouteSelectionExpression }),
1297
- ...(input.Target != null && { target: input.Target }),
1298
- ...(input.Version != null && { version: input.Version }),
1299
- });
1255
+ body = JSON.stringify(take(input, {
1256
+ apiKeySelectionExpression: [, , `ApiKeySelectionExpression`],
1257
+ corsConfiguration: [, (_) => se_Cors(_, context), `CorsConfiguration`],
1258
+ credentialsArn: [, , `CredentialsArn`],
1259
+ description: [, , `Description`],
1260
+ disableExecuteApiEndpoint: [, , `DisableExecuteApiEndpoint`],
1261
+ disableSchemaValidation: [, , `DisableSchemaValidation`],
1262
+ name: [, , `Name`],
1263
+ routeKey: [, , `RouteKey`],
1264
+ routeSelectionExpression: [, , `RouteSelectionExpression`],
1265
+ target: [, , `Target`],
1266
+ version: [, , `Version`],
1267
+ }));
1300
1268
  return new __HttpRequest({
1301
1269
  protocol,
1302
1270
  hostname,
@@ -1317,11 +1285,11 @@ export const se_UpdateApiMappingCommand = async (input, context) => {
1317
1285
  resolvedPath = __resolvedPath(resolvedPath, input, "ApiMappingId", () => input.ApiMappingId, "{ApiMappingId}", false);
1318
1286
  resolvedPath = __resolvedPath(resolvedPath, input, "DomainName", () => input.DomainName, "{DomainName}", false);
1319
1287
  let body;
1320
- body = JSON.stringify({
1321
- ...(input.ApiId != null && { apiId: input.ApiId }),
1322
- ...(input.ApiMappingKey != null && { apiMappingKey: input.ApiMappingKey }),
1323
- ...(input.Stage != null && { stage: input.Stage }),
1324
- });
1288
+ body = JSON.stringify(take(input, {
1289
+ apiId: [, , `ApiId`],
1290
+ apiMappingKey: [, , `ApiMappingKey`],
1291
+ stage: [, , `Stage`],
1292
+ }));
1325
1293
  return new __HttpRequest({
1326
1294
  protocol,
1327
1295
  hostname,
@@ -1342,24 +1310,18 @@ export const se_UpdateAuthorizerCommand = async (input, context) => {
1342
1310
  resolvedPath = __resolvedPath(resolvedPath, input, "ApiId", () => input.ApiId, "{ApiId}", false);
1343
1311
  resolvedPath = __resolvedPath(resolvedPath, input, "AuthorizerId", () => input.AuthorizerId, "{AuthorizerId}", false);
1344
1312
  let body;
1345
- body = JSON.stringify({
1346
- ...(input.AuthorizerCredentialsArn != null && { authorizerCredentialsArn: input.AuthorizerCredentialsArn }),
1347
- ...(input.AuthorizerPayloadFormatVersion != null && {
1348
- authorizerPayloadFormatVersion: input.AuthorizerPayloadFormatVersion,
1349
- }),
1350
- ...(input.AuthorizerResultTtlInSeconds != null && {
1351
- authorizerResultTtlInSeconds: input.AuthorizerResultTtlInSeconds,
1352
- }),
1353
- ...(input.AuthorizerType != null && { authorizerType: input.AuthorizerType }),
1354
- ...(input.AuthorizerUri != null && { authorizerUri: input.AuthorizerUri }),
1355
- ...(input.EnableSimpleResponses != null && { enableSimpleResponses: input.EnableSimpleResponses }),
1356
- ...(input.IdentitySource != null && { identitySource: se_IdentitySourceList(input.IdentitySource, context) }),
1357
- ...(input.IdentityValidationExpression != null && {
1358
- identityValidationExpression: input.IdentityValidationExpression,
1359
- }),
1360
- ...(input.JwtConfiguration != null && { jwtConfiguration: se_JWTConfiguration(input.JwtConfiguration, context) }),
1361
- ...(input.Name != null && { name: input.Name }),
1362
- });
1313
+ body = JSON.stringify(take(input, {
1314
+ authorizerCredentialsArn: [, , `AuthorizerCredentialsArn`],
1315
+ authorizerPayloadFormatVersion: [, , `AuthorizerPayloadFormatVersion`],
1316
+ authorizerResultTtlInSeconds: [, , `AuthorizerResultTtlInSeconds`],
1317
+ authorizerType: [, , `AuthorizerType`],
1318
+ authorizerUri: [, , `AuthorizerUri`],
1319
+ enableSimpleResponses: [, , `EnableSimpleResponses`],
1320
+ identitySource: [, (_) => _json(_), `IdentitySource`],
1321
+ identityValidationExpression: [, , `IdentityValidationExpression`],
1322
+ jwtConfiguration: [, (_) => se_JWTConfiguration(_, context), `JwtConfiguration`],
1323
+ name: [, , `Name`],
1324
+ }));
1363
1325
  return new __HttpRequest({
1364
1326
  protocol,
1365
1327
  hostname,
@@ -1380,9 +1342,9 @@ export const se_UpdateDeploymentCommand = async (input, context) => {
1380
1342
  resolvedPath = __resolvedPath(resolvedPath, input, "ApiId", () => input.ApiId, "{ApiId}", false);
1381
1343
  resolvedPath = __resolvedPath(resolvedPath, input, "DeploymentId", () => input.DeploymentId, "{DeploymentId}", false);
1382
1344
  let body;
1383
- body = JSON.stringify({
1384
- ...(input.Description != null && { description: input.Description }),
1385
- });
1345
+ body = JSON.stringify(take(input, {
1346
+ description: [, , `Description`],
1347
+ }));
1386
1348
  return new __HttpRequest({
1387
1349
  protocol,
1388
1350
  hostname,
@@ -1401,14 +1363,10 @@ export const se_UpdateDomainNameCommand = async (input, context) => {
1401
1363
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v2/domainnames/{DomainName}";
1402
1364
  resolvedPath = __resolvedPath(resolvedPath, input, "DomainName", () => input.DomainName, "{DomainName}", false);
1403
1365
  let body;
1404
- body = JSON.stringify({
1405
- ...(input.DomainNameConfigurations != null && {
1406
- domainNameConfigurations: se_DomainNameConfigurations(input.DomainNameConfigurations, context),
1407
- }),
1408
- ...(input.MutualTlsAuthentication != null && {
1409
- mutualTlsAuthentication: se_MutualTlsAuthenticationInput(input.MutualTlsAuthentication, context),
1410
- }),
1411
- });
1366
+ body = JSON.stringify(take(input, {
1367
+ domainNameConfigurations: [, (_) => se_DomainNameConfigurations(_, context), `DomainNameConfigurations`],
1368
+ mutualTlsAuthentication: [, (_) => se_MutualTlsAuthenticationInput(_, context), `MutualTlsAuthentication`],
1369
+ }));
1412
1370
  return new __HttpRequest({
1413
1371
  protocol,
1414
1372
  hostname,
@@ -1429,31 +1387,25 @@ export const se_UpdateIntegrationCommand = async (input, context) => {
1429
1387
  resolvedPath = __resolvedPath(resolvedPath, input, "ApiId", () => input.ApiId, "{ApiId}", false);
1430
1388
  resolvedPath = __resolvedPath(resolvedPath, input, "IntegrationId", () => input.IntegrationId, "{IntegrationId}", false);
1431
1389
  let body;
1432
- body = JSON.stringify({
1433
- ...(input.ConnectionId != null && { connectionId: input.ConnectionId }),
1434
- ...(input.ConnectionType != null && { connectionType: input.ConnectionType }),
1435
- ...(input.ContentHandlingStrategy != null && { contentHandlingStrategy: input.ContentHandlingStrategy }),
1436
- ...(input.CredentialsArn != null && { credentialsArn: input.CredentialsArn }),
1437
- ...(input.Description != null && { description: input.Description }),
1438
- ...(input.IntegrationMethod != null && { integrationMethod: input.IntegrationMethod }),
1439
- ...(input.IntegrationSubtype != null && { integrationSubtype: input.IntegrationSubtype }),
1440
- ...(input.IntegrationType != null && { integrationType: input.IntegrationType }),
1441
- ...(input.IntegrationUri != null && { integrationUri: input.IntegrationUri }),
1442
- ...(input.PassthroughBehavior != null && { passthroughBehavior: input.PassthroughBehavior }),
1443
- ...(input.PayloadFormatVersion != null && { payloadFormatVersion: input.PayloadFormatVersion }),
1444
- ...(input.RequestParameters != null && {
1445
- requestParameters: se_IntegrationParameters(input.RequestParameters, context),
1446
- }),
1447
- ...(input.RequestTemplates != null && { requestTemplates: se_TemplateMap(input.RequestTemplates, context) }),
1448
- ...(input.ResponseParameters != null && {
1449
- responseParameters: se_ResponseParameters(input.ResponseParameters, context),
1450
- }),
1451
- ...(input.TemplateSelectionExpression != null && {
1452
- templateSelectionExpression: input.TemplateSelectionExpression,
1453
- }),
1454
- ...(input.TimeoutInMillis != null && { timeoutInMillis: input.TimeoutInMillis }),
1455
- ...(input.TlsConfig != null && { tlsConfig: se_TlsConfigInput(input.TlsConfig, context) }),
1456
- });
1390
+ body = JSON.stringify(take(input, {
1391
+ connectionId: [, , `ConnectionId`],
1392
+ connectionType: [, , `ConnectionType`],
1393
+ contentHandlingStrategy: [, , `ContentHandlingStrategy`],
1394
+ credentialsArn: [, , `CredentialsArn`],
1395
+ description: [, , `Description`],
1396
+ integrationMethod: [, , `IntegrationMethod`],
1397
+ integrationSubtype: [, , `IntegrationSubtype`],
1398
+ integrationType: [, , `IntegrationType`],
1399
+ integrationUri: [, , `IntegrationUri`],
1400
+ passthroughBehavior: [, , `PassthroughBehavior`],
1401
+ payloadFormatVersion: [, , `PayloadFormatVersion`],
1402
+ requestParameters: [, (_) => _json(_), `RequestParameters`],
1403
+ requestTemplates: [, (_) => _json(_), `RequestTemplates`],
1404
+ responseParameters: [, (_) => _json(_), `ResponseParameters`],
1405
+ templateSelectionExpression: [, , `TemplateSelectionExpression`],
1406
+ timeoutInMillis: [, , `TimeoutInMillis`],
1407
+ tlsConfig: [, (_) => se_TlsConfigInput(_, context), `TlsConfig`],
1408
+ }));
1457
1409
  return new __HttpRequest({
1458
1410
  protocol,
1459
1411
  hostname,
@@ -1475,17 +1427,13 @@ export const se_UpdateIntegrationResponseCommand = async (input, context) => {
1475
1427
  resolvedPath = __resolvedPath(resolvedPath, input, "IntegrationId", () => input.IntegrationId, "{IntegrationId}", false);
1476
1428
  resolvedPath = __resolvedPath(resolvedPath, input, "IntegrationResponseId", () => input.IntegrationResponseId, "{IntegrationResponseId}", false);
1477
1429
  let body;
1478
- body = JSON.stringify({
1479
- ...(input.ContentHandlingStrategy != null && { contentHandlingStrategy: input.ContentHandlingStrategy }),
1480
- ...(input.IntegrationResponseKey != null && { integrationResponseKey: input.IntegrationResponseKey }),
1481
- ...(input.ResponseParameters != null && {
1482
- responseParameters: se_IntegrationParameters(input.ResponseParameters, context),
1483
- }),
1484
- ...(input.ResponseTemplates != null && { responseTemplates: se_TemplateMap(input.ResponseTemplates, context) }),
1485
- ...(input.TemplateSelectionExpression != null && {
1486
- templateSelectionExpression: input.TemplateSelectionExpression,
1487
- }),
1488
- });
1430
+ body = JSON.stringify(take(input, {
1431
+ contentHandlingStrategy: [, , `ContentHandlingStrategy`],
1432
+ integrationResponseKey: [, , `IntegrationResponseKey`],
1433
+ responseParameters: [, (_) => _json(_), `ResponseParameters`],
1434
+ responseTemplates: [, (_) => _json(_), `ResponseTemplates`],
1435
+ templateSelectionExpression: [, , `TemplateSelectionExpression`],
1436
+ }));
1489
1437
  return new __HttpRequest({
1490
1438
  protocol,
1491
1439
  hostname,
@@ -1505,12 +1453,12 @@ export const se_UpdateModelCommand = async (input, context) => {
1505
1453
  resolvedPath = __resolvedPath(resolvedPath, input, "ApiId", () => input.ApiId, "{ApiId}", false);
1506
1454
  resolvedPath = __resolvedPath(resolvedPath, input, "ModelId", () => input.ModelId, "{ModelId}", false);
1507
1455
  let body;
1508
- body = JSON.stringify({
1509
- ...(input.ContentType != null && { contentType: input.ContentType }),
1510
- ...(input.Description != null && { description: input.Description }),
1511
- ...(input.Name != null && { name: input.Name }),
1512
- ...(input.Schema != null && { schema: input.Schema }),
1513
- });
1456
+ body = JSON.stringify(take(input, {
1457
+ contentType: [, , `ContentType`],
1458
+ description: [, , `Description`],
1459
+ name: [, , `Name`],
1460
+ schema: [, , `Schema`],
1461
+ }));
1514
1462
  return new __HttpRequest({
1515
1463
  protocol,
1516
1464
  hostname,
@@ -1530,23 +1478,19 @@ export const se_UpdateRouteCommand = async (input, context) => {
1530
1478
  resolvedPath = __resolvedPath(resolvedPath, input, "ApiId", () => input.ApiId, "{ApiId}", false);
1531
1479
  resolvedPath = __resolvedPath(resolvedPath, input, "RouteId", () => input.RouteId, "{RouteId}", false);
1532
1480
  let body;
1533
- body = JSON.stringify({
1534
- ...(input.ApiKeyRequired != null && { apiKeyRequired: input.ApiKeyRequired }),
1535
- ...(input.AuthorizationScopes != null && {
1536
- authorizationScopes: se_AuthorizationScopes(input.AuthorizationScopes, context),
1537
- }),
1538
- ...(input.AuthorizationType != null && { authorizationType: input.AuthorizationType }),
1539
- ...(input.AuthorizerId != null && { authorizerId: input.AuthorizerId }),
1540
- ...(input.ModelSelectionExpression != null && { modelSelectionExpression: input.ModelSelectionExpression }),
1541
- ...(input.OperationName != null && { operationName: input.OperationName }),
1542
- ...(input.RequestModels != null && { requestModels: se_RouteModels(input.RequestModels, context) }),
1543
- ...(input.RequestParameters != null && { requestParameters: se_RouteParameters(input.RequestParameters, context) }),
1544
- ...(input.RouteKey != null && { routeKey: input.RouteKey }),
1545
- ...(input.RouteResponseSelectionExpression != null && {
1546
- routeResponseSelectionExpression: input.RouteResponseSelectionExpression,
1547
- }),
1548
- ...(input.Target != null && { target: input.Target }),
1549
- });
1481
+ body = JSON.stringify(take(input, {
1482
+ apiKeyRequired: [, , `ApiKeyRequired`],
1483
+ authorizationScopes: [, (_) => _json(_), `AuthorizationScopes`],
1484
+ authorizationType: [, , `AuthorizationType`],
1485
+ authorizerId: [, , `AuthorizerId`],
1486
+ modelSelectionExpression: [, , `ModelSelectionExpression`],
1487
+ operationName: [, , `OperationName`],
1488
+ requestModels: [, (_) => _json(_), `RequestModels`],
1489
+ requestParameters: [, (_) => se_RouteParameters(_, context), `RequestParameters`],
1490
+ routeKey: [, , `RouteKey`],
1491
+ routeResponseSelectionExpression: [, , `RouteResponseSelectionExpression`],
1492
+ target: [, , `Target`],
1493
+ }));
1550
1494
  return new __HttpRequest({
1551
1495
  protocol,
1552
1496
  hostname,
@@ -1568,14 +1512,12 @@ export const se_UpdateRouteResponseCommand = async (input, context) => {
1568
1512
  resolvedPath = __resolvedPath(resolvedPath, input, "RouteId", () => input.RouteId, "{RouteId}", false);
1569
1513
  resolvedPath = __resolvedPath(resolvedPath, input, "RouteResponseId", () => input.RouteResponseId, "{RouteResponseId}", false);
1570
1514
  let body;
1571
- body = JSON.stringify({
1572
- ...(input.ModelSelectionExpression != null && { modelSelectionExpression: input.ModelSelectionExpression }),
1573
- ...(input.ResponseModels != null && { responseModels: se_RouteModels(input.ResponseModels, context) }),
1574
- ...(input.ResponseParameters != null && {
1575
- responseParameters: se_RouteParameters(input.ResponseParameters, context),
1576
- }),
1577
- ...(input.RouteResponseKey != null && { routeResponseKey: input.RouteResponseKey }),
1578
- });
1515
+ body = JSON.stringify(take(input, {
1516
+ modelSelectionExpression: [, , `ModelSelectionExpression`],
1517
+ responseModels: [, (_) => _json(_), `ResponseModels`],
1518
+ responseParameters: [, (_) => se_RouteParameters(_, context), `ResponseParameters`],
1519
+ routeResponseKey: [, , `RouteResponseKey`],
1520
+ }));
1579
1521
  return new __HttpRequest({
1580
1522
  protocol,
1581
1523
  hostname,
@@ -1595,20 +1537,16 @@ export const se_UpdateStageCommand = async (input, context) => {
1595
1537
  resolvedPath = __resolvedPath(resolvedPath, input, "ApiId", () => input.ApiId, "{ApiId}", false);
1596
1538
  resolvedPath = __resolvedPath(resolvedPath, input, "StageName", () => input.StageName, "{StageName}", false);
1597
1539
  let body;
1598
- body = JSON.stringify({
1599
- ...(input.AccessLogSettings != null && {
1600
- accessLogSettings: se_AccessLogSettings(input.AccessLogSettings, context),
1601
- }),
1602
- ...(input.AutoDeploy != null && { autoDeploy: input.AutoDeploy }),
1603
- ...(input.ClientCertificateId != null && { clientCertificateId: input.ClientCertificateId }),
1604
- ...(input.DefaultRouteSettings != null && {
1605
- defaultRouteSettings: se_RouteSettings(input.DefaultRouteSettings, context),
1606
- }),
1607
- ...(input.DeploymentId != null && { deploymentId: input.DeploymentId }),
1608
- ...(input.Description != null && { description: input.Description }),
1609
- ...(input.RouteSettings != null && { routeSettings: se_RouteSettingsMap(input.RouteSettings, context) }),
1610
- ...(input.StageVariables != null && { stageVariables: se_StageVariablesMap(input.StageVariables, context) }),
1611
- });
1540
+ body = JSON.stringify(take(input, {
1541
+ accessLogSettings: [, (_) => se_AccessLogSettings(_, context), `AccessLogSettings`],
1542
+ autoDeploy: [, , `AutoDeploy`],
1543
+ clientCertificateId: [, , `ClientCertificateId`],
1544
+ defaultRouteSettings: [, (_) => se_RouteSettings(_, context), `DefaultRouteSettings`],
1545
+ deploymentId: [, , `DeploymentId`],
1546
+ description: [, , `Description`],
1547
+ routeSettings: [, (_) => se_RouteSettingsMap(_, context), `RouteSettings`],
1548
+ stageVariables: [, (_) => _json(_), `StageVariables`],
1549
+ }));
1612
1550
  return new __HttpRequest({
1613
1551
  protocol,
1614
1552
  hostname,
@@ -1627,9 +1565,9 @@ export const se_UpdateVpcLinkCommand = async (input, context) => {
1627
1565
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v2/vpclinks/{VpcLinkId}";
1628
1566
  resolvedPath = __resolvedPath(resolvedPath, input, "VpcLinkId", () => input.VpcLinkId, "{VpcLinkId}", false);
1629
1567
  let body;
1630
- body = JSON.stringify({
1631
- ...(input.Name != null && { name: input.Name }),
1632
- });
1568
+ body = JSON.stringify(take(input, {
1569
+ name: [, , `Name`],
1570
+ }));
1633
1571
  return new __HttpRequest({
1634
1572
  protocol,
1635
1573
  hostname,
@@ -1648,54 +1586,25 @@ export const de_CreateApiCommand = async (output, context) => {
1648
1586
  $metadata: deserializeMetadata(output),
1649
1587
  });
1650
1588
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1651
- if (data.apiEndpoint != null) {
1652
- contents.ApiEndpoint = __expectString(data.apiEndpoint);
1653
- }
1654
- if (data.apiGatewayManaged != null) {
1655
- contents.ApiGatewayManaged = __expectBoolean(data.apiGatewayManaged);
1656
- }
1657
- if (data.apiId != null) {
1658
- contents.ApiId = __expectString(data.apiId);
1659
- }
1660
- if (data.apiKeySelectionExpression != null) {
1661
- contents.ApiKeySelectionExpression = __expectString(data.apiKeySelectionExpression);
1662
- }
1663
- if (data.corsConfiguration != null) {
1664
- contents.CorsConfiguration = de_Cors(data.corsConfiguration, context);
1665
- }
1666
- if (data.createdDate != null) {
1667
- contents.CreatedDate = __expectNonNull(__parseRfc3339DateTimeWithOffset(data.createdDate));
1668
- }
1669
- if (data.description != null) {
1670
- contents.Description = __expectString(data.description);
1671
- }
1672
- if (data.disableExecuteApiEndpoint != null) {
1673
- contents.DisableExecuteApiEndpoint = __expectBoolean(data.disableExecuteApiEndpoint);
1674
- }
1675
- if (data.disableSchemaValidation != null) {
1676
- contents.DisableSchemaValidation = __expectBoolean(data.disableSchemaValidation);
1677
- }
1678
- if (data.importInfo != null) {
1679
- contents.ImportInfo = de___listOf__string(data.importInfo, context);
1680
- }
1681
- if (data.name != null) {
1682
- contents.Name = __expectString(data.name);
1683
- }
1684
- if (data.protocolType != null) {
1685
- contents.ProtocolType = __expectString(data.protocolType);
1686
- }
1687
- if (data.routeSelectionExpression != null) {
1688
- contents.RouteSelectionExpression = __expectString(data.routeSelectionExpression);
1689
- }
1690
- if (data.tags != null) {
1691
- contents.Tags = de_Tags(data.tags, context);
1692
- }
1693
- if (data.version != null) {
1694
- contents.Version = __expectString(data.version);
1695
- }
1696
- if (data.warnings != null) {
1697
- contents.Warnings = de___listOf__string(data.warnings, context);
1698
- }
1589
+ const doc = take(data, {
1590
+ ApiEndpoint: [, __expectString, `apiEndpoint`],
1591
+ ApiGatewayManaged: [, __expectBoolean, `apiGatewayManaged`],
1592
+ ApiId: [, __expectString, `apiId`],
1593
+ ApiKeySelectionExpression: [, __expectString, `apiKeySelectionExpression`],
1594
+ CorsConfiguration: [, (_) => de_Cors(_, context), `corsConfiguration`],
1595
+ CreatedDate: [, (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)), `createdDate`],
1596
+ Description: [, __expectString, `description`],
1597
+ DisableExecuteApiEndpoint: [, __expectBoolean, `disableExecuteApiEndpoint`],
1598
+ DisableSchemaValidation: [, __expectBoolean, `disableSchemaValidation`],
1599
+ ImportInfo: [, _json, `importInfo`],
1600
+ Name: [, __expectString, `name`],
1601
+ ProtocolType: [, __expectString, `protocolType`],
1602
+ RouteSelectionExpression: [, __expectString, `routeSelectionExpression`],
1603
+ Tags: [, _json, `tags`],
1604
+ Version: [, __expectString, `version`],
1605
+ Warnings: [, _json, `warnings`],
1606
+ });
1607
+ Object.assign(contents, doc);
1699
1608
  return contents;
1700
1609
  };
1701
1610
  const de_CreateApiCommandError = async (output, context) => {
@@ -1719,10 +1628,9 @@ const de_CreateApiCommandError = async (output, context) => {
1719
1628
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1720
1629
  default:
1721
1630
  const parsedBody = parsedOutput.body;
1722
- throwDefaultError({
1631
+ return throwDefaultError({
1723
1632
  output,
1724
1633
  parsedBody,
1725
- exceptionCtor: __BaseException,
1726
1634
  errorCode,
1727
1635
  });
1728
1636
  }
@@ -1735,18 +1643,13 @@ export const de_CreateApiMappingCommand = async (output, context) => {
1735
1643
  $metadata: deserializeMetadata(output),
1736
1644
  });
1737
1645
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1738
- if (data.apiId != null) {
1739
- contents.ApiId = __expectString(data.apiId);
1740
- }
1741
- if (data.apiMappingId != null) {
1742
- contents.ApiMappingId = __expectString(data.apiMappingId);
1743
- }
1744
- if (data.apiMappingKey != null) {
1745
- contents.ApiMappingKey = __expectString(data.apiMappingKey);
1746
- }
1747
- if (data.stage != null) {
1748
- contents.Stage = __expectString(data.stage);
1749
- }
1646
+ const doc = take(data, {
1647
+ ApiId: [, __expectString, `apiId`],
1648
+ ApiMappingId: [, __expectString, `apiMappingId`],
1649
+ ApiMappingKey: [, __expectString, `apiMappingKey`],
1650
+ Stage: [, __expectString, `stage`],
1651
+ });
1652
+ Object.assign(contents, doc);
1750
1653
  return contents;
1751
1654
  };
1752
1655
  const de_CreateApiMappingCommandError = async (output, context) => {
@@ -1770,10 +1673,9 @@ const de_CreateApiMappingCommandError = async (output, context) => {
1770
1673
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1771
1674
  default:
1772
1675
  const parsedBody = parsedOutput.body;
1773
- throwDefaultError({
1676
+ return throwDefaultError({
1774
1677
  output,
1775
1678
  parsedBody,
1776
- exceptionCtor: __BaseException,
1777
1679
  errorCode,
1778
1680
  });
1779
1681
  }
@@ -1786,39 +1688,20 @@ export const de_CreateAuthorizerCommand = async (output, context) => {
1786
1688
  $metadata: deserializeMetadata(output),
1787
1689
  });
1788
1690
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1789
- if (data.authorizerCredentialsArn != null) {
1790
- contents.AuthorizerCredentialsArn = __expectString(data.authorizerCredentialsArn);
1791
- }
1792
- if (data.authorizerId != null) {
1793
- contents.AuthorizerId = __expectString(data.authorizerId);
1794
- }
1795
- if (data.authorizerPayloadFormatVersion != null) {
1796
- contents.AuthorizerPayloadFormatVersion = __expectString(data.authorizerPayloadFormatVersion);
1797
- }
1798
- if (data.authorizerResultTtlInSeconds != null) {
1799
- contents.AuthorizerResultTtlInSeconds = __expectInt32(data.authorizerResultTtlInSeconds);
1800
- }
1801
- if (data.authorizerType != null) {
1802
- contents.AuthorizerType = __expectString(data.authorizerType);
1803
- }
1804
- if (data.authorizerUri != null) {
1805
- contents.AuthorizerUri = __expectString(data.authorizerUri);
1806
- }
1807
- if (data.enableSimpleResponses != null) {
1808
- contents.EnableSimpleResponses = __expectBoolean(data.enableSimpleResponses);
1809
- }
1810
- if (data.identitySource != null) {
1811
- contents.IdentitySource = de_IdentitySourceList(data.identitySource, context);
1812
- }
1813
- if (data.identityValidationExpression != null) {
1814
- contents.IdentityValidationExpression = __expectString(data.identityValidationExpression);
1815
- }
1816
- if (data.jwtConfiguration != null) {
1817
- contents.JwtConfiguration = de_JWTConfiguration(data.jwtConfiguration, context);
1818
- }
1819
- if (data.name != null) {
1820
- contents.Name = __expectString(data.name);
1821
- }
1691
+ const doc = take(data, {
1692
+ AuthorizerCredentialsArn: [, __expectString, `authorizerCredentialsArn`],
1693
+ AuthorizerId: [, __expectString, `authorizerId`],
1694
+ AuthorizerPayloadFormatVersion: [, __expectString, `authorizerPayloadFormatVersion`],
1695
+ AuthorizerResultTtlInSeconds: [, __expectInt32, `authorizerResultTtlInSeconds`],
1696
+ AuthorizerType: [, __expectString, `authorizerType`],
1697
+ AuthorizerUri: [, __expectString, `authorizerUri`],
1698
+ EnableSimpleResponses: [, __expectBoolean, `enableSimpleResponses`],
1699
+ IdentitySource: [, _json, `identitySource`],
1700
+ IdentityValidationExpression: [, __expectString, `identityValidationExpression`],
1701
+ JwtConfiguration: [, (_) => de_JWTConfiguration(_, context), `jwtConfiguration`],
1702
+ Name: [, __expectString, `name`],
1703
+ });
1704
+ Object.assign(contents, doc);
1822
1705
  return contents;
1823
1706
  };
1824
1707
  const de_CreateAuthorizerCommandError = async (output, context) => {
@@ -1842,10 +1725,9 @@ const de_CreateAuthorizerCommandError = async (output, context) => {
1842
1725
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1843
1726
  default:
1844
1727
  const parsedBody = parsedOutput.body;
1845
- throwDefaultError({
1728
+ return throwDefaultError({
1846
1729
  output,
1847
1730
  parsedBody,
1848
- exceptionCtor: __BaseException,
1849
1731
  errorCode,
1850
1732
  });
1851
1733
  }
@@ -1858,24 +1740,15 @@ export const de_CreateDeploymentCommand = async (output, context) => {
1858
1740
  $metadata: deserializeMetadata(output),
1859
1741
  });
1860
1742
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1861
- if (data.autoDeployed != null) {
1862
- contents.AutoDeployed = __expectBoolean(data.autoDeployed);
1863
- }
1864
- if (data.createdDate != null) {
1865
- contents.CreatedDate = __expectNonNull(__parseRfc3339DateTimeWithOffset(data.createdDate));
1866
- }
1867
- if (data.deploymentId != null) {
1868
- contents.DeploymentId = __expectString(data.deploymentId);
1869
- }
1870
- if (data.deploymentStatus != null) {
1871
- contents.DeploymentStatus = __expectString(data.deploymentStatus);
1872
- }
1873
- if (data.deploymentStatusMessage != null) {
1874
- contents.DeploymentStatusMessage = __expectString(data.deploymentStatusMessage);
1875
- }
1876
- if (data.description != null) {
1877
- contents.Description = __expectString(data.description);
1878
- }
1743
+ const doc = take(data, {
1744
+ AutoDeployed: [, __expectBoolean, `autoDeployed`],
1745
+ CreatedDate: [, (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)), `createdDate`],
1746
+ DeploymentId: [, __expectString, `deploymentId`],
1747
+ DeploymentStatus: [, __expectString, `deploymentStatus`],
1748
+ DeploymentStatusMessage: [, __expectString, `deploymentStatusMessage`],
1749
+ Description: [, __expectString, `description`],
1750
+ });
1751
+ Object.assign(contents, doc);
1879
1752
  return contents;
1880
1753
  };
1881
1754
  const de_CreateDeploymentCommandError = async (output, context) => {
@@ -1899,10 +1772,9 @@ const de_CreateDeploymentCommandError = async (output, context) => {
1899
1772
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1900
1773
  default:
1901
1774
  const parsedBody = parsedOutput.body;
1902
- throwDefaultError({
1775
+ return throwDefaultError({
1903
1776
  output,
1904
1777
  parsedBody,
1905
- exceptionCtor: __BaseException,
1906
1778
  errorCode,
1907
1779
  });
1908
1780
  }
@@ -1915,21 +1787,14 @@ export const de_CreateDomainNameCommand = async (output, context) => {
1915
1787
  $metadata: deserializeMetadata(output),
1916
1788
  });
1917
1789
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1918
- if (data.apiMappingSelectionExpression != null) {
1919
- contents.ApiMappingSelectionExpression = __expectString(data.apiMappingSelectionExpression);
1920
- }
1921
- if (data.domainName != null) {
1922
- contents.DomainName = __expectString(data.domainName);
1923
- }
1924
- if (data.domainNameConfigurations != null) {
1925
- contents.DomainNameConfigurations = de_DomainNameConfigurations(data.domainNameConfigurations, context);
1926
- }
1927
- if (data.mutualTlsAuthentication != null) {
1928
- contents.MutualTlsAuthentication = de_MutualTlsAuthentication(data.mutualTlsAuthentication, context);
1929
- }
1930
- if (data.tags != null) {
1931
- contents.Tags = de_Tags(data.tags, context);
1932
- }
1790
+ const doc = take(data, {
1791
+ ApiMappingSelectionExpression: [, __expectString, `apiMappingSelectionExpression`],
1792
+ DomainName: [, __expectString, `domainName`],
1793
+ DomainNameConfigurations: [, (_) => de_DomainNameConfigurations(_, context), `domainNameConfigurations`],
1794
+ MutualTlsAuthentication: [, (_) => de_MutualTlsAuthentication(_, context), `mutualTlsAuthentication`],
1795
+ Tags: [, _json, `tags`],
1796
+ });
1797
+ Object.assign(contents, doc);
1933
1798
  return contents;
1934
1799
  };
1935
1800
  const de_CreateDomainNameCommandError = async (output, context) => {
@@ -1956,10 +1821,9 @@ const de_CreateDomainNameCommandError = async (output, context) => {
1956
1821
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1957
1822
  default:
1958
1823
  const parsedBody = parsedOutput.body;
1959
- throwDefaultError({
1824
+ return throwDefaultError({
1960
1825
  output,
1961
1826
  parsedBody,
1962
- exceptionCtor: __BaseException,
1963
1827
  errorCode,
1964
1828
  });
1965
1829
  }
@@ -1972,66 +1836,29 @@ export const de_CreateIntegrationCommand = async (output, context) => {
1972
1836
  $metadata: deserializeMetadata(output),
1973
1837
  });
1974
1838
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1975
- if (data.apiGatewayManaged != null) {
1976
- contents.ApiGatewayManaged = __expectBoolean(data.apiGatewayManaged);
1977
- }
1978
- if (data.connectionId != null) {
1979
- contents.ConnectionId = __expectString(data.connectionId);
1980
- }
1981
- if (data.connectionType != null) {
1982
- contents.ConnectionType = __expectString(data.connectionType);
1983
- }
1984
- if (data.contentHandlingStrategy != null) {
1985
- contents.ContentHandlingStrategy = __expectString(data.contentHandlingStrategy);
1986
- }
1987
- if (data.credentialsArn != null) {
1988
- contents.CredentialsArn = __expectString(data.credentialsArn);
1989
- }
1990
- if (data.description != null) {
1991
- contents.Description = __expectString(data.description);
1992
- }
1993
- if (data.integrationId != null) {
1994
- contents.IntegrationId = __expectString(data.integrationId);
1995
- }
1996
- if (data.integrationMethod != null) {
1997
- contents.IntegrationMethod = __expectString(data.integrationMethod);
1998
- }
1999
- if (data.integrationResponseSelectionExpression != null) {
2000
- contents.IntegrationResponseSelectionExpression = __expectString(data.integrationResponseSelectionExpression);
2001
- }
2002
- if (data.integrationSubtype != null) {
2003
- contents.IntegrationSubtype = __expectString(data.integrationSubtype);
2004
- }
2005
- if (data.integrationType != null) {
2006
- contents.IntegrationType = __expectString(data.integrationType);
2007
- }
2008
- if (data.integrationUri != null) {
2009
- contents.IntegrationUri = __expectString(data.integrationUri);
2010
- }
2011
- if (data.passthroughBehavior != null) {
2012
- contents.PassthroughBehavior = __expectString(data.passthroughBehavior);
2013
- }
2014
- if (data.payloadFormatVersion != null) {
2015
- contents.PayloadFormatVersion = __expectString(data.payloadFormatVersion);
2016
- }
2017
- if (data.requestParameters != null) {
2018
- contents.RequestParameters = de_IntegrationParameters(data.requestParameters, context);
2019
- }
2020
- if (data.requestTemplates != null) {
2021
- contents.RequestTemplates = de_TemplateMap(data.requestTemplates, context);
2022
- }
2023
- if (data.responseParameters != null) {
2024
- contents.ResponseParameters = de_ResponseParameters(data.responseParameters, context);
2025
- }
2026
- if (data.templateSelectionExpression != null) {
2027
- contents.TemplateSelectionExpression = __expectString(data.templateSelectionExpression);
2028
- }
2029
- if (data.timeoutInMillis != null) {
2030
- contents.TimeoutInMillis = __expectInt32(data.timeoutInMillis);
2031
- }
2032
- if (data.tlsConfig != null) {
2033
- contents.TlsConfig = de_TlsConfig(data.tlsConfig, context);
2034
- }
1839
+ const doc = take(data, {
1840
+ ApiGatewayManaged: [, __expectBoolean, `apiGatewayManaged`],
1841
+ ConnectionId: [, __expectString, `connectionId`],
1842
+ ConnectionType: [, __expectString, `connectionType`],
1843
+ ContentHandlingStrategy: [, __expectString, `contentHandlingStrategy`],
1844
+ CredentialsArn: [, __expectString, `credentialsArn`],
1845
+ Description: [, __expectString, `description`],
1846
+ IntegrationId: [, __expectString, `integrationId`],
1847
+ IntegrationMethod: [, __expectString, `integrationMethod`],
1848
+ IntegrationResponseSelectionExpression: [, __expectString, `integrationResponseSelectionExpression`],
1849
+ IntegrationSubtype: [, __expectString, `integrationSubtype`],
1850
+ IntegrationType: [, __expectString, `integrationType`],
1851
+ IntegrationUri: [, __expectString, `integrationUri`],
1852
+ PassthroughBehavior: [, __expectString, `passthroughBehavior`],
1853
+ PayloadFormatVersion: [, __expectString, `payloadFormatVersion`],
1854
+ RequestParameters: [, _json, `requestParameters`],
1855
+ RequestTemplates: [, _json, `requestTemplates`],
1856
+ ResponseParameters: [, _json, `responseParameters`],
1857
+ TemplateSelectionExpression: [, __expectString, `templateSelectionExpression`],
1858
+ TimeoutInMillis: [, __expectInt32, `timeoutInMillis`],
1859
+ TlsConfig: [, (_) => de_TlsConfig(_, context), `tlsConfig`],
1860
+ });
1861
+ Object.assign(contents, doc);
2035
1862
  return contents;
2036
1863
  };
2037
1864
  const de_CreateIntegrationCommandError = async (output, context) => {
@@ -2055,10 +1882,9 @@ const de_CreateIntegrationCommandError = async (output, context) => {
2055
1882
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
2056
1883
  default:
2057
1884
  const parsedBody = parsedOutput.body;
2058
- throwDefaultError({
1885
+ return throwDefaultError({
2059
1886
  output,
2060
1887
  parsedBody,
2061
- exceptionCtor: __BaseException,
2062
1888
  errorCode,
2063
1889
  });
2064
1890
  }
@@ -2071,24 +1897,15 @@ export const de_CreateIntegrationResponseCommand = async (output, context) => {
2071
1897
  $metadata: deserializeMetadata(output),
2072
1898
  });
2073
1899
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
2074
- if (data.contentHandlingStrategy != null) {
2075
- contents.ContentHandlingStrategy = __expectString(data.contentHandlingStrategy);
2076
- }
2077
- if (data.integrationResponseId != null) {
2078
- contents.IntegrationResponseId = __expectString(data.integrationResponseId);
2079
- }
2080
- if (data.integrationResponseKey != null) {
2081
- contents.IntegrationResponseKey = __expectString(data.integrationResponseKey);
2082
- }
2083
- if (data.responseParameters != null) {
2084
- contents.ResponseParameters = de_IntegrationParameters(data.responseParameters, context);
2085
- }
2086
- if (data.responseTemplates != null) {
2087
- contents.ResponseTemplates = de_TemplateMap(data.responseTemplates, context);
2088
- }
2089
- if (data.templateSelectionExpression != null) {
2090
- contents.TemplateSelectionExpression = __expectString(data.templateSelectionExpression);
2091
- }
1900
+ const doc = take(data, {
1901
+ ContentHandlingStrategy: [, __expectString, `contentHandlingStrategy`],
1902
+ IntegrationResponseId: [, __expectString, `integrationResponseId`],
1903
+ IntegrationResponseKey: [, __expectString, `integrationResponseKey`],
1904
+ ResponseParameters: [, _json, `responseParameters`],
1905
+ ResponseTemplates: [, _json, `responseTemplates`],
1906
+ TemplateSelectionExpression: [, __expectString, `templateSelectionExpression`],
1907
+ });
1908
+ Object.assign(contents, doc);
2092
1909
  return contents;
2093
1910
  };
2094
1911
  const de_CreateIntegrationResponseCommandError = async (output, context) => {
@@ -2112,10 +1929,9 @@ const de_CreateIntegrationResponseCommandError = async (output, context) => {
2112
1929
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
2113
1930
  default:
2114
1931
  const parsedBody = parsedOutput.body;
2115
- throwDefaultError({
1932
+ return throwDefaultError({
2116
1933
  output,
2117
1934
  parsedBody,
2118
- exceptionCtor: __BaseException,
2119
1935
  errorCode,
2120
1936
  });
2121
1937
  }
@@ -2128,21 +1944,14 @@ export const de_CreateModelCommand = async (output, context) => {
2128
1944
  $metadata: deserializeMetadata(output),
2129
1945
  });
2130
1946
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
2131
- if (data.contentType != null) {
2132
- contents.ContentType = __expectString(data.contentType);
2133
- }
2134
- if (data.description != null) {
2135
- contents.Description = __expectString(data.description);
2136
- }
2137
- if (data.modelId != null) {
2138
- contents.ModelId = __expectString(data.modelId);
2139
- }
2140
- if (data.name != null) {
2141
- contents.Name = __expectString(data.name);
2142
- }
2143
- if (data.schema != null) {
2144
- contents.Schema = __expectString(data.schema);
2145
- }
1947
+ const doc = take(data, {
1948
+ ContentType: [, __expectString, `contentType`],
1949
+ Description: [, __expectString, `description`],
1950
+ ModelId: [, __expectString, `modelId`],
1951
+ Name: [, __expectString, `name`],
1952
+ Schema: [, __expectString, `schema`],
1953
+ });
1954
+ Object.assign(contents, doc);
2146
1955
  return contents;
2147
1956
  };
2148
1957
  const de_CreateModelCommandError = async (output, context) => {
@@ -2166,10 +1975,9 @@ const de_CreateModelCommandError = async (output, context) => {
2166
1975
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
2167
1976
  default:
2168
1977
  const parsedBody = parsedOutput.body;
2169
- throwDefaultError({
1978
+ return throwDefaultError({
2170
1979
  output,
2171
1980
  parsedBody,
2172
- exceptionCtor: __BaseException,
2173
1981
  errorCode,
2174
1982
  });
2175
1983
  }
@@ -2182,45 +1990,22 @@ export const de_CreateRouteCommand = async (output, context) => {
2182
1990
  $metadata: deserializeMetadata(output),
2183
1991
  });
2184
1992
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
2185
- if (data.apiGatewayManaged != null) {
2186
- contents.ApiGatewayManaged = __expectBoolean(data.apiGatewayManaged);
2187
- }
2188
- if (data.apiKeyRequired != null) {
2189
- contents.ApiKeyRequired = __expectBoolean(data.apiKeyRequired);
2190
- }
2191
- if (data.authorizationScopes != null) {
2192
- contents.AuthorizationScopes = de_AuthorizationScopes(data.authorizationScopes, context);
2193
- }
2194
- if (data.authorizationType != null) {
2195
- contents.AuthorizationType = __expectString(data.authorizationType);
2196
- }
2197
- if (data.authorizerId != null) {
2198
- contents.AuthorizerId = __expectString(data.authorizerId);
2199
- }
2200
- if (data.modelSelectionExpression != null) {
2201
- contents.ModelSelectionExpression = __expectString(data.modelSelectionExpression);
2202
- }
2203
- if (data.operationName != null) {
2204
- contents.OperationName = __expectString(data.operationName);
2205
- }
2206
- if (data.requestModels != null) {
2207
- contents.RequestModels = de_RouteModels(data.requestModels, context);
2208
- }
2209
- if (data.requestParameters != null) {
2210
- contents.RequestParameters = de_RouteParameters(data.requestParameters, context);
2211
- }
2212
- if (data.routeId != null) {
2213
- contents.RouteId = __expectString(data.routeId);
2214
- }
2215
- if (data.routeKey != null) {
2216
- contents.RouteKey = __expectString(data.routeKey);
2217
- }
2218
- if (data.routeResponseSelectionExpression != null) {
2219
- contents.RouteResponseSelectionExpression = __expectString(data.routeResponseSelectionExpression);
2220
- }
2221
- if (data.target != null) {
2222
- contents.Target = __expectString(data.target);
2223
- }
1993
+ const doc = take(data, {
1994
+ ApiGatewayManaged: [, __expectBoolean, `apiGatewayManaged`],
1995
+ ApiKeyRequired: [, __expectBoolean, `apiKeyRequired`],
1996
+ AuthorizationScopes: [, _json, `authorizationScopes`],
1997
+ AuthorizationType: [, __expectString, `authorizationType`],
1998
+ AuthorizerId: [, __expectString, `authorizerId`],
1999
+ ModelSelectionExpression: [, __expectString, `modelSelectionExpression`],
2000
+ OperationName: [, __expectString, `operationName`],
2001
+ RequestModels: [, _json, `requestModels`],
2002
+ RequestParameters: [, (_) => de_RouteParameters(_, context), `requestParameters`],
2003
+ RouteId: [, __expectString, `routeId`],
2004
+ RouteKey: [, __expectString, `routeKey`],
2005
+ RouteResponseSelectionExpression: [, __expectString, `routeResponseSelectionExpression`],
2006
+ Target: [, __expectString, `target`],
2007
+ });
2008
+ Object.assign(contents, doc);
2224
2009
  return contents;
2225
2010
  };
2226
2011
  const de_CreateRouteCommandError = async (output, context) => {
@@ -2244,10 +2029,9 @@ const de_CreateRouteCommandError = async (output, context) => {
2244
2029
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
2245
2030
  default:
2246
2031
  const parsedBody = parsedOutput.body;
2247
- throwDefaultError({
2032
+ return throwDefaultError({
2248
2033
  output,
2249
2034
  parsedBody,
2250
- exceptionCtor: __BaseException,
2251
2035
  errorCode,
2252
2036
  });
2253
2037
  }
@@ -2260,21 +2044,14 @@ export const de_CreateRouteResponseCommand = async (output, context) => {
2260
2044
  $metadata: deserializeMetadata(output),
2261
2045
  });
2262
2046
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
2263
- if (data.modelSelectionExpression != null) {
2264
- contents.ModelSelectionExpression = __expectString(data.modelSelectionExpression);
2265
- }
2266
- if (data.responseModels != null) {
2267
- contents.ResponseModels = de_RouteModels(data.responseModels, context);
2268
- }
2269
- if (data.responseParameters != null) {
2270
- contents.ResponseParameters = de_RouteParameters(data.responseParameters, context);
2271
- }
2272
- if (data.routeResponseId != null) {
2273
- contents.RouteResponseId = __expectString(data.routeResponseId);
2274
- }
2275
- if (data.routeResponseKey != null) {
2276
- contents.RouteResponseKey = __expectString(data.routeResponseKey);
2277
- }
2047
+ const doc = take(data, {
2048
+ ModelSelectionExpression: [, __expectString, `modelSelectionExpression`],
2049
+ ResponseModels: [, _json, `responseModels`],
2050
+ ResponseParameters: [, (_) => de_RouteParameters(_, context), `responseParameters`],
2051
+ RouteResponseId: [, __expectString, `routeResponseId`],
2052
+ RouteResponseKey: [, __expectString, `routeResponseKey`],
2053
+ });
2054
+ Object.assign(contents, doc);
2278
2055
  return contents;
2279
2056
  };
2280
2057
  const de_CreateRouteResponseCommandError = async (output, context) => {
@@ -2298,10 +2075,9 @@ const de_CreateRouteResponseCommandError = async (output, context) => {
2298
2075
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
2299
2076
  default:
2300
2077
  const parsedBody = parsedOutput.body;
2301
- throwDefaultError({
2078
+ return throwDefaultError({
2302
2079
  output,
2303
2080
  parsedBody,
2304
- exceptionCtor: __BaseException,
2305
2081
  errorCode,
2306
2082
  });
2307
2083
  }
@@ -2314,48 +2090,23 @@ export const de_CreateStageCommand = async (output, context) => {
2314
2090
  $metadata: deserializeMetadata(output),
2315
2091
  });
2316
2092
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
2317
- if (data.accessLogSettings != null) {
2318
- contents.AccessLogSettings = de_AccessLogSettings(data.accessLogSettings, context);
2319
- }
2320
- if (data.apiGatewayManaged != null) {
2321
- contents.ApiGatewayManaged = __expectBoolean(data.apiGatewayManaged);
2322
- }
2323
- if (data.autoDeploy != null) {
2324
- contents.AutoDeploy = __expectBoolean(data.autoDeploy);
2325
- }
2326
- if (data.clientCertificateId != null) {
2327
- contents.ClientCertificateId = __expectString(data.clientCertificateId);
2328
- }
2329
- if (data.createdDate != null) {
2330
- contents.CreatedDate = __expectNonNull(__parseRfc3339DateTimeWithOffset(data.createdDate));
2331
- }
2332
- if (data.defaultRouteSettings != null) {
2333
- contents.DefaultRouteSettings = de_RouteSettings(data.defaultRouteSettings, context);
2334
- }
2335
- if (data.deploymentId != null) {
2336
- contents.DeploymentId = __expectString(data.deploymentId);
2337
- }
2338
- if (data.description != null) {
2339
- contents.Description = __expectString(data.description);
2340
- }
2341
- if (data.lastDeploymentStatusMessage != null) {
2342
- contents.LastDeploymentStatusMessage = __expectString(data.lastDeploymentStatusMessage);
2343
- }
2344
- if (data.lastUpdatedDate != null) {
2345
- contents.LastUpdatedDate = __expectNonNull(__parseRfc3339DateTimeWithOffset(data.lastUpdatedDate));
2346
- }
2347
- if (data.routeSettings != null) {
2348
- contents.RouteSettings = de_RouteSettingsMap(data.routeSettings, context);
2349
- }
2350
- if (data.stageName != null) {
2351
- contents.StageName = __expectString(data.stageName);
2352
- }
2353
- if (data.stageVariables != null) {
2354
- contents.StageVariables = de_StageVariablesMap(data.stageVariables, context);
2355
- }
2356
- if (data.tags != null) {
2357
- contents.Tags = de_Tags(data.tags, context);
2358
- }
2093
+ const doc = take(data, {
2094
+ AccessLogSettings: [, (_) => de_AccessLogSettings(_, context), `accessLogSettings`],
2095
+ ApiGatewayManaged: [, __expectBoolean, `apiGatewayManaged`],
2096
+ AutoDeploy: [, __expectBoolean, `autoDeploy`],
2097
+ ClientCertificateId: [, __expectString, `clientCertificateId`],
2098
+ CreatedDate: [, (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)), `createdDate`],
2099
+ DefaultRouteSettings: [, (_) => de_RouteSettings(_, context), `defaultRouteSettings`],
2100
+ DeploymentId: [, __expectString, `deploymentId`],
2101
+ Description: [, __expectString, `description`],
2102
+ LastDeploymentStatusMessage: [, __expectString, `lastDeploymentStatusMessage`],
2103
+ LastUpdatedDate: [, (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)), `lastUpdatedDate`],
2104
+ RouteSettings: [, (_) => de_RouteSettingsMap(_, context), `routeSettings`],
2105
+ StageName: [, __expectString, `stageName`],
2106
+ StageVariables: [, _json, `stageVariables`],
2107
+ Tags: [, _json, `tags`],
2108
+ });
2109
+ Object.assign(contents, doc);
2359
2110
  return contents;
2360
2111
  };
2361
2112
  const de_CreateStageCommandError = async (output, context) => {
@@ -2379,10 +2130,9 @@ const de_CreateStageCommandError = async (output, context) => {
2379
2130
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
2380
2131
  default:
2381
2132
  const parsedBody = parsedOutput.body;
2382
- throwDefaultError({
2133
+ return throwDefaultError({
2383
2134
  output,
2384
2135
  parsedBody,
2385
- exceptionCtor: __BaseException,
2386
2136
  errorCode,
2387
2137
  });
2388
2138
  }
@@ -2395,33 +2145,18 @@ export const de_CreateVpcLinkCommand = async (output, context) => {
2395
2145
  $metadata: deserializeMetadata(output),
2396
2146
  });
2397
2147
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
2398
- if (data.createdDate != null) {
2399
- contents.CreatedDate = __expectNonNull(__parseRfc3339DateTimeWithOffset(data.createdDate));
2400
- }
2401
- if (data.name != null) {
2402
- contents.Name = __expectString(data.name);
2403
- }
2404
- if (data.securityGroupIds != null) {
2405
- contents.SecurityGroupIds = de_SecurityGroupIdList(data.securityGroupIds, context);
2406
- }
2407
- if (data.subnetIds != null) {
2408
- contents.SubnetIds = de_SubnetIdList(data.subnetIds, context);
2409
- }
2410
- if (data.tags != null) {
2411
- contents.Tags = de_Tags(data.tags, context);
2412
- }
2413
- if (data.vpcLinkId != null) {
2414
- contents.VpcLinkId = __expectString(data.vpcLinkId);
2415
- }
2416
- if (data.vpcLinkStatus != null) {
2417
- contents.VpcLinkStatus = __expectString(data.vpcLinkStatus);
2418
- }
2419
- if (data.vpcLinkStatusMessage != null) {
2420
- contents.VpcLinkStatusMessage = __expectString(data.vpcLinkStatusMessage);
2421
- }
2422
- if (data.vpcLinkVersion != null) {
2423
- contents.VpcLinkVersion = __expectString(data.vpcLinkVersion);
2424
- }
2148
+ const doc = take(data, {
2149
+ CreatedDate: [, (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)), `createdDate`],
2150
+ Name: [, __expectString, `name`],
2151
+ SecurityGroupIds: [, _json, `securityGroupIds`],
2152
+ SubnetIds: [, _json, `subnetIds`],
2153
+ Tags: [, _json, `tags`],
2154
+ VpcLinkId: [, __expectString, `vpcLinkId`],
2155
+ VpcLinkStatus: [, __expectString, `vpcLinkStatus`],
2156
+ VpcLinkStatusMessage: [, __expectString, `vpcLinkStatusMessage`],
2157
+ VpcLinkVersion: [, __expectString, `vpcLinkVersion`],
2158
+ });
2159
+ Object.assign(contents, doc);
2425
2160
  return contents;
2426
2161
  };
2427
2162
  const de_CreateVpcLinkCommandError = async (output, context) => {
@@ -2439,10 +2174,9 @@ const de_CreateVpcLinkCommandError = async (output, context) => {
2439
2174
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
2440
2175
  default:
2441
2176
  const parsedBody = parsedOutput.body;
2442
- throwDefaultError({
2177
+ return throwDefaultError({
2443
2178
  output,
2444
2179
  parsedBody,
2445
- exceptionCtor: __BaseException,
2446
2180
  errorCode,
2447
2181
  });
2448
2182
  }
@@ -2472,10 +2206,9 @@ const de_DeleteAccessLogSettingsCommandError = async (output, context) => {
2472
2206
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
2473
2207
  default:
2474
2208
  const parsedBody = parsedOutput.body;
2475
- throwDefaultError({
2209
+ return throwDefaultError({
2476
2210
  output,
2477
2211
  parsedBody,
2478
- exceptionCtor: __BaseException,
2479
2212
  errorCode,
2480
2213
  });
2481
2214
  }
@@ -2505,10 +2238,9 @@ const de_DeleteApiCommandError = async (output, context) => {
2505
2238
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
2506
2239
  default:
2507
2240
  const parsedBody = parsedOutput.body;
2508
- throwDefaultError({
2241
+ return throwDefaultError({
2509
2242
  output,
2510
2243
  parsedBody,
2511
- exceptionCtor: __BaseException,
2512
2244
  errorCode,
2513
2245
  });
2514
2246
  }
@@ -2541,10 +2273,9 @@ const de_DeleteApiMappingCommandError = async (output, context) => {
2541
2273
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
2542
2274
  default:
2543
2275
  const parsedBody = parsedOutput.body;
2544
- throwDefaultError({
2276
+ return throwDefaultError({
2545
2277
  output,
2546
2278
  parsedBody,
2547
- exceptionCtor: __BaseException,
2548
2279
  errorCode,
2549
2280
  });
2550
2281
  }
@@ -2574,10 +2305,9 @@ const de_DeleteAuthorizerCommandError = async (output, context) => {
2574
2305
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
2575
2306
  default:
2576
2307
  const parsedBody = parsedOutput.body;
2577
- throwDefaultError({
2308
+ return throwDefaultError({
2578
2309
  output,
2579
2310
  parsedBody,
2580
- exceptionCtor: __BaseException,
2581
2311
  errorCode,
2582
2312
  });
2583
2313
  }
@@ -2607,10 +2337,9 @@ const de_DeleteCorsConfigurationCommandError = async (output, context) => {
2607
2337
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
2608
2338
  default:
2609
2339
  const parsedBody = parsedOutput.body;
2610
- throwDefaultError({
2340
+ return throwDefaultError({
2611
2341
  output,
2612
2342
  parsedBody,
2613
- exceptionCtor: __BaseException,
2614
2343
  errorCode,
2615
2344
  });
2616
2345
  }
@@ -2640,10 +2369,9 @@ const de_DeleteDeploymentCommandError = async (output, context) => {
2640
2369
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
2641
2370
  default:
2642
2371
  const parsedBody = parsedOutput.body;
2643
- throwDefaultError({
2372
+ return throwDefaultError({
2644
2373
  output,
2645
2374
  parsedBody,
2646
- exceptionCtor: __BaseException,
2647
2375
  errorCode,
2648
2376
  });
2649
2377
  }
@@ -2673,10 +2401,9 @@ const de_DeleteDomainNameCommandError = async (output, context) => {
2673
2401
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
2674
2402
  default:
2675
2403
  const parsedBody = parsedOutput.body;
2676
- throwDefaultError({
2404
+ return throwDefaultError({
2677
2405
  output,
2678
2406
  parsedBody,
2679
- exceptionCtor: __BaseException,
2680
2407
  errorCode,
2681
2408
  });
2682
2409
  }
@@ -2706,10 +2433,9 @@ const de_DeleteIntegrationCommandError = async (output, context) => {
2706
2433
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
2707
2434
  default:
2708
2435
  const parsedBody = parsedOutput.body;
2709
- throwDefaultError({
2436
+ return throwDefaultError({
2710
2437
  output,
2711
2438
  parsedBody,
2712
- exceptionCtor: __BaseException,
2713
2439
  errorCode,
2714
2440
  });
2715
2441
  }
@@ -2739,10 +2465,9 @@ const de_DeleteIntegrationResponseCommandError = async (output, context) => {
2739
2465
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
2740
2466
  default:
2741
2467
  const parsedBody = parsedOutput.body;
2742
- throwDefaultError({
2468
+ return throwDefaultError({
2743
2469
  output,
2744
2470
  parsedBody,
2745
- exceptionCtor: __BaseException,
2746
2471
  errorCode,
2747
2472
  });
2748
2473
  }
@@ -2772,10 +2497,9 @@ const de_DeleteModelCommandError = async (output, context) => {
2772
2497
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
2773
2498
  default:
2774
2499
  const parsedBody = parsedOutput.body;
2775
- throwDefaultError({
2500
+ return throwDefaultError({
2776
2501
  output,
2777
2502
  parsedBody,
2778
- exceptionCtor: __BaseException,
2779
2503
  errorCode,
2780
2504
  });
2781
2505
  }
@@ -2805,10 +2529,9 @@ const de_DeleteRouteCommandError = async (output, context) => {
2805
2529
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
2806
2530
  default:
2807
2531
  const parsedBody = parsedOutput.body;
2808
- throwDefaultError({
2532
+ return throwDefaultError({
2809
2533
  output,
2810
2534
  parsedBody,
2811
- exceptionCtor: __BaseException,
2812
2535
  errorCode,
2813
2536
  });
2814
2537
  }
@@ -2838,10 +2561,9 @@ const de_DeleteRouteRequestParameterCommandError = async (output, context) => {
2838
2561
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
2839
2562
  default:
2840
2563
  const parsedBody = parsedOutput.body;
2841
- throwDefaultError({
2564
+ return throwDefaultError({
2842
2565
  output,
2843
2566
  parsedBody,
2844
- exceptionCtor: __BaseException,
2845
2567
  errorCode,
2846
2568
  });
2847
2569
  }
@@ -2871,10 +2593,9 @@ const de_DeleteRouteResponseCommandError = async (output, context) => {
2871
2593
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
2872
2594
  default:
2873
2595
  const parsedBody = parsedOutput.body;
2874
- throwDefaultError({
2596
+ return throwDefaultError({
2875
2597
  output,
2876
2598
  parsedBody,
2877
- exceptionCtor: __BaseException,
2878
2599
  errorCode,
2879
2600
  });
2880
2601
  }
@@ -2904,10 +2625,9 @@ const de_DeleteRouteSettingsCommandError = async (output, context) => {
2904
2625
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
2905
2626
  default:
2906
2627
  const parsedBody = parsedOutput.body;
2907
- throwDefaultError({
2628
+ return throwDefaultError({
2908
2629
  output,
2909
2630
  parsedBody,
2910
- exceptionCtor: __BaseException,
2911
2631
  errorCode,
2912
2632
  });
2913
2633
  }
@@ -2937,10 +2657,9 @@ const de_DeleteStageCommandError = async (output, context) => {
2937
2657
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
2938
2658
  default:
2939
2659
  const parsedBody = parsedOutput.body;
2940
- throwDefaultError({
2660
+ return throwDefaultError({
2941
2661
  output,
2942
2662
  parsedBody,
2943
- exceptionCtor: __BaseException,
2944
2663
  errorCode,
2945
2664
  });
2946
2665
  }
@@ -2970,10 +2689,9 @@ const de_DeleteVpcLinkCommandError = async (output, context) => {
2970
2689
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
2971
2690
  default:
2972
2691
  const parsedBody = parsedOutput.body;
2973
- throwDefaultError({
2692
+ return throwDefaultError({
2974
2693
  output,
2975
2694
  parsedBody,
2976
- exceptionCtor: __BaseException,
2977
2695
  errorCode,
2978
2696
  });
2979
2697
  }
@@ -3007,10 +2725,9 @@ const de_ExportApiCommandError = async (output, context) => {
3007
2725
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
3008
2726
  default:
3009
2727
  const parsedBody = parsedOutput.body;
3010
- throwDefaultError({
2728
+ return throwDefaultError({
3011
2729
  output,
3012
2730
  parsedBody,
3013
- exceptionCtor: __BaseException,
3014
2731
  errorCode,
3015
2732
  });
3016
2733
  }
@@ -3023,54 +2740,25 @@ export const de_GetApiCommand = async (output, context) => {
3023
2740
  $metadata: deserializeMetadata(output),
3024
2741
  });
3025
2742
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
3026
- if (data.apiEndpoint != null) {
3027
- contents.ApiEndpoint = __expectString(data.apiEndpoint);
3028
- }
3029
- if (data.apiGatewayManaged != null) {
3030
- contents.ApiGatewayManaged = __expectBoolean(data.apiGatewayManaged);
3031
- }
3032
- if (data.apiId != null) {
3033
- contents.ApiId = __expectString(data.apiId);
3034
- }
3035
- if (data.apiKeySelectionExpression != null) {
3036
- contents.ApiKeySelectionExpression = __expectString(data.apiKeySelectionExpression);
3037
- }
3038
- if (data.corsConfiguration != null) {
3039
- contents.CorsConfiguration = de_Cors(data.corsConfiguration, context);
3040
- }
3041
- if (data.createdDate != null) {
3042
- contents.CreatedDate = __expectNonNull(__parseRfc3339DateTimeWithOffset(data.createdDate));
3043
- }
3044
- if (data.description != null) {
3045
- contents.Description = __expectString(data.description);
3046
- }
3047
- if (data.disableExecuteApiEndpoint != null) {
3048
- contents.DisableExecuteApiEndpoint = __expectBoolean(data.disableExecuteApiEndpoint);
3049
- }
3050
- if (data.disableSchemaValidation != null) {
3051
- contents.DisableSchemaValidation = __expectBoolean(data.disableSchemaValidation);
3052
- }
3053
- if (data.importInfo != null) {
3054
- contents.ImportInfo = de___listOf__string(data.importInfo, context);
3055
- }
3056
- if (data.name != null) {
3057
- contents.Name = __expectString(data.name);
3058
- }
3059
- if (data.protocolType != null) {
3060
- contents.ProtocolType = __expectString(data.protocolType);
3061
- }
3062
- if (data.routeSelectionExpression != null) {
3063
- contents.RouteSelectionExpression = __expectString(data.routeSelectionExpression);
3064
- }
3065
- if (data.tags != null) {
3066
- contents.Tags = de_Tags(data.tags, context);
3067
- }
3068
- if (data.version != null) {
3069
- contents.Version = __expectString(data.version);
3070
- }
3071
- if (data.warnings != null) {
3072
- contents.Warnings = de___listOf__string(data.warnings, context);
3073
- }
2743
+ const doc = take(data, {
2744
+ ApiEndpoint: [, __expectString, `apiEndpoint`],
2745
+ ApiGatewayManaged: [, __expectBoolean, `apiGatewayManaged`],
2746
+ ApiId: [, __expectString, `apiId`],
2747
+ ApiKeySelectionExpression: [, __expectString, `apiKeySelectionExpression`],
2748
+ CorsConfiguration: [, (_) => de_Cors(_, context), `corsConfiguration`],
2749
+ CreatedDate: [, (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)), `createdDate`],
2750
+ Description: [, __expectString, `description`],
2751
+ DisableExecuteApiEndpoint: [, __expectBoolean, `disableExecuteApiEndpoint`],
2752
+ DisableSchemaValidation: [, __expectBoolean, `disableSchemaValidation`],
2753
+ ImportInfo: [, _json, `importInfo`],
2754
+ Name: [, __expectString, `name`],
2755
+ ProtocolType: [, __expectString, `protocolType`],
2756
+ RouteSelectionExpression: [, __expectString, `routeSelectionExpression`],
2757
+ Tags: [, _json, `tags`],
2758
+ Version: [, __expectString, `version`],
2759
+ Warnings: [, _json, `warnings`],
2760
+ });
2761
+ Object.assign(contents, doc);
3074
2762
  return contents;
3075
2763
  };
3076
2764
  const de_GetApiCommandError = async (output, context) => {
@@ -3088,10 +2776,9 @@ const de_GetApiCommandError = async (output, context) => {
3088
2776
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
3089
2777
  default:
3090
2778
  const parsedBody = parsedOutput.body;
3091
- throwDefaultError({
2779
+ return throwDefaultError({
3092
2780
  output,
3093
2781
  parsedBody,
3094
- exceptionCtor: __BaseException,
3095
2782
  errorCode,
3096
2783
  });
3097
2784
  }
@@ -3104,18 +2791,13 @@ export const de_GetApiMappingCommand = async (output, context) => {
3104
2791
  $metadata: deserializeMetadata(output),
3105
2792
  });
3106
2793
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
3107
- if (data.apiId != null) {
3108
- contents.ApiId = __expectString(data.apiId);
3109
- }
3110
- if (data.apiMappingId != null) {
3111
- contents.ApiMappingId = __expectString(data.apiMappingId);
3112
- }
3113
- if (data.apiMappingKey != null) {
3114
- contents.ApiMappingKey = __expectString(data.apiMappingKey);
3115
- }
3116
- if (data.stage != null) {
3117
- contents.Stage = __expectString(data.stage);
3118
- }
2794
+ const doc = take(data, {
2795
+ ApiId: [, __expectString, `apiId`],
2796
+ ApiMappingId: [, __expectString, `apiMappingId`],
2797
+ ApiMappingKey: [, __expectString, `apiMappingKey`],
2798
+ Stage: [, __expectString, `stage`],
2799
+ });
2800
+ Object.assign(contents, doc);
3119
2801
  return contents;
3120
2802
  };
3121
2803
  const de_GetApiMappingCommandError = async (output, context) => {
@@ -3136,10 +2818,9 @@ const de_GetApiMappingCommandError = async (output, context) => {
3136
2818
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
3137
2819
  default:
3138
2820
  const parsedBody = parsedOutput.body;
3139
- throwDefaultError({
2821
+ return throwDefaultError({
3140
2822
  output,
3141
2823
  parsedBody,
3142
- exceptionCtor: __BaseException,
3143
2824
  errorCode,
3144
2825
  });
3145
2826
  }
@@ -3152,12 +2833,11 @@ export const de_GetApiMappingsCommand = async (output, context) => {
3152
2833
  $metadata: deserializeMetadata(output),
3153
2834
  });
3154
2835
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
3155
- if (data.items != null) {
3156
- contents.Items = de___listOfApiMapping(data.items, context);
3157
- }
3158
- if (data.nextToken != null) {
3159
- contents.NextToken = __expectString(data.nextToken);
3160
- }
2836
+ const doc = take(data, {
2837
+ Items: [, (_) => de___listOfApiMapping(_, context), `items`],
2838
+ NextToken: [, __expectString, `nextToken`],
2839
+ });
2840
+ Object.assign(contents, doc);
3161
2841
  return contents;
3162
2842
  };
3163
2843
  const de_GetApiMappingsCommandError = async (output, context) => {
@@ -3178,10 +2858,9 @@ const de_GetApiMappingsCommandError = async (output, context) => {
3178
2858
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
3179
2859
  default:
3180
2860
  const parsedBody = parsedOutput.body;
3181
- throwDefaultError({
2861
+ return throwDefaultError({
3182
2862
  output,
3183
2863
  parsedBody,
3184
- exceptionCtor: __BaseException,
3185
2864
  errorCode,
3186
2865
  });
3187
2866
  }
@@ -3194,12 +2873,11 @@ export const de_GetApisCommand = async (output, context) => {
3194
2873
  $metadata: deserializeMetadata(output),
3195
2874
  });
3196
2875
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
3197
- if (data.items != null) {
3198
- contents.Items = de___listOfApi(data.items, context);
3199
- }
3200
- if (data.nextToken != null) {
3201
- contents.NextToken = __expectString(data.nextToken);
3202
- }
2876
+ const doc = take(data, {
2877
+ Items: [, (_) => de___listOfApi(_, context), `items`],
2878
+ NextToken: [, __expectString, `nextToken`],
2879
+ });
2880
+ Object.assign(contents, doc);
3203
2881
  return contents;
3204
2882
  };
3205
2883
  const de_GetApisCommandError = async (output, context) => {
@@ -3220,10 +2898,9 @@ const de_GetApisCommandError = async (output, context) => {
3220
2898
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
3221
2899
  default:
3222
2900
  const parsedBody = parsedOutput.body;
3223
- throwDefaultError({
2901
+ return throwDefaultError({
3224
2902
  output,
3225
2903
  parsedBody,
3226
- exceptionCtor: __BaseException,
3227
2904
  errorCode,
3228
2905
  });
3229
2906
  }
@@ -3236,39 +2913,20 @@ export const de_GetAuthorizerCommand = async (output, context) => {
3236
2913
  $metadata: deserializeMetadata(output),
3237
2914
  });
3238
2915
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
3239
- if (data.authorizerCredentialsArn != null) {
3240
- contents.AuthorizerCredentialsArn = __expectString(data.authorizerCredentialsArn);
3241
- }
3242
- if (data.authorizerId != null) {
3243
- contents.AuthorizerId = __expectString(data.authorizerId);
3244
- }
3245
- if (data.authorizerPayloadFormatVersion != null) {
3246
- contents.AuthorizerPayloadFormatVersion = __expectString(data.authorizerPayloadFormatVersion);
3247
- }
3248
- if (data.authorizerResultTtlInSeconds != null) {
3249
- contents.AuthorizerResultTtlInSeconds = __expectInt32(data.authorizerResultTtlInSeconds);
3250
- }
3251
- if (data.authorizerType != null) {
3252
- contents.AuthorizerType = __expectString(data.authorizerType);
3253
- }
3254
- if (data.authorizerUri != null) {
3255
- contents.AuthorizerUri = __expectString(data.authorizerUri);
3256
- }
3257
- if (data.enableSimpleResponses != null) {
3258
- contents.EnableSimpleResponses = __expectBoolean(data.enableSimpleResponses);
3259
- }
3260
- if (data.identitySource != null) {
3261
- contents.IdentitySource = de_IdentitySourceList(data.identitySource, context);
3262
- }
3263
- if (data.identityValidationExpression != null) {
3264
- contents.IdentityValidationExpression = __expectString(data.identityValidationExpression);
3265
- }
3266
- if (data.jwtConfiguration != null) {
3267
- contents.JwtConfiguration = de_JWTConfiguration(data.jwtConfiguration, context);
3268
- }
3269
- if (data.name != null) {
3270
- contents.Name = __expectString(data.name);
3271
- }
2916
+ const doc = take(data, {
2917
+ AuthorizerCredentialsArn: [, __expectString, `authorizerCredentialsArn`],
2918
+ AuthorizerId: [, __expectString, `authorizerId`],
2919
+ AuthorizerPayloadFormatVersion: [, __expectString, `authorizerPayloadFormatVersion`],
2920
+ AuthorizerResultTtlInSeconds: [, __expectInt32, `authorizerResultTtlInSeconds`],
2921
+ AuthorizerType: [, __expectString, `authorizerType`],
2922
+ AuthorizerUri: [, __expectString, `authorizerUri`],
2923
+ EnableSimpleResponses: [, __expectBoolean, `enableSimpleResponses`],
2924
+ IdentitySource: [, _json, `identitySource`],
2925
+ IdentityValidationExpression: [, __expectString, `identityValidationExpression`],
2926
+ JwtConfiguration: [, (_) => de_JWTConfiguration(_, context), `jwtConfiguration`],
2927
+ Name: [, __expectString, `name`],
2928
+ });
2929
+ Object.assign(contents, doc);
3272
2930
  return contents;
3273
2931
  };
3274
2932
  const de_GetAuthorizerCommandError = async (output, context) => {
@@ -3286,10 +2944,9 @@ const de_GetAuthorizerCommandError = async (output, context) => {
3286
2944
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
3287
2945
  default:
3288
2946
  const parsedBody = parsedOutput.body;
3289
- throwDefaultError({
2947
+ return throwDefaultError({
3290
2948
  output,
3291
2949
  parsedBody,
3292
- exceptionCtor: __BaseException,
3293
2950
  errorCode,
3294
2951
  });
3295
2952
  }
@@ -3302,12 +2959,11 @@ export const de_GetAuthorizersCommand = async (output, context) => {
3302
2959
  $metadata: deserializeMetadata(output),
3303
2960
  });
3304
2961
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
3305
- if (data.items != null) {
3306
- contents.Items = de___listOfAuthorizer(data.items, context);
3307
- }
3308
- if (data.nextToken != null) {
3309
- contents.NextToken = __expectString(data.nextToken);
3310
- }
2962
+ const doc = take(data, {
2963
+ Items: [, (_) => de___listOfAuthorizer(_, context), `items`],
2964
+ NextToken: [, __expectString, `nextToken`],
2965
+ });
2966
+ Object.assign(contents, doc);
3311
2967
  return contents;
3312
2968
  };
3313
2969
  const de_GetAuthorizersCommandError = async (output, context) => {
@@ -3328,10 +2984,9 @@ const de_GetAuthorizersCommandError = async (output, context) => {
3328
2984
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
3329
2985
  default:
3330
2986
  const parsedBody = parsedOutput.body;
3331
- throwDefaultError({
2987
+ return throwDefaultError({
3332
2988
  output,
3333
2989
  parsedBody,
3334
- exceptionCtor: __BaseException,
3335
2990
  errorCode,
3336
2991
  });
3337
2992
  }
@@ -3344,24 +2999,15 @@ export const de_GetDeploymentCommand = async (output, context) => {
3344
2999
  $metadata: deserializeMetadata(output),
3345
3000
  });
3346
3001
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
3347
- if (data.autoDeployed != null) {
3348
- contents.AutoDeployed = __expectBoolean(data.autoDeployed);
3349
- }
3350
- if (data.createdDate != null) {
3351
- contents.CreatedDate = __expectNonNull(__parseRfc3339DateTimeWithOffset(data.createdDate));
3352
- }
3353
- if (data.deploymentId != null) {
3354
- contents.DeploymentId = __expectString(data.deploymentId);
3355
- }
3356
- if (data.deploymentStatus != null) {
3357
- contents.DeploymentStatus = __expectString(data.deploymentStatus);
3358
- }
3359
- if (data.deploymentStatusMessage != null) {
3360
- contents.DeploymentStatusMessage = __expectString(data.deploymentStatusMessage);
3361
- }
3362
- if (data.description != null) {
3363
- contents.Description = __expectString(data.description);
3364
- }
3002
+ const doc = take(data, {
3003
+ AutoDeployed: [, __expectBoolean, `autoDeployed`],
3004
+ CreatedDate: [, (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)), `createdDate`],
3005
+ DeploymentId: [, __expectString, `deploymentId`],
3006
+ DeploymentStatus: [, __expectString, `deploymentStatus`],
3007
+ DeploymentStatusMessage: [, __expectString, `deploymentStatusMessage`],
3008
+ Description: [, __expectString, `description`],
3009
+ });
3010
+ Object.assign(contents, doc);
3365
3011
  return contents;
3366
3012
  };
3367
3013
  const de_GetDeploymentCommandError = async (output, context) => {
@@ -3379,10 +3025,9 @@ const de_GetDeploymentCommandError = async (output, context) => {
3379
3025
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
3380
3026
  default:
3381
3027
  const parsedBody = parsedOutput.body;
3382
- throwDefaultError({
3028
+ return throwDefaultError({
3383
3029
  output,
3384
3030
  parsedBody,
3385
- exceptionCtor: __BaseException,
3386
3031
  errorCode,
3387
3032
  });
3388
3033
  }
@@ -3395,12 +3040,11 @@ export const de_GetDeploymentsCommand = async (output, context) => {
3395
3040
  $metadata: deserializeMetadata(output),
3396
3041
  });
3397
3042
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
3398
- if (data.items != null) {
3399
- contents.Items = de___listOfDeployment(data.items, context);
3400
- }
3401
- if (data.nextToken != null) {
3402
- contents.NextToken = __expectString(data.nextToken);
3403
- }
3043
+ const doc = take(data, {
3044
+ Items: [, (_) => de___listOfDeployment(_, context), `items`],
3045
+ NextToken: [, __expectString, `nextToken`],
3046
+ });
3047
+ Object.assign(contents, doc);
3404
3048
  return contents;
3405
3049
  };
3406
3050
  const de_GetDeploymentsCommandError = async (output, context) => {
@@ -3421,10 +3065,9 @@ const de_GetDeploymentsCommandError = async (output, context) => {
3421
3065
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
3422
3066
  default:
3423
3067
  const parsedBody = parsedOutput.body;
3424
- throwDefaultError({
3068
+ return throwDefaultError({
3425
3069
  output,
3426
3070
  parsedBody,
3427
- exceptionCtor: __BaseException,
3428
3071
  errorCode,
3429
3072
  });
3430
3073
  }
@@ -3437,21 +3080,14 @@ export const de_GetDomainNameCommand = async (output, context) => {
3437
3080
  $metadata: deserializeMetadata(output),
3438
3081
  });
3439
3082
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
3440
- if (data.apiMappingSelectionExpression != null) {
3441
- contents.ApiMappingSelectionExpression = __expectString(data.apiMappingSelectionExpression);
3442
- }
3443
- if (data.domainName != null) {
3444
- contents.DomainName = __expectString(data.domainName);
3445
- }
3446
- if (data.domainNameConfigurations != null) {
3447
- contents.DomainNameConfigurations = de_DomainNameConfigurations(data.domainNameConfigurations, context);
3448
- }
3449
- if (data.mutualTlsAuthentication != null) {
3450
- contents.MutualTlsAuthentication = de_MutualTlsAuthentication(data.mutualTlsAuthentication, context);
3451
- }
3452
- if (data.tags != null) {
3453
- contents.Tags = de_Tags(data.tags, context);
3454
- }
3083
+ const doc = take(data, {
3084
+ ApiMappingSelectionExpression: [, __expectString, `apiMappingSelectionExpression`],
3085
+ DomainName: [, __expectString, `domainName`],
3086
+ DomainNameConfigurations: [, (_) => de_DomainNameConfigurations(_, context), `domainNameConfigurations`],
3087
+ MutualTlsAuthentication: [, (_) => de_MutualTlsAuthentication(_, context), `mutualTlsAuthentication`],
3088
+ Tags: [, _json, `tags`],
3089
+ });
3090
+ Object.assign(contents, doc);
3455
3091
  return contents;
3456
3092
  };
3457
3093
  const de_GetDomainNameCommandError = async (output, context) => {
@@ -3469,10 +3105,9 @@ const de_GetDomainNameCommandError = async (output, context) => {
3469
3105
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
3470
3106
  default:
3471
3107
  const parsedBody = parsedOutput.body;
3472
- throwDefaultError({
3108
+ return throwDefaultError({
3473
3109
  output,
3474
3110
  parsedBody,
3475
- exceptionCtor: __BaseException,
3476
3111
  errorCode,
3477
3112
  });
3478
3113
  }
@@ -3485,12 +3120,11 @@ export const de_GetDomainNamesCommand = async (output, context) => {
3485
3120
  $metadata: deserializeMetadata(output),
3486
3121
  });
3487
3122
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
3488
- if (data.items != null) {
3489
- contents.Items = de___listOfDomainName(data.items, context);
3490
- }
3491
- if (data.nextToken != null) {
3492
- contents.NextToken = __expectString(data.nextToken);
3493
- }
3123
+ const doc = take(data, {
3124
+ Items: [, (_) => de___listOfDomainName(_, context), `items`],
3125
+ NextToken: [, __expectString, `nextToken`],
3126
+ });
3127
+ Object.assign(contents, doc);
3494
3128
  return contents;
3495
3129
  };
3496
3130
  const de_GetDomainNamesCommandError = async (output, context) => {
@@ -3511,10 +3145,9 @@ const de_GetDomainNamesCommandError = async (output, context) => {
3511
3145
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
3512
3146
  default:
3513
3147
  const parsedBody = parsedOutput.body;
3514
- throwDefaultError({
3148
+ return throwDefaultError({
3515
3149
  output,
3516
3150
  parsedBody,
3517
- exceptionCtor: __BaseException,
3518
3151
  errorCode,
3519
3152
  });
3520
3153
  }
@@ -3527,66 +3160,29 @@ export const de_GetIntegrationCommand = async (output, context) => {
3527
3160
  $metadata: deserializeMetadata(output),
3528
3161
  });
3529
3162
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
3530
- if (data.apiGatewayManaged != null) {
3531
- contents.ApiGatewayManaged = __expectBoolean(data.apiGatewayManaged);
3532
- }
3533
- if (data.connectionId != null) {
3534
- contents.ConnectionId = __expectString(data.connectionId);
3535
- }
3536
- if (data.connectionType != null) {
3537
- contents.ConnectionType = __expectString(data.connectionType);
3538
- }
3539
- if (data.contentHandlingStrategy != null) {
3540
- contents.ContentHandlingStrategy = __expectString(data.contentHandlingStrategy);
3541
- }
3542
- if (data.credentialsArn != null) {
3543
- contents.CredentialsArn = __expectString(data.credentialsArn);
3544
- }
3545
- if (data.description != null) {
3546
- contents.Description = __expectString(data.description);
3547
- }
3548
- if (data.integrationId != null) {
3549
- contents.IntegrationId = __expectString(data.integrationId);
3550
- }
3551
- if (data.integrationMethod != null) {
3552
- contents.IntegrationMethod = __expectString(data.integrationMethod);
3553
- }
3554
- if (data.integrationResponseSelectionExpression != null) {
3555
- contents.IntegrationResponseSelectionExpression = __expectString(data.integrationResponseSelectionExpression);
3556
- }
3557
- if (data.integrationSubtype != null) {
3558
- contents.IntegrationSubtype = __expectString(data.integrationSubtype);
3559
- }
3560
- if (data.integrationType != null) {
3561
- contents.IntegrationType = __expectString(data.integrationType);
3562
- }
3563
- if (data.integrationUri != null) {
3564
- contents.IntegrationUri = __expectString(data.integrationUri);
3565
- }
3566
- if (data.passthroughBehavior != null) {
3567
- contents.PassthroughBehavior = __expectString(data.passthroughBehavior);
3568
- }
3569
- if (data.payloadFormatVersion != null) {
3570
- contents.PayloadFormatVersion = __expectString(data.payloadFormatVersion);
3571
- }
3572
- if (data.requestParameters != null) {
3573
- contents.RequestParameters = de_IntegrationParameters(data.requestParameters, context);
3574
- }
3575
- if (data.requestTemplates != null) {
3576
- contents.RequestTemplates = de_TemplateMap(data.requestTemplates, context);
3577
- }
3578
- if (data.responseParameters != null) {
3579
- contents.ResponseParameters = de_ResponseParameters(data.responseParameters, context);
3580
- }
3581
- if (data.templateSelectionExpression != null) {
3582
- contents.TemplateSelectionExpression = __expectString(data.templateSelectionExpression);
3583
- }
3584
- if (data.timeoutInMillis != null) {
3585
- contents.TimeoutInMillis = __expectInt32(data.timeoutInMillis);
3586
- }
3587
- if (data.tlsConfig != null) {
3588
- contents.TlsConfig = de_TlsConfig(data.tlsConfig, context);
3589
- }
3163
+ const doc = take(data, {
3164
+ ApiGatewayManaged: [, __expectBoolean, `apiGatewayManaged`],
3165
+ ConnectionId: [, __expectString, `connectionId`],
3166
+ ConnectionType: [, __expectString, `connectionType`],
3167
+ ContentHandlingStrategy: [, __expectString, `contentHandlingStrategy`],
3168
+ CredentialsArn: [, __expectString, `credentialsArn`],
3169
+ Description: [, __expectString, `description`],
3170
+ IntegrationId: [, __expectString, `integrationId`],
3171
+ IntegrationMethod: [, __expectString, `integrationMethod`],
3172
+ IntegrationResponseSelectionExpression: [, __expectString, `integrationResponseSelectionExpression`],
3173
+ IntegrationSubtype: [, __expectString, `integrationSubtype`],
3174
+ IntegrationType: [, __expectString, `integrationType`],
3175
+ IntegrationUri: [, __expectString, `integrationUri`],
3176
+ PassthroughBehavior: [, __expectString, `passthroughBehavior`],
3177
+ PayloadFormatVersion: [, __expectString, `payloadFormatVersion`],
3178
+ RequestParameters: [, _json, `requestParameters`],
3179
+ RequestTemplates: [, _json, `requestTemplates`],
3180
+ ResponseParameters: [, _json, `responseParameters`],
3181
+ TemplateSelectionExpression: [, __expectString, `templateSelectionExpression`],
3182
+ TimeoutInMillis: [, __expectInt32, `timeoutInMillis`],
3183
+ TlsConfig: [, (_) => de_TlsConfig(_, context), `tlsConfig`],
3184
+ });
3185
+ Object.assign(contents, doc);
3590
3186
  return contents;
3591
3187
  };
3592
3188
  const de_GetIntegrationCommandError = async (output, context) => {
@@ -3604,10 +3200,9 @@ const de_GetIntegrationCommandError = async (output, context) => {
3604
3200
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
3605
3201
  default:
3606
3202
  const parsedBody = parsedOutput.body;
3607
- throwDefaultError({
3203
+ return throwDefaultError({
3608
3204
  output,
3609
3205
  parsedBody,
3610
- exceptionCtor: __BaseException,
3611
3206
  errorCode,
3612
3207
  });
3613
3208
  }
@@ -3620,24 +3215,15 @@ export const de_GetIntegrationResponseCommand = async (output, context) => {
3620
3215
  $metadata: deserializeMetadata(output),
3621
3216
  });
3622
3217
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
3623
- if (data.contentHandlingStrategy != null) {
3624
- contents.ContentHandlingStrategy = __expectString(data.contentHandlingStrategy);
3625
- }
3626
- if (data.integrationResponseId != null) {
3627
- contents.IntegrationResponseId = __expectString(data.integrationResponseId);
3628
- }
3629
- if (data.integrationResponseKey != null) {
3630
- contents.IntegrationResponseKey = __expectString(data.integrationResponseKey);
3631
- }
3632
- if (data.responseParameters != null) {
3633
- contents.ResponseParameters = de_IntegrationParameters(data.responseParameters, context);
3634
- }
3635
- if (data.responseTemplates != null) {
3636
- contents.ResponseTemplates = de_TemplateMap(data.responseTemplates, context);
3637
- }
3638
- if (data.templateSelectionExpression != null) {
3639
- contents.TemplateSelectionExpression = __expectString(data.templateSelectionExpression);
3640
- }
3218
+ const doc = take(data, {
3219
+ ContentHandlingStrategy: [, __expectString, `contentHandlingStrategy`],
3220
+ IntegrationResponseId: [, __expectString, `integrationResponseId`],
3221
+ IntegrationResponseKey: [, __expectString, `integrationResponseKey`],
3222
+ ResponseParameters: [, _json, `responseParameters`],
3223
+ ResponseTemplates: [, _json, `responseTemplates`],
3224
+ TemplateSelectionExpression: [, __expectString, `templateSelectionExpression`],
3225
+ });
3226
+ Object.assign(contents, doc);
3641
3227
  return contents;
3642
3228
  };
3643
3229
  const de_GetIntegrationResponseCommandError = async (output, context) => {
@@ -3655,10 +3241,9 @@ const de_GetIntegrationResponseCommandError = async (output, context) => {
3655
3241
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
3656
3242
  default:
3657
3243
  const parsedBody = parsedOutput.body;
3658
- throwDefaultError({
3244
+ return throwDefaultError({
3659
3245
  output,
3660
3246
  parsedBody,
3661
- exceptionCtor: __BaseException,
3662
3247
  errorCode,
3663
3248
  });
3664
3249
  }
@@ -3671,12 +3256,11 @@ export const de_GetIntegrationResponsesCommand = async (output, context) => {
3671
3256
  $metadata: deserializeMetadata(output),
3672
3257
  });
3673
3258
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
3674
- if (data.items != null) {
3675
- contents.Items = de___listOfIntegrationResponse(data.items, context);
3676
- }
3677
- if (data.nextToken != null) {
3678
- contents.NextToken = __expectString(data.nextToken);
3679
- }
3259
+ const doc = take(data, {
3260
+ Items: [, (_) => de___listOfIntegrationResponse(_, context), `items`],
3261
+ NextToken: [, __expectString, `nextToken`],
3262
+ });
3263
+ Object.assign(contents, doc);
3680
3264
  return contents;
3681
3265
  };
3682
3266
  const de_GetIntegrationResponsesCommandError = async (output, context) => {
@@ -3697,10 +3281,9 @@ const de_GetIntegrationResponsesCommandError = async (output, context) => {
3697
3281
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
3698
3282
  default:
3699
3283
  const parsedBody = parsedOutput.body;
3700
- throwDefaultError({
3284
+ return throwDefaultError({
3701
3285
  output,
3702
3286
  parsedBody,
3703
- exceptionCtor: __BaseException,
3704
3287
  errorCode,
3705
3288
  });
3706
3289
  }
@@ -3713,12 +3296,11 @@ export const de_GetIntegrationsCommand = async (output, context) => {
3713
3296
  $metadata: deserializeMetadata(output),
3714
3297
  });
3715
3298
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
3716
- if (data.items != null) {
3717
- contents.Items = de___listOfIntegration(data.items, context);
3718
- }
3719
- if (data.nextToken != null) {
3720
- contents.NextToken = __expectString(data.nextToken);
3721
- }
3299
+ const doc = take(data, {
3300
+ Items: [, (_) => de___listOfIntegration(_, context), `items`],
3301
+ NextToken: [, __expectString, `nextToken`],
3302
+ });
3303
+ Object.assign(contents, doc);
3722
3304
  return contents;
3723
3305
  };
3724
3306
  const de_GetIntegrationsCommandError = async (output, context) => {
@@ -3739,10 +3321,9 @@ const de_GetIntegrationsCommandError = async (output, context) => {
3739
3321
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
3740
3322
  default:
3741
3323
  const parsedBody = parsedOutput.body;
3742
- throwDefaultError({
3324
+ return throwDefaultError({
3743
3325
  output,
3744
3326
  parsedBody,
3745
- exceptionCtor: __BaseException,
3746
3327
  errorCode,
3747
3328
  });
3748
3329
  }
@@ -3755,21 +3336,14 @@ export const de_GetModelCommand = async (output, context) => {
3755
3336
  $metadata: deserializeMetadata(output),
3756
3337
  });
3757
3338
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
3758
- if (data.contentType != null) {
3759
- contents.ContentType = __expectString(data.contentType);
3760
- }
3761
- if (data.description != null) {
3762
- contents.Description = __expectString(data.description);
3763
- }
3764
- if (data.modelId != null) {
3765
- contents.ModelId = __expectString(data.modelId);
3766
- }
3767
- if (data.name != null) {
3768
- contents.Name = __expectString(data.name);
3769
- }
3770
- if (data.schema != null) {
3771
- contents.Schema = __expectString(data.schema);
3772
- }
3339
+ const doc = take(data, {
3340
+ ContentType: [, __expectString, `contentType`],
3341
+ Description: [, __expectString, `description`],
3342
+ ModelId: [, __expectString, `modelId`],
3343
+ Name: [, __expectString, `name`],
3344
+ Schema: [, __expectString, `schema`],
3345
+ });
3346
+ Object.assign(contents, doc);
3773
3347
  return contents;
3774
3348
  };
3775
3349
  const de_GetModelCommandError = async (output, context) => {
@@ -3787,10 +3361,9 @@ const de_GetModelCommandError = async (output, context) => {
3787
3361
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
3788
3362
  default:
3789
3363
  const parsedBody = parsedOutput.body;
3790
- throwDefaultError({
3364
+ return throwDefaultError({
3791
3365
  output,
3792
3366
  parsedBody,
3793
- exceptionCtor: __BaseException,
3794
3367
  errorCode,
3795
3368
  });
3796
3369
  }
@@ -3803,12 +3376,11 @@ export const de_GetModelsCommand = async (output, context) => {
3803
3376
  $metadata: deserializeMetadata(output),
3804
3377
  });
3805
3378
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
3806
- if (data.items != null) {
3807
- contents.Items = de___listOfModel(data.items, context);
3808
- }
3809
- if (data.nextToken != null) {
3810
- contents.NextToken = __expectString(data.nextToken);
3811
- }
3379
+ const doc = take(data, {
3380
+ Items: [, (_) => de___listOfModel(_, context), `items`],
3381
+ NextToken: [, __expectString, `nextToken`],
3382
+ });
3383
+ Object.assign(contents, doc);
3812
3384
  return contents;
3813
3385
  };
3814
3386
  const de_GetModelsCommandError = async (output, context) => {
@@ -3829,10 +3401,9 @@ const de_GetModelsCommandError = async (output, context) => {
3829
3401
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
3830
3402
  default:
3831
3403
  const parsedBody = parsedOutput.body;
3832
- throwDefaultError({
3404
+ return throwDefaultError({
3833
3405
  output,
3834
3406
  parsedBody,
3835
- exceptionCtor: __BaseException,
3836
3407
  errorCode,
3837
3408
  });
3838
3409
  }
@@ -3845,9 +3416,10 @@ export const de_GetModelTemplateCommand = async (output, context) => {
3845
3416
  $metadata: deserializeMetadata(output),
3846
3417
  });
3847
3418
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
3848
- if (data.value != null) {
3849
- contents.Value = __expectString(data.value);
3850
- }
3419
+ const doc = take(data, {
3420
+ Value: [, __expectString, `value`],
3421
+ });
3422
+ Object.assign(contents, doc);
3851
3423
  return contents;
3852
3424
  };
3853
3425
  const de_GetModelTemplateCommandError = async (output, context) => {
@@ -3865,10 +3437,9 @@ const de_GetModelTemplateCommandError = async (output, context) => {
3865
3437
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
3866
3438
  default:
3867
3439
  const parsedBody = parsedOutput.body;
3868
- throwDefaultError({
3440
+ return throwDefaultError({
3869
3441
  output,
3870
3442
  parsedBody,
3871
- exceptionCtor: __BaseException,
3872
3443
  errorCode,
3873
3444
  });
3874
3445
  }
@@ -3881,45 +3452,22 @@ export const de_GetRouteCommand = async (output, context) => {
3881
3452
  $metadata: deserializeMetadata(output),
3882
3453
  });
3883
3454
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
3884
- if (data.apiGatewayManaged != null) {
3885
- contents.ApiGatewayManaged = __expectBoolean(data.apiGatewayManaged);
3886
- }
3887
- if (data.apiKeyRequired != null) {
3888
- contents.ApiKeyRequired = __expectBoolean(data.apiKeyRequired);
3889
- }
3890
- if (data.authorizationScopes != null) {
3891
- contents.AuthorizationScopes = de_AuthorizationScopes(data.authorizationScopes, context);
3892
- }
3893
- if (data.authorizationType != null) {
3894
- contents.AuthorizationType = __expectString(data.authorizationType);
3895
- }
3896
- if (data.authorizerId != null) {
3897
- contents.AuthorizerId = __expectString(data.authorizerId);
3898
- }
3899
- if (data.modelSelectionExpression != null) {
3900
- contents.ModelSelectionExpression = __expectString(data.modelSelectionExpression);
3901
- }
3902
- if (data.operationName != null) {
3903
- contents.OperationName = __expectString(data.operationName);
3904
- }
3905
- if (data.requestModels != null) {
3906
- contents.RequestModels = de_RouteModels(data.requestModels, context);
3907
- }
3908
- if (data.requestParameters != null) {
3909
- contents.RequestParameters = de_RouteParameters(data.requestParameters, context);
3910
- }
3911
- if (data.routeId != null) {
3912
- contents.RouteId = __expectString(data.routeId);
3913
- }
3914
- if (data.routeKey != null) {
3915
- contents.RouteKey = __expectString(data.routeKey);
3916
- }
3917
- if (data.routeResponseSelectionExpression != null) {
3918
- contents.RouteResponseSelectionExpression = __expectString(data.routeResponseSelectionExpression);
3919
- }
3920
- if (data.target != null) {
3921
- contents.Target = __expectString(data.target);
3922
- }
3455
+ const doc = take(data, {
3456
+ ApiGatewayManaged: [, __expectBoolean, `apiGatewayManaged`],
3457
+ ApiKeyRequired: [, __expectBoolean, `apiKeyRequired`],
3458
+ AuthorizationScopes: [, _json, `authorizationScopes`],
3459
+ AuthorizationType: [, __expectString, `authorizationType`],
3460
+ AuthorizerId: [, __expectString, `authorizerId`],
3461
+ ModelSelectionExpression: [, __expectString, `modelSelectionExpression`],
3462
+ OperationName: [, __expectString, `operationName`],
3463
+ RequestModels: [, _json, `requestModels`],
3464
+ RequestParameters: [, (_) => de_RouteParameters(_, context), `requestParameters`],
3465
+ RouteId: [, __expectString, `routeId`],
3466
+ RouteKey: [, __expectString, `routeKey`],
3467
+ RouteResponseSelectionExpression: [, __expectString, `routeResponseSelectionExpression`],
3468
+ Target: [, __expectString, `target`],
3469
+ });
3470
+ Object.assign(contents, doc);
3923
3471
  return contents;
3924
3472
  };
3925
3473
  const de_GetRouteCommandError = async (output, context) => {
@@ -3937,10 +3485,9 @@ const de_GetRouteCommandError = async (output, context) => {
3937
3485
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
3938
3486
  default:
3939
3487
  const parsedBody = parsedOutput.body;
3940
- throwDefaultError({
3488
+ return throwDefaultError({
3941
3489
  output,
3942
3490
  parsedBody,
3943
- exceptionCtor: __BaseException,
3944
3491
  errorCode,
3945
3492
  });
3946
3493
  }
@@ -3953,21 +3500,14 @@ export const de_GetRouteResponseCommand = async (output, context) => {
3953
3500
  $metadata: deserializeMetadata(output),
3954
3501
  });
3955
3502
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
3956
- if (data.modelSelectionExpression != null) {
3957
- contents.ModelSelectionExpression = __expectString(data.modelSelectionExpression);
3958
- }
3959
- if (data.responseModels != null) {
3960
- contents.ResponseModels = de_RouteModels(data.responseModels, context);
3961
- }
3962
- if (data.responseParameters != null) {
3963
- contents.ResponseParameters = de_RouteParameters(data.responseParameters, context);
3964
- }
3965
- if (data.routeResponseId != null) {
3966
- contents.RouteResponseId = __expectString(data.routeResponseId);
3967
- }
3968
- if (data.routeResponseKey != null) {
3969
- contents.RouteResponseKey = __expectString(data.routeResponseKey);
3970
- }
3503
+ const doc = take(data, {
3504
+ ModelSelectionExpression: [, __expectString, `modelSelectionExpression`],
3505
+ ResponseModels: [, _json, `responseModels`],
3506
+ ResponseParameters: [, (_) => de_RouteParameters(_, context), `responseParameters`],
3507
+ RouteResponseId: [, __expectString, `routeResponseId`],
3508
+ RouteResponseKey: [, __expectString, `routeResponseKey`],
3509
+ });
3510
+ Object.assign(contents, doc);
3971
3511
  return contents;
3972
3512
  };
3973
3513
  const de_GetRouteResponseCommandError = async (output, context) => {
@@ -3985,10 +3525,9 @@ const de_GetRouteResponseCommandError = async (output, context) => {
3985
3525
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
3986
3526
  default:
3987
3527
  const parsedBody = parsedOutput.body;
3988
- throwDefaultError({
3528
+ return throwDefaultError({
3989
3529
  output,
3990
3530
  parsedBody,
3991
- exceptionCtor: __BaseException,
3992
3531
  errorCode,
3993
3532
  });
3994
3533
  }
@@ -4001,12 +3540,11 @@ export const de_GetRouteResponsesCommand = async (output, context) => {
4001
3540
  $metadata: deserializeMetadata(output),
4002
3541
  });
4003
3542
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
4004
- if (data.items != null) {
4005
- contents.Items = de___listOfRouteResponse(data.items, context);
4006
- }
4007
- if (data.nextToken != null) {
4008
- contents.NextToken = __expectString(data.nextToken);
4009
- }
3543
+ const doc = take(data, {
3544
+ Items: [, (_) => de___listOfRouteResponse(_, context), `items`],
3545
+ NextToken: [, __expectString, `nextToken`],
3546
+ });
3547
+ Object.assign(contents, doc);
4010
3548
  return contents;
4011
3549
  };
4012
3550
  const de_GetRouteResponsesCommandError = async (output, context) => {
@@ -4027,10 +3565,9 @@ const de_GetRouteResponsesCommandError = async (output, context) => {
4027
3565
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
4028
3566
  default:
4029
3567
  const parsedBody = parsedOutput.body;
4030
- throwDefaultError({
3568
+ return throwDefaultError({
4031
3569
  output,
4032
3570
  parsedBody,
4033
- exceptionCtor: __BaseException,
4034
3571
  errorCode,
4035
3572
  });
4036
3573
  }
@@ -4043,12 +3580,11 @@ export const de_GetRoutesCommand = async (output, context) => {
4043
3580
  $metadata: deserializeMetadata(output),
4044
3581
  });
4045
3582
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
4046
- if (data.items != null) {
4047
- contents.Items = de___listOfRoute(data.items, context);
4048
- }
4049
- if (data.nextToken != null) {
4050
- contents.NextToken = __expectString(data.nextToken);
4051
- }
3583
+ const doc = take(data, {
3584
+ Items: [, (_) => de___listOfRoute(_, context), `items`],
3585
+ NextToken: [, __expectString, `nextToken`],
3586
+ });
3587
+ Object.assign(contents, doc);
4052
3588
  return contents;
4053
3589
  };
4054
3590
  const de_GetRoutesCommandError = async (output, context) => {
@@ -4069,10 +3605,9 @@ const de_GetRoutesCommandError = async (output, context) => {
4069
3605
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
4070
3606
  default:
4071
3607
  const parsedBody = parsedOutput.body;
4072
- throwDefaultError({
3608
+ return throwDefaultError({
4073
3609
  output,
4074
3610
  parsedBody,
4075
- exceptionCtor: __BaseException,
4076
3611
  errorCode,
4077
3612
  });
4078
3613
  }
@@ -4085,48 +3620,23 @@ export const de_GetStageCommand = async (output, context) => {
4085
3620
  $metadata: deserializeMetadata(output),
4086
3621
  });
4087
3622
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
4088
- if (data.accessLogSettings != null) {
4089
- contents.AccessLogSettings = de_AccessLogSettings(data.accessLogSettings, context);
4090
- }
4091
- if (data.apiGatewayManaged != null) {
4092
- contents.ApiGatewayManaged = __expectBoolean(data.apiGatewayManaged);
4093
- }
4094
- if (data.autoDeploy != null) {
4095
- contents.AutoDeploy = __expectBoolean(data.autoDeploy);
4096
- }
4097
- if (data.clientCertificateId != null) {
4098
- contents.ClientCertificateId = __expectString(data.clientCertificateId);
4099
- }
4100
- if (data.createdDate != null) {
4101
- contents.CreatedDate = __expectNonNull(__parseRfc3339DateTimeWithOffset(data.createdDate));
4102
- }
4103
- if (data.defaultRouteSettings != null) {
4104
- contents.DefaultRouteSettings = de_RouteSettings(data.defaultRouteSettings, context);
4105
- }
4106
- if (data.deploymentId != null) {
4107
- contents.DeploymentId = __expectString(data.deploymentId);
4108
- }
4109
- if (data.description != null) {
4110
- contents.Description = __expectString(data.description);
4111
- }
4112
- if (data.lastDeploymentStatusMessage != null) {
4113
- contents.LastDeploymentStatusMessage = __expectString(data.lastDeploymentStatusMessage);
4114
- }
4115
- if (data.lastUpdatedDate != null) {
4116
- contents.LastUpdatedDate = __expectNonNull(__parseRfc3339DateTimeWithOffset(data.lastUpdatedDate));
4117
- }
4118
- if (data.routeSettings != null) {
4119
- contents.RouteSettings = de_RouteSettingsMap(data.routeSettings, context);
4120
- }
4121
- if (data.stageName != null) {
4122
- contents.StageName = __expectString(data.stageName);
4123
- }
4124
- if (data.stageVariables != null) {
4125
- contents.StageVariables = de_StageVariablesMap(data.stageVariables, context);
4126
- }
4127
- if (data.tags != null) {
4128
- contents.Tags = de_Tags(data.tags, context);
4129
- }
3623
+ const doc = take(data, {
3624
+ AccessLogSettings: [, (_) => de_AccessLogSettings(_, context), `accessLogSettings`],
3625
+ ApiGatewayManaged: [, __expectBoolean, `apiGatewayManaged`],
3626
+ AutoDeploy: [, __expectBoolean, `autoDeploy`],
3627
+ ClientCertificateId: [, __expectString, `clientCertificateId`],
3628
+ CreatedDate: [, (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)), `createdDate`],
3629
+ DefaultRouteSettings: [, (_) => de_RouteSettings(_, context), `defaultRouteSettings`],
3630
+ DeploymentId: [, __expectString, `deploymentId`],
3631
+ Description: [, __expectString, `description`],
3632
+ LastDeploymentStatusMessage: [, __expectString, `lastDeploymentStatusMessage`],
3633
+ LastUpdatedDate: [, (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)), `lastUpdatedDate`],
3634
+ RouteSettings: [, (_) => de_RouteSettingsMap(_, context), `routeSettings`],
3635
+ StageName: [, __expectString, `stageName`],
3636
+ StageVariables: [, _json, `stageVariables`],
3637
+ Tags: [, _json, `tags`],
3638
+ });
3639
+ Object.assign(contents, doc);
4130
3640
  return contents;
4131
3641
  };
4132
3642
  const de_GetStageCommandError = async (output, context) => {
@@ -4144,10 +3654,9 @@ const de_GetStageCommandError = async (output, context) => {
4144
3654
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
4145
3655
  default:
4146
3656
  const parsedBody = parsedOutput.body;
4147
- throwDefaultError({
3657
+ return throwDefaultError({
4148
3658
  output,
4149
3659
  parsedBody,
4150
- exceptionCtor: __BaseException,
4151
3660
  errorCode,
4152
3661
  });
4153
3662
  }
@@ -4160,12 +3669,11 @@ export const de_GetStagesCommand = async (output, context) => {
4160
3669
  $metadata: deserializeMetadata(output),
4161
3670
  });
4162
3671
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
4163
- if (data.items != null) {
4164
- contents.Items = de___listOfStage(data.items, context);
4165
- }
4166
- if (data.nextToken != null) {
4167
- contents.NextToken = __expectString(data.nextToken);
4168
- }
3672
+ const doc = take(data, {
3673
+ Items: [, (_) => de___listOfStage(_, context), `items`],
3674
+ NextToken: [, __expectString, `nextToken`],
3675
+ });
3676
+ Object.assign(contents, doc);
4169
3677
  return contents;
4170
3678
  };
4171
3679
  const de_GetStagesCommandError = async (output, context) => {
@@ -4186,10 +3694,9 @@ const de_GetStagesCommandError = async (output, context) => {
4186
3694
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
4187
3695
  default:
4188
3696
  const parsedBody = parsedOutput.body;
4189
- throwDefaultError({
3697
+ return throwDefaultError({
4190
3698
  output,
4191
3699
  parsedBody,
4192
- exceptionCtor: __BaseException,
4193
3700
  errorCode,
4194
3701
  });
4195
3702
  }
@@ -4202,9 +3709,10 @@ export const de_GetTagsCommand = async (output, context) => {
4202
3709
  $metadata: deserializeMetadata(output),
4203
3710
  });
4204
3711
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
4205
- if (data.tags != null) {
4206
- contents.Tags = de_Tags(data.tags, context);
4207
- }
3712
+ const doc = take(data, {
3713
+ Tags: [, _json, `tags`],
3714
+ });
3715
+ Object.assign(contents, doc);
4208
3716
  return contents;
4209
3717
  };
4210
3718
  const de_GetTagsCommandError = async (output, context) => {
@@ -4228,10 +3736,9 @@ const de_GetTagsCommandError = async (output, context) => {
4228
3736
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
4229
3737
  default:
4230
3738
  const parsedBody = parsedOutput.body;
4231
- throwDefaultError({
3739
+ return throwDefaultError({
4232
3740
  output,
4233
3741
  parsedBody,
4234
- exceptionCtor: __BaseException,
4235
3742
  errorCode,
4236
3743
  });
4237
3744
  }
@@ -4244,33 +3751,18 @@ export const de_GetVpcLinkCommand = async (output, context) => {
4244
3751
  $metadata: deserializeMetadata(output),
4245
3752
  });
4246
3753
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
4247
- if (data.createdDate != null) {
4248
- contents.CreatedDate = __expectNonNull(__parseRfc3339DateTimeWithOffset(data.createdDate));
4249
- }
4250
- if (data.name != null) {
4251
- contents.Name = __expectString(data.name);
4252
- }
4253
- if (data.securityGroupIds != null) {
4254
- contents.SecurityGroupIds = de_SecurityGroupIdList(data.securityGroupIds, context);
4255
- }
4256
- if (data.subnetIds != null) {
4257
- contents.SubnetIds = de_SubnetIdList(data.subnetIds, context);
4258
- }
4259
- if (data.tags != null) {
4260
- contents.Tags = de_Tags(data.tags, context);
4261
- }
4262
- if (data.vpcLinkId != null) {
4263
- contents.VpcLinkId = __expectString(data.vpcLinkId);
4264
- }
4265
- if (data.vpcLinkStatus != null) {
4266
- contents.VpcLinkStatus = __expectString(data.vpcLinkStatus);
4267
- }
4268
- if (data.vpcLinkStatusMessage != null) {
4269
- contents.VpcLinkStatusMessage = __expectString(data.vpcLinkStatusMessage);
4270
- }
4271
- if (data.vpcLinkVersion != null) {
4272
- contents.VpcLinkVersion = __expectString(data.vpcLinkVersion);
4273
- }
3754
+ const doc = take(data, {
3755
+ CreatedDate: [, (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)), `createdDate`],
3756
+ Name: [, __expectString, `name`],
3757
+ SecurityGroupIds: [, _json, `securityGroupIds`],
3758
+ SubnetIds: [, _json, `subnetIds`],
3759
+ Tags: [, _json, `tags`],
3760
+ VpcLinkId: [, __expectString, `vpcLinkId`],
3761
+ VpcLinkStatus: [, __expectString, `vpcLinkStatus`],
3762
+ VpcLinkStatusMessage: [, __expectString, `vpcLinkStatusMessage`],
3763
+ VpcLinkVersion: [, __expectString, `vpcLinkVersion`],
3764
+ });
3765
+ Object.assign(contents, doc);
4274
3766
  return contents;
4275
3767
  };
4276
3768
  const de_GetVpcLinkCommandError = async (output, context) => {
@@ -4288,10 +3780,9 @@ const de_GetVpcLinkCommandError = async (output, context) => {
4288
3780
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
4289
3781
  default:
4290
3782
  const parsedBody = parsedOutput.body;
4291
- throwDefaultError({
3783
+ return throwDefaultError({
4292
3784
  output,
4293
3785
  parsedBody,
4294
- exceptionCtor: __BaseException,
4295
3786
  errorCode,
4296
3787
  });
4297
3788
  }
@@ -4304,12 +3795,11 @@ export const de_GetVpcLinksCommand = async (output, context) => {
4304
3795
  $metadata: deserializeMetadata(output),
4305
3796
  });
4306
3797
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
4307
- if (data.items != null) {
4308
- contents.Items = de___listOfVpcLink(data.items, context);
4309
- }
4310
- if (data.nextToken != null) {
4311
- contents.NextToken = __expectString(data.nextToken);
4312
- }
3798
+ const doc = take(data, {
3799
+ Items: [, (_) => de___listOfVpcLink(_, context), `items`],
3800
+ NextToken: [, __expectString, `nextToken`],
3801
+ });
3802
+ Object.assign(contents, doc);
4313
3803
  return contents;
4314
3804
  };
4315
3805
  const de_GetVpcLinksCommandError = async (output, context) => {
@@ -4327,10 +3817,9 @@ const de_GetVpcLinksCommandError = async (output, context) => {
4327
3817
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
4328
3818
  default:
4329
3819
  const parsedBody = parsedOutput.body;
4330
- throwDefaultError({
3820
+ return throwDefaultError({
4331
3821
  output,
4332
3822
  parsedBody,
4333
- exceptionCtor: __BaseException,
4334
3823
  errorCode,
4335
3824
  });
4336
3825
  }
@@ -4343,54 +3832,25 @@ export const de_ImportApiCommand = async (output, context) => {
4343
3832
  $metadata: deserializeMetadata(output),
4344
3833
  });
4345
3834
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
4346
- if (data.apiEndpoint != null) {
4347
- contents.ApiEndpoint = __expectString(data.apiEndpoint);
4348
- }
4349
- if (data.apiGatewayManaged != null) {
4350
- contents.ApiGatewayManaged = __expectBoolean(data.apiGatewayManaged);
4351
- }
4352
- if (data.apiId != null) {
4353
- contents.ApiId = __expectString(data.apiId);
4354
- }
4355
- if (data.apiKeySelectionExpression != null) {
4356
- contents.ApiKeySelectionExpression = __expectString(data.apiKeySelectionExpression);
4357
- }
4358
- if (data.corsConfiguration != null) {
4359
- contents.CorsConfiguration = de_Cors(data.corsConfiguration, context);
4360
- }
4361
- if (data.createdDate != null) {
4362
- contents.CreatedDate = __expectNonNull(__parseRfc3339DateTimeWithOffset(data.createdDate));
4363
- }
4364
- if (data.description != null) {
4365
- contents.Description = __expectString(data.description);
4366
- }
4367
- if (data.disableExecuteApiEndpoint != null) {
4368
- contents.DisableExecuteApiEndpoint = __expectBoolean(data.disableExecuteApiEndpoint);
4369
- }
4370
- if (data.disableSchemaValidation != null) {
4371
- contents.DisableSchemaValidation = __expectBoolean(data.disableSchemaValidation);
4372
- }
4373
- if (data.importInfo != null) {
4374
- contents.ImportInfo = de___listOf__string(data.importInfo, context);
4375
- }
4376
- if (data.name != null) {
4377
- contents.Name = __expectString(data.name);
4378
- }
4379
- if (data.protocolType != null) {
4380
- contents.ProtocolType = __expectString(data.protocolType);
4381
- }
4382
- if (data.routeSelectionExpression != null) {
4383
- contents.RouteSelectionExpression = __expectString(data.routeSelectionExpression);
4384
- }
4385
- if (data.tags != null) {
4386
- contents.Tags = de_Tags(data.tags, context);
4387
- }
4388
- if (data.version != null) {
4389
- contents.Version = __expectString(data.version);
4390
- }
4391
- if (data.warnings != null) {
4392
- contents.Warnings = de___listOf__string(data.warnings, context);
4393
- }
3835
+ const doc = take(data, {
3836
+ ApiEndpoint: [, __expectString, `apiEndpoint`],
3837
+ ApiGatewayManaged: [, __expectBoolean, `apiGatewayManaged`],
3838
+ ApiId: [, __expectString, `apiId`],
3839
+ ApiKeySelectionExpression: [, __expectString, `apiKeySelectionExpression`],
3840
+ CorsConfiguration: [, (_) => de_Cors(_, context), `corsConfiguration`],
3841
+ CreatedDate: [, (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)), `createdDate`],
3842
+ Description: [, __expectString, `description`],
3843
+ DisableExecuteApiEndpoint: [, __expectBoolean, `disableExecuteApiEndpoint`],
3844
+ DisableSchemaValidation: [, __expectBoolean, `disableSchemaValidation`],
3845
+ ImportInfo: [, _json, `importInfo`],
3846
+ Name: [, __expectString, `name`],
3847
+ ProtocolType: [, __expectString, `protocolType`],
3848
+ RouteSelectionExpression: [, __expectString, `routeSelectionExpression`],
3849
+ Tags: [, _json, `tags`],
3850
+ Version: [, __expectString, `version`],
3851
+ Warnings: [, _json, `warnings`],
3852
+ });
3853
+ Object.assign(contents, doc);
4394
3854
  return contents;
4395
3855
  };
4396
3856
  const de_ImportApiCommandError = async (output, context) => {
@@ -4414,10 +3874,9 @@ const de_ImportApiCommandError = async (output, context) => {
4414
3874
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
4415
3875
  default:
4416
3876
  const parsedBody = parsedOutput.body;
4417
- throwDefaultError({
3877
+ return throwDefaultError({
4418
3878
  output,
4419
3879
  parsedBody,
4420
- exceptionCtor: __BaseException,
4421
3880
  errorCode,
4422
3881
  });
4423
3882
  }
@@ -4430,54 +3889,25 @@ export const de_ReimportApiCommand = async (output, context) => {
4430
3889
  $metadata: deserializeMetadata(output),
4431
3890
  });
4432
3891
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
4433
- if (data.apiEndpoint != null) {
4434
- contents.ApiEndpoint = __expectString(data.apiEndpoint);
4435
- }
4436
- if (data.apiGatewayManaged != null) {
4437
- contents.ApiGatewayManaged = __expectBoolean(data.apiGatewayManaged);
4438
- }
4439
- if (data.apiId != null) {
4440
- contents.ApiId = __expectString(data.apiId);
4441
- }
4442
- if (data.apiKeySelectionExpression != null) {
4443
- contents.ApiKeySelectionExpression = __expectString(data.apiKeySelectionExpression);
4444
- }
4445
- if (data.corsConfiguration != null) {
4446
- contents.CorsConfiguration = de_Cors(data.corsConfiguration, context);
4447
- }
4448
- if (data.createdDate != null) {
4449
- contents.CreatedDate = __expectNonNull(__parseRfc3339DateTimeWithOffset(data.createdDate));
4450
- }
4451
- if (data.description != null) {
4452
- contents.Description = __expectString(data.description);
4453
- }
4454
- if (data.disableExecuteApiEndpoint != null) {
4455
- contents.DisableExecuteApiEndpoint = __expectBoolean(data.disableExecuteApiEndpoint);
4456
- }
4457
- if (data.disableSchemaValidation != null) {
4458
- contents.DisableSchemaValidation = __expectBoolean(data.disableSchemaValidation);
4459
- }
4460
- if (data.importInfo != null) {
4461
- contents.ImportInfo = de___listOf__string(data.importInfo, context);
4462
- }
4463
- if (data.name != null) {
4464
- contents.Name = __expectString(data.name);
4465
- }
4466
- if (data.protocolType != null) {
4467
- contents.ProtocolType = __expectString(data.protocolType);
4468
- }
4469
- if (data.routeSelectionExpression != null) {
4470
- contents.RouteSelectionExpression = __expectString(data.routeSelectionExpression);
4471
- }
4472
- if (data.tags != null) {
4473
- contents.Tags = de_Tags(data.tags, context);
4474
- }
4475
- if (data.version != null) {
4476
- contents.Version = __expectString(data.version);
4477
- }
4478
- if (data.warnings != null) {
4479
- contents.Warnings = de___listOf__string(data.warnings, context);
4480
- }
3892
+ const doc = take(data, {
3893
+ ApiEndpoint: [, __expectString, `apiEndpoint`],
3894
+ ApiGatewayManaged: [, __expectBoolean, `apiGatewayManaged`],
3895
+ ApiId: [, __expectString, `apiId`],
3896
+ ApiKeySelectionExpression: [, __expectString, `apiKeySelectionExpression`],
3897
+ CorsConfiguration: [, (_) => de_Cors(_, context), `corsConfiguration`],
3898
+ CreatedDate: [, (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)), `createdDate`],
3899
+ Description: [, __expectString, `description`],
3900
+ DisableExecuteApiEndpoint: [, __expectBoolean, `disableExecuteApiEndpoint`],
3901
+ DisableSchemaValidation: [, __expectBoolean, `disableSchemaValidation`],
3902
+ ImportInfo: [, _json, `importInfo`],
3903
+ Name: [, __expectString, `name`],
3904
+ ProtocolType: [, __expectString, `protocolType`],
3905
+ RouteSelectionExpression: [, __expectString, `routeSelectionExpression`],
3906
+ Tags: [, _json, `tags`],
3907
+ Version: [, __expectString, `version`],
3908
+ Warnings: [, _json, `warnings`],
3909
+ });
3910
+ Object.assign(contents, doc);
4481
3911
  return contents;
4482
3912
  };
4483
3913
  const de_ReimportApiCommandError = async (output, context) => {
@@ -4501,10 +3931,9 @@ const de_ReimportApiCommandError = async (output, context) => {
4501
3931
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
4502
3932
  default:
4503
3933
  const parsedBody = parsedOutput.body;
4504
- throwDefaultError({
3934
+ return throwDefaultError({
4505
3935
  output,
4506
3936
  parsedBody,
4507
- exceptionCtor: __BaseException,
4508
3937
  errorCode,
4509
3938
  });
4510
3939
  }
@@ -4534,10 +3963,9 @@ const de_ResetAuthorizersCacheCommandError = async (output, context) => {
4534
3963
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
4535
3964
  default:
4536
3965
  const parsedBody = parsedOutput.body;
4537
- throwDefaultError({
3966
+ return throwDefaultError({
4538
3967
  output,
4539
3968
  parsedBody,
4540
- exceptionCtor: __BaseException,
4541
3969
  errorCode,
4542
3970
  });
4543
3971
  }
@@ -4573,10 +4001,9 @@ const de_TagResourceCommandError = async (output, context) => {
4573
4001
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
4574
4002
  default:
4575
4003
  const parsedBody = parsedOutput.body;
4576
- throwDefaultError({
4004
+ return throwDefaultError({
4577
4005
  output,
4578
4006
  parsedBody,
4579
- exceptionCtor: __BaseException,
4580
4007
  errorCode,
4581
4008
  });
4582
4009
  }
@@ -4612,10 +4039,9 @@ const de_UntagResourceCommandError = async (output, context) => {
4612
4039
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
4613
4040
  default:
4614
4041
  const parsedBody = parsedOutput.body;
4615
- throwDefaultError({
4042
+ return throwDefaultError({
4616
4043
  output,
4617
4044
  parsedBody,
4618
- exceptionCtor: __BaseException,
4619
4045
  errorCode,
4620
4046
  });
4621
4047
  }
@@ -4628,54 +4054,25 @@ export const de_UpdateApiCommand = async (output, context) => {
4628
4054
  $metadata: deserializeMetadata(output),
4629
4055
  });
4630
4056
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
4631
- if (data.apiEndpoint != null) {
4632
- contents.ApiEndpoint = __expectString(data.apiEndpoint);
4633
- }
4634
- if (data.apiGatewayManaged != null) {
4635
- contents.ApiGatewayManaged = __expectBoolean(data.apiGatewayManaged);
4636
- }
4637
- if (data.apiId != null) {
4638
- contents.ApiId = __expectString(data.apiId);
4639
- }
4640
- if (data.apiKeySelectionExpression != null) {
4641
- contents.ApiKeySelectionExpression = __expectString(data.apiKeySelectionExpression);
4642
- }
4643
- if (data.corsConfiguration != null) {
4644
- contents.CorsConfiguration = de_Cors(data.corsConfiguration, context);
4645
- }
4646
- if (data.createdDate != null) {
4647
- contents.CreatedDate = __expectNonNull(__parseRfc3339DateTimeWithOffset(data.createdDate));
4648
- }
4649
- if (data.description != null) {
4650
- contents.Description = __expectString(data.description);
4651
- }
4652
- if (data.disableExecuteApiEndpoint != null) {
4653
- contents.DisableExecuteApiEndpoint = __expectBoolean(data.disableExecuteApiEndpoint);
4654
- }
4655
- if (data.disableSchemaValidation != null) {
4656
- contents.DisableSchemaValidation = __expectBoolean(data.disableSchemaValidation);
4657
- }
4658
- if (data.importInfo != null) {
4659
- contents.ImportInfo = de___listOf__string(data.importInfo, context);
4660
- }
4661
- if (data.name != null) {
4662
- contents.Name = __expectString(data.name);
4663
- }
4664
- if (data.protocolType != null) {
4665
- contents.ProtocolType = __expectString(data.protocolType);
4666
- }
4667
- if (data.routeSelectionExpression != null) {
4668
- contents.RouteSelectionExpression = __expectString(data.routeSelectionExpression);
4669
- }
4670
- if (data.tags != null) {
4671
- contents.Tags = de_Tags(data.tags, context);
4672
- }
4673
- if (data.version != null) {
4674
- contents.Version = __expectString(data.version);
4675
- }
4676
- if (data.warnings != null) {
4677
- contents.Warnings = de___listOf__string(data.warnings, context);
4678
- }
4057
+ const doc = take(data, {
4058
+ ApiEndpoint: [, __expectString, `apiEndpoint`],
4059
+ ApiGatewayManaged: [, __expectBoolean, `apiGatewayManaged`],
4060
+ ApiId: [, __expectString, `apiId`],
4061
+ ApiKeySelectionExpression: [, __expectString, `apiKeySelectionExpression`],
4062
+ CorsConfiguration: [, (_) => de_Cors(_, context), `corsConfiguration`],
4063
+ CreatedDate: [, (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)), `createdDate`],
4064
+ Description: [, __expectString, `description`],
4065
+ DisableExecuteApiEndpoint: [, __expectBoolean, `disableExecuteApiEndpoint`],
4066
+ DisableSchemaValidation: [, __expectBoolean, `disableSchemaValidation`],
4067
+ ImportInfo: [, _json, `importInfo`],
4068
+ Name: [, __expectString, `name`],
4069
+ ProtocolType: [, __expectString, `protocolType`],
4070
+ RouteSelectionExpression: [, __expectString, `routeSelectionExpression`],
4071
+ Tags: [, _json, `tags`],
4072
+ Version: [, __expectString, `version`],
4073
+ Warnings: [, _json, `warnings`],
4074
+ });
4075
+ Object.assign(contents, doc);
4679
4076
  return contents;
4680
4077
  };
4681
4078
  const de_UpdateApiCommandError = async (output, context) => {
@@ -4699,10 +4096,9 @@ const de_UpdateApiCommandError = async (output, context) => {
4699
4096
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
4700
4097
  default:
4701
4098
  const parsedBody = parsedOutput.body;
4702
- throwDefaultError({
4099
+ return throwDefaultError({
4703
4100
  output,
4704
4101
  parsedBody,
4705
- exceptionCtor: __BaseException,
4706
4102
  errorCode,
4707
4103
  });
4708
4104
  }
@@ -4715,18 +4111,13 @@ export const de_UpdateApiMappingCommand = async (output, context) => {
4715
4111
  $metadata: deserializeMetadata(output),
4716
4112
  });
4717
4113
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
4718
- if (data.apiId != null) {
4719
- contents.ApiId = __expectString(data.apiId);
4720
- }
4721
- if (data.apiMappingId != null) {
4722
- contents.ApiMappingId = __expectString(data.apiMappingId);
4723
- }
4724
- if (data.apiMappingKey != null) {
4725
- contents.ApiMappingKey = __expectString(data.apiMappingKey);
4726
- }
4727
- if (data.stage != null) {
4728
- contents.Stage = __expectString(data.stage);
4729
- }
4114
+ const doc = take(data, {
4115
+ ApiId: [, __expectString, `apiId`],
4116
+ ApiMappingId: [, __expectString, `apiMappingId`],
4117
+ ApiMappingKey: [, __expectString, `apiMappingKey`],
4118
+ Stage: [, __expectString, `stage`],
4119
+ });
4120
+ Object.assign(contents, doc);
4730
4121
  return contents;
4731
4122
  };
4732
4123
  const de_UpdateApiMappingCommandError = async (output, context) => {
@@ -4750,10 +4141,9 @@ const de_UpdateApiMappingCommandError = async (output, context) => {
4750
4141
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
4751
4142
  default:
4752
4143
  const parsedBody = parsedOutput.body;
4753
- throwDefaultError({
4144
+ return throwDefaultError({
4754
4145
  output,
4755
4146
  parsedBody,
4756
- exceptionCtor: __BaseException,
4757
4147
  errorCode,
4758
4148
  });
4759
4149
  }
@@ -4766,39 +4156,20 @@ export const de_UpdateAuthorizerCommand = async (output, context) => {
4766
4156
  $metadata: deserializeMetadata(output),
4767
4157
  });
4768
4158
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
4769
- if (data.authorizerCredentialsArn != null) {
4770
- contents.AuthorizerCredentialsArn = __expectString(data.authorizerCredentialsArn);
4771
- }
4772
- if (data.authorizerId != null) {
4773
- contents.AuthorizerId = __expectString(data.authorizerId);
4774
- }
4775
- if (data.authorizerPayloadFormatVersion != null) {
4776
- contents.AuthorizerPayloadFormatVersion = __expectString(data.authorizerPayloadFormatVersion);
4777
- }
4778
- if (data.authorizerResultTtlInSeconds != null) {
4779
- contents.AuthorizerResultTtlInSeconds = __expectInt32(data.authorizerResultTtlInSeconds);
4780
- }
4781
- if (data.authorizerType != null) {
4782
- contents.AuthorizerType = __expectString(data.authorizerType);
4783
- }
4784
- if (data.authorizerUri != null) {
4785
- contents.AuthorizerUri = __expectString(data.authorizerUri);
4786
- }
4787
- if (data.enableSimpleResponses != null) {
4788
- contents.EnableSimpleResponses = __expectBoolean(data.enableSimpleResponses);
4789
- }
4790
- if (data.identitySource != null) {
4791
- contents.IdentitySource = de_IdentitySourceList(data.identitySource, context);
4792
- }
4793
- if (data.identityValidationExpression != null) {
4794
- contents.IdentityValidationExpression = __expectString(data.identityValidationExpression);
4795
- }
4796
- if (data.jwtConfiguration != null) {
4797
- contents.JwtConfiguration = de_JWTConfiguration(data.jwtConfiguration, context);
4798
- }
4799
- if (data.name != null) {
4800
- contents.Name = __expectString(data.name);
4801
- }
4159
+ const doc = take(data, {
4160
+ AuthorizerCredentialsArn: [, __expectString, `authorizerCredentialsArn`],
4161
+ AuthorizerId: [, __expectString, `authorizerId`],
4162
+ AuthorizerPayloadFormatVersion: [, __expectString, `authorizerPayloadFormatVersion`],
4163
+ AuthorizerResultTtlInSeconds: [, __expectInt32, `authorizerResultTtlInSeconds`],
4164
+ AuthorizerType: [, __expectString, `authorizerType`],
4165
+ AuthorizerUri: [, __expectString, `authorizerUri`],
4166
+ EnableSimpleResponses: [, __expectBoolean, `enableSimpleResponses`],
4167
+ IdentitySource: [, _json, `identitySource`],
4168
+ IdentityValidationExpression: [, __expectString, `identityValidationExpression`],
4169
+ JwtConfiguration: [, (_) => de_JWTConfiguration(_, context), `jwtConfiguration`],
4170
+ Name: [, __expectString, `name`],
4171
+ });
4172
+ Object.assign(contents, doc);
4802
4173
  return contents;
4803
4174
  };
4804
4175
  const de_UpdateAuthorizerCommandError = async (output, context) => {
@@ -4822,10 +4193,9 @@ const de_UpdateAuthorizerCommandError = async (output, context) => {
4822
4193
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
4823
4194
  default:
4824
4195
  const parsedBody = parsedOutput.body;
4825
- throwDefaultError({
4196
+ return throwDefaultError({
4826
4197
  output,
4827
4198
  parsedBody,
4828
- exceptionCtor: __BaseException,
4829
4199
  errorCode,
4830
4200
  });
4831
4201
  }
@@ -4838,24 +4208,15 @@ export const de_UpdateDeploymentCommand = async (output, context) => {
4838
4208
  $metadata: deserializeMetadata(output),
4839
4209
  });
4840
4210
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
4841
- if (data.autoDeployed != null) {
4842
- contents.AutoDeployed = __expectBoolean(data.autoDeployed);
4843
- }
4844
- if (data.createdDate != null) {
4845
- contents.CreatedDate = __expectNonNull(__parseRfc3339DateTimeWithOffset(data.createdDate));
4846
- }
4847
- if (data.deploymentId != null) {
4848
- contents.DeploymentId = __expectString(data.deploymentId);
4849
- }
4850
- if (data.deploymentStatus != null) {
4851
- contents.DeploymentStatus = __expectString(data.deploymentStatus);
4852
- }
4853
- if (data.deploymentStatusMessage != null) {
4854
- contents.DeploymentStatusMessage = __expectString(data.deploymentStatusMessage);
4855
- }
4856
- if (data.description != null) {
4857
- contents.Description = __expectString(data.description);
4858
- }
4211
+ const doc = take(data, {
4212
+ AutoDeployed: [, __expectBoolean, `autoDeployed`],
4213
+ CreatedDate: [, (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)), `createdDate`],
4214
+ DeploymentId: [, __expectString, `deploymentId`],
4215
+ DeploymentStatus: [, __expectString, `deploymentStatus`],
4216
+ DeploymentStatusMessage: [, __expectString, `deploymentStatusMessage`],
4217
+ Description: [, __expectString, `description`],
4218
+ });
4219
+ Object.assign(contents, doc);
4859
4220
  return contents;
4860
4221
  };
4861
4222
  const de_UpdateDeploymentCommandError = async (output, context) => {
@@ -4879,10 +4240,9 @@ const de_UpdateDeploymentCommandError = async (output, context) => {
4879
4240
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
4880
4241
  default:
4881
4242
  const parsedBody = parsedOutput.body;
4882
- throwDefaultError({
4243
+ return throwDefaultError({
4883
4244
  output,
4884
4245
  parsedBody,
4885
- exceptionCtor: __BaseException,
4886
4246
  errorCode,
4887
4247
  });
4888
4248
  }
@@ -4895,21 +4255,14 @@ export const de_UpdateDomainNameCommand = async (output, context) => {
4895
4255
  $metadata: deserializeMetadata(output),
4896
4256
  });
4897
4257
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
4898
- if (data.apiMappingSelectionExpression != null) {
4899
- contents.ApiMappingSelectionExpression = __expectString(data.apiMappingSelectionExpression);
4900
- }
4901
- if (data.domainName != null) {
4902
- contents.DomainName = __expectString(data.domainName);
4903
- }
4904
- if (data.domainNameConfigurations != null) {
4905
- contents.DomainNameConfigurations = de_DomainNameConfigurations(data.domainNameConfigurations, context);
4906
- }
4907
- if (data.mutualTlsAuthentication != null) {
4908
- contents.MutualTlsAuthentication = de_MutualTlsAuthentication(data.mutualTlsAuthentication, context);
4909
- }
4910
- if (data.tags != null) {
4911
- contents.Tags = de_Tags(data.tags, context);
4912
- }
4258
+ const doc = take(data, {
4259
+ ApiMappingSelectionExpression: [, __expectString, `apiMappingSelectionExpression`],
4260
+ DomainName: [, __expectString, `domainName`],
4261
+ DomainNameConfigurations: [, (_) => de_DomainNameConfigurations(_, context), `domainNameConfigurations`],
4262
+ MutualTlsAuthentication: [, (_) => de_MutualTlsAuthentication(_, context), `mutualTlsAuthentication`],
4263
+ Tags: [, _json, `tags`],
4264
+ });
4265
+ Object.assign(contents, doc);
4913
4266
  return contents;
4914
4267
  };
4915
4268
  const de_UpdateDomainNameCommandError = async (output, context) => {
@@ -4933,10 +4286,9 @@ const de_UpdateDomainNameCommandError = async (output, context) => {
4933
4286
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
4934
4287
  default:
4935
4288
  const parsedBody = parsedOutput.body;
4936
- throwDefaultError({
4289
+ return throwDefaultError({
4937
4290
  output,
4938
4291
  parsedBody,
4939
- exceptionCtor: __BaseException,
4940
4292
  errorCode,
4941
4293
  });
4942
4294
  }
@@ -4949,66 +4301,29 @@ export const de_UpdateIntegrationCommand = async (output, context) => {
4949
4301
  $metadata: deserializeMetadata(output),
4950
4302
  });
4951
4303
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
4952
- if (data.apiGatewayManaged != null) {
4953
- contents.ApiGatewayManaged = __expectBoolean(data.apiGatewayManaged);
4954
- }
4955
- if (data.connectionId != null) {
4956
- contents.ConnectionId = __expectString(data.connectionId);
4957
- }
4958
- if (data.connectionType != null) {
4959
- contents.ConnectionType = __expectString(data.connectionType);
4960
- }
4961
- if (data.contentHandlingStrategy != null) {
4962
- contents.ContentHandlingStrategy = __expectString(data.contentHandlingStrategy);
4963
- }
4964
- if (data.credentialsArn != null) {
4965
- contents.CredentialsArn = __expectString(data.credentialsArn);
4966
- }
4967
- if (data.description != null) {
4968
- contents.Description = __expectString(data.description);
4969
- }
4970
- if (data.integrationId != null) {
4971
- contents.IntegrationId = __expectString(data.integrationId);
4972
- }
4973
- if (data.integrationMethod != null) {
4974
- contents.IntegrationMethod = __expectString(data.integrationMethod);
4975
- }
4976
- if (data.integrationResponseSelectionExpression != null) {
4977
- contents.IntegrationResponseSelectionExpression = __expectString(data.integrationResponseSelectionExpression);
4978
- }
4979
- if (data.integrationSubtype != null) {
4980
- contents.IntegrationSubtype = __expectString(data.integrationSubtype);
4981
- }
4982
- if (data.integrationType != null) {
4983
- contents.IntegrationType = __expectString(data.integrationType);
4984
- }
4985
- if (data.integrationUri != null) {
4986
- contents.IntegrationUri = __expectString(data.integrationUri);
4987
- }
4988
- if (data.passthroughBehavior != null) {
4989
- contents.PassthroughBehavior = __expectString(data.passthroughBehavior);
4990
- }
4991
- if (data.payloadFormatVersion != null) {
4992
- contents.PayloadFormatVersion = __expectString(data.payloadFormatVersion);
4993
- }
4994
- if (data.requestParameters != null) {
4995
- contents.RequestParameters = de_IntegrationParameters(data.requestParameters, context);
4996
- }
4997
- if (data.requestTemplates != null) {
4998
- contents.RequestTemplates = de_TemplateMap(data.requestTemplates, context);
4999
- }
5000
- if (data.responseParameters != null) {
5001
- contents.ResponseParameters = de_ResponseParameters(data.responseParameters, context);
5002
- }
5003
- if (data.templateSelectionExpression != null) {
5004
- contents.TemplateSelectionExpression = __expectString(data.templateSelectionExpression);
5005
- }
5006
- if (data.timeoutInMillis != null) {
5007
- contents.TimeoutInMillis = __expectInt32(data.timeoutInMillis);
5008
- }
5009
- if (data.tlsConfig != null) {
5010
- contents.TlsConfig = de_TlsConfig(data.tlsConfig, context);
5011
- }
4304
+ const doc = take(data, {
4305
+ ApiGatewayManaged: [, __expectBoolean, `apiGatewayManaged`],
4306
+ ConnectionId: [, __expectString, `connectionId`],
4307
+ ConnectionType: [, __expectString, `connectionType`],
4308
+ ContentHandlingStrategy: [, __expectString, `contentHandlingStrategy`],
4309
+ CredentialsArn: [, __expectString, `credentialsArn`],
4310
+ Description: [, __expectString, `description`],
4311
+ IntegrationId: [, __expectString, `integrationId`],
4312
+ IntegrationMethod: [, __expectString, `integrationMethod`],
4313
+ IntegrationResponseSelectionExpression: [, __expectString, `integrationResponseSelectionExpression`],
4314
+ IntegrationSubtype: [, __expectString, `integrationSubtype`],
4315
+ IntegrationType: [, __expectString, `integrationType`],
4316
+ IntegrationUri: [, __expectString, `integrationUri`],
4317
+ PassthroughBehavior: [, __expectString, `passthroughBehavior`],
4318
+ PayloadFormatVersion: [, __expectString, `payloadFormatVersion`],
4319
+ RequestParameters: [, _json, `requestParameters`],
4320
+ RequestTemplates: [, _json, `requestTemplates`],
4321
+ ResponseParameters: [, _json, `responseParameters`],
4322
+ TemplateSelectionExpression: [, __expectString, `templateSelectionExpression`],
4323
+ TimeoutInMillis: [, __expectInt32, `timeoutInMillis`],
4324
+ TlsConfig: [, (_) => de_TlsConfig(_, context), `tlsConfig`],
4325
+ });
4326
+ Object.assign(contents, doc);
5012
4327
  return contents;
5013
4328
  };
5014
4329
  const de_UpdateIntegrationCommandError = async (output, context) => {
@@ -5032,10 +4347,9 @@ const de_UpdateIntegrationCommandError = async (output, context) => {
5032
4347
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
5033
4348
  default:
5034
4349
  const parsedBody = parsedOutput.body;
5035
- throwDefaultError({
4350
+ return throwDefaultError({
5036
4351
  output,
5037
4352
  parsedBody,
5038
- exceptionCtor: __BaseException,
5039
4353
  errorCode,
5040
4354
  });
5041
4355
  }
@@ -5048,24 +4362,15 @@ export const de_UpdateIntegrationResponseCommand = async (output, context) => {
5048
4362
  $metadata: deserializeMetadata(output),
5049
4363
  });
5050
4364
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
5051
- if (data.contentHandlingStrategy != null) {
5052
- contents.ContentHandlingStrategy = __expectString(data.contentHandlingStrategy);
5053
- }
5054
- if (data.integrationResponseId != null) {
5055
- contents.IntegrationResponseId = __expectString(data.integrationResponseId);
5056
- }
5057
- if (data.integrationResponseKey != null) {
5058
- contents.IntegrationResponseKey = __expectString(data.integrationResponseKey);
5059
- }
5060
- if (data.responseParameters != null) {
5061
- contents.ResponseParameters = de_IntegrationParameters(data.responseParameters, context);
5062
- }
5063
- if (data.responseTemplates != null) {
5064
- contents.ResponseTemplates = de_TemplateMap(data.responseTemplates, context);
5065
- }
5066
- if (data.templateSelectionExpression != null) {
5067
- contents.TemplateSelectionExpression = __expectString(data.templateSelectionExpression);
5068
- }
4365
+ const doc = take(data, {
4366
+ ContentHandlingStrategy: [, __expectString, `contentHandlingStrategy`],
4367
+ IntegrationResponseId: [, __expectString, `integrationResponseId`],
4368
+ IntegrationResponseKey: [, __expectString, `integrationResponseKey`],
4369
+ ResponseParameters: [, _json, `responseParameters`],
4370
+ ResponseTemplates: [, _json, `responseTemplates`],
4371
+ TemplateSelectionExpression: [, __expectString, `templateSelectionExpression`],
4372
+ });
4373
+ Object.assign(contents, doc);
5069
4374
  return contents;
5070
4375
  };
5071
4376
  const de_UpdateIntegrationResponseCommandError = async (output, context) => {
@@ -5089,10 +4394,9 @@ const de_UpdateIntegrationResponseCommandError = async (output, context) => {
5089
4394
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
5090
4395
  default:
5091
4396
  const parsedBody = parsedOutput.body;
5092
- throwDefaultError({
4397
+ return throwDefaultError({
5093
4398
  output,
5094
4399
  parsedBody,
5095
- exceptionCtor: __BaseException,
5096
4400
  errorCode,
5097
4401
  });
5098
4402
  }
@@ -5105,21 +4409,14 @@ export const de_UpdateModelCommand = async (output, context) => {
5105
4409
  $metadata: deserializeMetadata(output),
5106
4410
  });
5107
4411
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
5108
- if (data.contentType != null) {
5109
- contents.ContentType = __expectString(data.contentType);
5110
- }
5111
- if (data.description != null) {
5112
- contents.Description = __expectString(data.description);
5113
- }
5114
- if (data.modelId != null) {
5115
- contents.ModelId = __expectString(data.modelId);
5116
- }
5117
- if (data.name != null) {
5118
- contents.Name = __expectString(data.name);
5119
- }
5120
- if (data.schema != null) {
5121
- contents.Schema = __expectString(data.schema);
5122
- }
4412
+ const doc = take(data, {
4413
+ ContentType: [, __expectString, `contentType`],
4414
+ Description: [, __expectString, `description`],
4415
+ ModelId: [, __expectString, `modelId`],
4416
+ Name: [, __expectString, `name`],
4417
+ Schema: [, __expectString, `schema`],
4418
+ });
4419
+ Object.assign(contents, doc);
5123
4420
  return contents;
5124
4421
  };
5125
4422
  const de_UpdateModelCommandError = async (output, context) => {
@@ -5143,10 +4440,9 @@ const de_UpdateModelCommandError = async (output, context) => {
5143
4440
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
5144
4441
  default:
5145
4442
  const parsedBody = parsedOutput.body;
5146
- throwDefaultError({
4443
+ return throwDefaultError({
5147
4444
  output,
5148
4445
  parsedBody,
5149
- exceptionCtor: __BaseException,
5150
4446
  errorCode,
5151
4447
  });
5152
4448
  }
@@ -5159,45 +4455,22 @@ export const de_UpdateRouteCommand = async (output, context) => {
5159
4455
  $metadata: deserializeMetadata(output),
5160
4456
  });
5161
4457
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
5162
- if (data.apiGatewayManaged != null) {
5163
- contents.ApiGatewayManaged = __expectBoolean(data.apiGatewayManaged);
5164
- }
5165
- if (data.apiKeyRequired != null) {
5166
- contents.ApiKeyRequired = __expectBoolean(data.apiKeyRequired);
5167
- }
5168
- if (data.authorizationScopes != null) {
5169
- contents.AuthorizationScopes = de_AuthorizationScopes(data.authorizationScopes, context);
5170
- }
5171
- if (data.authorizationType != null) {
5172
- contents.AuthorizationType = __expectString(data.authorizationType);
5173
- }
5174
- if (data.authorizerId != null) {
5175
- contents.AuthorizerId = __expectString(data.authorizerId);
5176
- }
5177
- if (data.modelSelectionExpression != null) {
5178
- contents.ModelSelectionExpression = __expectString(data.modelSelectionExpression);
5179
- }
5180
- if (data.operationName != null) {
5181
- contents.OperationName = __expectString(data.operationName);
5182
- }
5183
- if (data.requestModels != null) {
5184
- contents.RequestModels = de_RouteModels(data.requestModels, context);
5185
- }
5186
- if (data.requestParameters != null) {
5187
- contents.RequestParameters = de_RouteParameters(data.requestParameters, context);
5188
- }
5189
- if (data.routeId != null) {
5190
- contents.RouteId = __expectString(data.routeId);
5191
- }
5192
- if (data.routeKey != null) {
5193
- contents.RouteKey = __expectString(data.routeKey);
5194
- }
5195
- if (data.routeResponseSelectionExpression != null) {
5196
- contents.RouteResponseSelectionExpression = __expectString(data.routeResponseSelectionExpression);
5197
- }
5198
- if (data.target != null) {
5199
- contents.Target = __expectString(data.target);
5200
- }
4458
+ const doc = take(data, {
4459
+ ApiGatewayManaged: [, __expectBoolean, `apiGatewayManaged`],
4460
+ ApiKeyRequired: [, __expectBoolean, `apiKeyRequired`],
4461
+ AuthorizationScopes: [, _json, `authorizationScopes`],
4462
+ AuthorizationType: [, __expectString, `authorizationType`],
4463
+ AuthorizerId: [, __expectString, `authorizerId`],
4464
+ ModelSelectionExpression: [, __expectString, `modelSelectionExpression`],
4465
+ OperationName: [, __expectString, `operationName`],
4466
+ RequestModels: [, _json, `requestModels`],
4467
+ RequestParameters: [, (_) => de_RouteParameters(_, context), `requestParameters`],
4468
+ RouteId: [, __expectString, `routeId`],
4469
+ RouteKey: [, __expectString, `routeKey`],
4470
+ RouteResponseSelectionExpression: [, __expectString, `routeResponseSelectionExpression`],
4471
+ Target: [, __expectString, `target`],
4472
+ });
4473
+ Object.assign(contents, doc);
5201
4474
  return contents;
5202
4475
  };
5203
4476
  const de_UpdateRouteCommandError = async (output, context) => {
@@ -5221,10 +4494,9 @@ const de_UpdateRouteCommandError = async (output, context) => {
5221
4494
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
5222
4495
  default:
5223
4496
  const parsedBody = parsedOutput.body;
5224
- throwDefaultError({
4497
+ return throwDefaultError({
5225
4498
  output,
5226
4499
  parsedBody,
5227
- exceptionCtor: __BaseException,
5228
4500
  errorCode,
5229
4501
  });
5230
4502
  }
@@ -5237,21 +4509,14 @@ export const de_UpdateRouteResponseCommand = async (output, context) => {
5237
4509
  $metadata: deserializeMetadata(output),
5238
4510
  });
5239
4511
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
5240
- if (data.modelSelectionExpression != null) {
5241
- contents.ModelSelectionExpression = __expectString(data.modelSelectionExpression);
5242
- }
5243
- if (data.responseModels != null) {
5244
- contents.ResponseModels = de_RouteModels(data.responseModels, context);
5245
- }
5246
- if (data.responseParameters != null) {
5247
- contents.ResponseParameters = de_RouteParameters(data.responseParameters, context);
5248
- }
5249
- if (data.routeResponseId != null) {
5250
- contents.RouteResponseId = __expectString(data.routeResponseId);
5251
- }
5252
- if (data.routeResponseKey != null) {
5253
- contents.RouteResponseKey = __expectString(data.routeResponseKey);
5254
- }
4512
+ const doc = take(data, {
4513
+ ModelSelectionExpression: [, __expectString, `modelSelectionExpression`],
4514
+ ResponseModels: [, _json, `responseModels`],
4515
+ ResponseParameters: [, (_) => de_RouteParameters(_, context), `responseParameters`],
4516
+ RouteResponseId: [, __expectString, `routeResponseId`],
4517
+ RouteResponseKey: [, __expectString, `routeResponseKey`],
4518
+ });
4519
+ Object.assign(contents, doc);
5255
4520
  return contents;
5256
4521
  };
5257
4522
  const de_UpdateRouteResponseCommandError = async (output, context) => {
@@ -5275,10 +4540,9 @@ const de_UpdateRouteResponseCommandError = async (output, context) => {
5275
4540
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
5276
4541
  default:
5277
4542
  const parsedBody = parsedOutput.body;
5278
- throwDefaultError({
4543
+ return throwDefaultError({
5279
4544
  output,
5280
4545
  parsedBody,
5281
- exceptionCtor: __BaseException,
5282
4546
  errorCode,
5283
4547
  });
5284
4548
  }
@@ -5291,48 +4555,23 @@ export const de_UpdateStageCommand = async (output, context) => {
5291
4555
  $metadata: deserializeMetadata(output),
5292
4556
  });
5293
4557
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
5294
- if (data.accessLogSettings != null) {
5295
- contents.AccessLogSettings = de_AccessLogSettings(data.accessLogSettings, context);
5296
- }
5297
- if (data.apiGatewayManaged != null) {
5298
- contents.ApiGatewayManaged = __expectBoolean(data.apiGatewayManaged);
5299
- }
5300
- if (data.autoDeploy != null) {
5301
- contents.AutoDeploy = __expectBoolean(data.autoDeploy);
5302
- }
5303
- if (data.clientCertificateId != null) {
5304
- contents.ClientCertificateId = __expectString(data.clientCertificateId);
5305
- }
5306
- if (data.createdDate != null) {
5307
- contents.CreatedDate = __expectNonNull(__parseRfc3339DateTimeWithOffset(data.createdDate));
5308
- }
5309
- if (data.defaultRouteSettings != null) {
5310
- contents.DefaultRouteSettings = de_RouteSettings(data.defaultRouteSettings, context);
5311
- }
5312
- if (data.deploymentId != null) {
5313
- contents.DeploymentId = __expectString(data.deploymentId);
5314
- }
5315
- if (data.description != null) {
5316
- contents.Description = __expectString(data.description);
5317
- }
5318
- if (data.lastDeploymentStatusMessage != null) {
5319
- contents.LastDeploymentStatusMessage = __expectString(data.lastDeploymentStatusMessage);
5320
- }
5321
- if (data.lastUpdatedDate != null) {
5322
- contents.LastUpdatedDate = __expectNonNull(__parseRfc3339DateTimeWithOffset(data.lastUpdatedDate));
5323
- }
5324
- if (data.routeSettings != null) {
5325
- contents.RouteSettings = de_RouteSettingsMap(data.routeSettings, context);
5326
- }
5327
- if (data.stageName != null) {
5328
- contents.StageName = __expectString(data.stageName);
5329
- }
5330
- if (data.stageVariables != null) {
5331
- contents.StageVariables = de_StageVariablesMap(data.stageVariables, context);
5332
- }
5333
- if (data.tags != null) {
5334
- contents.Tags = de_Tags(data.tags, context);
5335
- }
4558
+ const doc = take(data, {
4559
+ AccessLogSettings: [, (_) => de_AccessLogSettings(_, context), `accessLogSettings`],
4560
+ ApiGatewayManaged: [, __expectBoolean, `apiGatewayManaged`],
4561
+ AutoDeploy: [, __expectBoolean, `autoDeploy`],
4562
+ ClientCertificateId: [, __expectString, `clientCertificateId`],
4563
+ CreatedDate: [, (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)), `createdDate`],
4564
+ DefaultRouteSettings: [, (_) => de_RouteSettings(_, context), `defaultRouteSettings`],
4565
+ DeploymentId: [, __expectString, `deploymentId`],
4566
+ Description: [, __expectString, `description`],
4567
+ LastDeploymentStatusMessage: [, __expectString, `lastDeploymentStatusMessage`],
4568
+ LastUpdatedDate: [, (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)), `lastUpdatedDate`],
4569
+ RouteSettings: [, (_) => de_RouteSettingsMap(_, context), `routeSettings`],
4570
+ StageName: [, __expectString, `stageName`],
4571
+ StageVariables: [, _json, `stageVariables`],
4572
+ Tags: [, _json, `tags`],
4573
+ });
4574
+ Object.assign(contents, doc);
5336
4575
  return contents;
5337
4576
  };
5338
4577
  const de_UpdateStageCommandError = async (output, context) => {
@@ -5356,10 +4595,9 @@ const de_UpdateStageCommandError = async (output, context) => {
5356
4595
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
5357
4596
  default:
5358
4597
  const parsedBody = parsedOutput.body;
5359
- throwDefaultError({
4598
+ return throwDefaultError({
5360
4599
  output,
5361
4600
  parsedBody,
5362
- exceptionCtor: __BaseException,
5363
4601
  errorCode,
5364
4602
  });
5365
4603
  }
@@ -5372,33 +4610,18 @@ export const de_UpdateVpcLinkCommand = async (output, context) => {
5372
4610
  $metadata: deserializeMetadata(output),
5373
4611
  });
5374
4612
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
5375
- if (data.createdDate != null) {
5376
- contents.CreatedDate = __expectNonNull(__parseRfc3339DateTimeWithOffset(data.createdDate));
5377
- }
5378
- if (data.name != null) {
5379
- contents.Name = __expectString(data.name);
5380
- }
5381
- if (data.securityGroupIds != null) {
5382
- contents.SecurityGroupIds = de_SecurityGroupIdList(data.securityGroupIds, context);
5383
- }
5384
- if (data.subnetIds != null) {
5385
- contents.SubnetIds = de_SubnetIdList(data.subnetIds, context);
5386
- }
5387
- if (data.tags != null) {
5388
- contents.Tags = de_Tags(data.tags, context);
5389
- }
5390
- if (data.vpcLinkId != null) {
5391
- contents.VpcLinkId = __expectString(data.vpcLinkId);
5392
- }
5393
- if (data.vpcLinkStatus != null) {
5394
- contents.VpcLinkStatus = __expectString(data.vpcLinkStatus);
5395
- }
5396
- if (data.vpcLinkStatusMessage != null) {
5397
- contents.VpcLinkStatusMessage = __expectString(data.vpcLinkStatusMessage);
5398
- }
5399
- if (data.vpcLinkVersion != null) {
5400
- contents.VpcLinkVersion = __expectString(data.vpcLinkVersion);
5401
- }
4613
+ const doc = take(data, {
4614
+ CreatedDate: [, (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)), `createdDate`],
4615
+ Name: [, __expectString, `name`],
4616
+ SecurityGroupIds: [, _json, `securityGroupIds`],
4617
+ SubnetIds: [, _json, `subnetIds`],
4618
+ Tags: [, _json, `tags`],
4619
+ VpcLinkId: [, __expectString, `vpcLinkId`],
4620
+ VpcLinkStatus: [, __expectString, `vpcLinkStatus`],
4621
+ VpcLinkStatusMessage: [, __expectString, `vpcLinkStatusMessage`],
4622
+ VpcLinkVersion: [, __expectString, `vpcLinkVersion`],
4623
+ });
4624
+ Object.assign(contents, doc);
5402
4625
  return contents;
5403
4626
  };
5404
4627
  const de_UpdateVpcLinkCommandError = async (output, context) => {
@@ -5419,21 +4642,21 @@ const de_UpdateVpcLinkCommandError = async (output, context) => {
5419
4642
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
5420
4643
  default:
5421
4644
  const parsedBody = parsedOutput.body;
5422
- throwDefaultError({
4645
+ return throwDefaultError({
5423
4646
  output,
5424
4647
  parsedBody,
5425
- exceptionCtor: __BaseException,
5426
4648
  errorCode,
5427
4649
  });
5428
4650
  }
5429
4651
  };
5430
- const map = __map;
4652
+ const throwDefaultError = withBaseException(__BaseException);
5431
4653
  const de_AccessDeniedExceptionRes = async (parsedOutput, context) => {
5432
4654
  const contents = map({});
5433
4655
  const data = parsedOutput.body;
5434
- if (data.message != null) {
5435
- contents.Message = __expectString(data.message);
5436
- }
4656
+ const doc = take(data, {
4657
+ Message: [, __expectString, `message`],
4658
+ });
4659
+ Object.assign(contents, doc);
5437
4660
  const exception = new AccessDeniedException({
5438
4661
  $metadata: deserializeMetadata(parsedOutput),
5439
4662
  ...contents,
@@ -5443,9 +4666,10 @@ const de_AccessDeniedExceptionRes = async (parsedOutput, context) => {
5443
4666
  const de_BadRequestExceptionRes = async (parsedOutput, context) => {
5444
4667
  const contents = map({});
5445
4668
  const data = parsedOutput.body;
5446
- if (data.message != null) {
5447
- contents.Message = __expectString(data.message);
5448
- }
4669
+ const doc = take(data, {
4670
+ Message: [, __expectString, `message`],
4671
+ });
4672
+ Object.assign(contents, doc);
5449
4673
  const exception = new BadRequestException({
5450
4674
  $metadata: deserializeMetadata(parsedOutput),
5451
4675
  ...contents,
@@ -5455,9 +4679,10 @@ const de_BadRequestExceptionRes = async (parsedOutput, context) => {
5455
4679
  const de_ConflictExceptionRes = async (parsedOutput, context) => {
5456
4680
  const contents = map({});
5457
4681
  const data = parsedOutput.body;
5458
- if (data.message != null) {
5459
- contents.Message = __expectString(data.message);
5460
- }
4682
+ const doc = take(data, {
4683
+ Message: [, __expectString, `message`],
4684
+ });
4685
+ Object.assign(contents, doc);
5461
4686
  const exception = new ConflictException({
5462
4687
  $metadata: deserializeMetadata(parsedOutput),
5463
4688
  ...contents,
@@ -5467,12 +4692,11 @@ const de_ConflictExceptionRes = async (parsedOutput, context) => {
5467
4692
  const de_NotFoundExceptionRes = async (parsedOutput, context) => {
5468
4693
  const contents = map({});
5469
4694
  const data = parsedOutput.body;
5470
- if (data.message != null) {
5471
- contents.Message = __expectString(data.message);
5472
- }
5473
- if (data.resourceType != null) {
5474
- contents.ResourceType = __expectString(data.resourceType);
5475
- }
4695
+ const doc = take(data, {
4696
+ Message: [, __expectString, `message`],
4697
+ ResourceType: [, __expectString, `resourceType`],
4698
+ });
4699
+ Object.assign(contents, doc);
5476
4700
  const exception = new NotFoundException({
5477
4701
  $metadata: deserializeMetadata(parsedOutput),
5478
4702
  ...contents,
@@ -5482,86 +4706,46 @@ const de_NotFoundExceptionRes = async (parsedOutput, context) => {
5482
4706
  const de_TooManyRequestsExceptionRes = async (parsedOutput, context) => {
5483
4707
  const contents = map({});
5484
4708
  const data = parsedOutput.body;
5485
- if (data.limitType != null) {
5486
- contents.LimitType = __expectString(data.limitType);
5487
- }
5488
- if (data.message != null) {
5489
- contents.Message = __expectString(data.message);
5490
- }
4709
+ const doc = take(data, {
4710
+ LimitType: [, __expectString, `limitType`],
4711
+ Message: [, __expectString, `message`],
4712
+ });
4713
+ Object.assign(contents, doc);
5491
4714
  const exception = new TooManyRequestsException({
5492
4715
  $metadata: deserializeMetadata(parsedOutput),
5493
4716
  ...contents,
5494
4717
  });
5495
4718
  return __decorateServiceException(exception, parsedOutput.body);
5496
4719
  };
5497
- const se___listOf__string = (input, context) => {
5498
- return input
5499
- .filter((e) => e != null)
5500
- .map((entry) => {
5501
- return entry;
5502
- });
5503
- };
5504
4720
  const se_AccessLogSettings = (input, context) => {
5505
- return {
5506
- ...(input.DestinationArn != null && { destinationArn: input.DestinationArn }),
5507
- ...(input.Format != null && { format: input.Format }),
5508
- };
5509
- };
5510
- const se_AuthorizationScopes = (input, context) => {
5511
- return input
5512
- .filter((e) => e != null)
5513
- .map((entry) => {
5514
- return entry;
4721
+ return take(input, {
4722
+ destinationArn: [, , `DestinationArn`],
4723
+ format: [, , `Format`],
5515
4724
  });
5516
4725
  };
5517
4726
  const se_Cors = (input, context) => {
5518
- return {
5519
- ...(input.AllowCredentials != null && { allowCredentials: input.AllowCredentials }),
5520
- ...(input.AllowHeaders != null && { allowHeaders: se_CorsHeaderList(input.AllowHeaders, context) }),
5521
- ...(input.AllowMethods != null && { allowMethods: se_CorsMethodList(input.AllowMethods, context) }),
5522
- ...(input.AllowOrigins != null && { allowOrigins: se_CorsOriginList(input.AllowOrigins, context) }),
5523
- ...(input.ExposeHeaders != null && { exposeHeaders: se_CorsHeaderList(input.ExposeHeaders, context) }),
5524
- ...(input.MaxAge != null && { maxAge: input.MaxAge }),
5525
- };
5526
- };
5527
- const se_CorsHeaderList = (input, context) => {
5528
- return input
5529
- .filter((e) => e != null)
5530
- .map((entry) => {
5531
- return entry;
5532
- });
5533
- };
5534
- const se_CorsMethodList = (input, context) => {
5535
- return input
5536
- .filter((e) => e != null)
5537
- .map((entry) => {
5538
- return entry;
5539
- });
5540
- };
5541
- const se_CorsOriginList = (input, context) => {
5542
- return input
5543
- .filter((e) => e != null)
5544
- .map((entry) => {
5545
- return entry;
4727
+ return take(input, {
4728
+ allowCredentials: [, , `AllowCredentials`],
4729
+ allowHeaders: [, _json, `AllowHeaders`],
4730
+ allowMethods: [, _json, `AllowMethods`],
4731
+ allowOrigins: [, _json, `AllowOrigins`],
4732
+ exposeHeaders: [, _json, `ExposeHeaders`],
4733
+ maxAge: [, , `MaxAge`],
5546
4734
  });
5547
4735
  };
5548
4736
  const se_DomainNameConfiguration = (input, context) => {
5549
- return {
5550
- ...(input.ApiGatewayDomainName != null && { apiGatewayDomainName: input.ApiGatewayDomainName }),
5551
- ...(input.CertificateArn != null && { certificateArn: input.CertificateArn }),
5552
- ...(input.CertificateName != null && { certificateName: input.CertificateName }),
5553
- ...(input.CertificateUploadDate != null && {
5554
- certificateUploadDate: input.CertificateUploadDate.toISOString().split(".")[0] + "Z",
5555
- }),
5556
- ...(input.DomainNameStatus != null && { domainNameStatus: input.DomainNameStatus }),
5557
- ...(input.DomainNameStatusMessage != null && { domainNameStatusMessage: input.DomainNameStatusMessage }),
5558
- ...(input.EndpointType != null && { endpointType: input.EndpointType }),
5559
- ...(input.HostedZoneId != null && { hostedZoneId: input.HostedZoneId }),
5560
- ...(input.OwnershipVerificationCertificateArn != null && {
5561
- ownershipVerificationCertificateArn: input.OwnershipVerificationCertificateArn,
5562
- }),
5563
- ...(input.SecurityPolicy != null && { securityPolicy: input.SecurityPolicy }),
5564
- };
4737
+ return take(input, {
4738
+ apiGatewayDomainName: [, , `ApiGatewayDomainName`],
4739
+ certificateArn: [, , `CertificateArn`],
4740
+ certificateName: [, , `CertificateName`],
4741
+ certificateUploadDate: [, (_) => _.toISOString().split(".")[0] + "Z", `CertificateUploadDate`],
4742
+ domainNameStatus: [, , `DomainNameStatus`],
4743
+ domainNameStatusMessage: [, , `DomainNameStatusMessage`],
4744
+ endpointType: [, , `EndpointType`],
4745
+ hostedZoneId: [, , `HostedZoneId`],
4746
+ ownershipVerificationCertificateArn: [, , `OwnershipVerificationCertificateArn`],
4747
+ securityPolicy: [, , `SecurityPolicy`],
4748
+ });
5565
4749
  };
5566
4750
  const se_DomainNameConfigurations = (input, context) => {
5567
4751
  return input
@@ -5570,56 +4754,22 @@ const se_DomainNameConfigurations = (input, context) => {
5570
4754
  return se_DomainNameConfiguration(entry, context);
5571
4755
  });
5572
4756
  };
5573
- const se_IdentitySourceList = (input, context) => {
5574
- return input
5575
- .filter((e) => e != null)
5576
- .map((entry) => {
5577
- return entry;
5578
- });
5579
- };
5580
- const se_IntegrationParameters = (input, context) => {
5581
- return Object.entries(input).reduce((acc, [key, value]) => {
5582
- if (value === null) {
5583
- return acc;
5584
- }
5585
- acc[key] = value;
5586
- return acc;
5587
- }, {});
5588
- };
5589
4757
  const se_JWTConfiguration = (input, context) => {
5590
- return {
5591
- ...(input.Audience != null && { audience: se___listOf__string(input.Audience, context) }),
5592
- ...(input.Issuer != null && { issuer: input.Issuer }),
5593
- };
4758
+ return take(input, {
4759
+ audience: [, _json, `Audience`],
4760
+ issuer: [, , `Issuer`],
4761
+ });
5594
4762
  };
5595
4763
  const se_MutualTlsAuthenticationInput = (input, context) => {
5596
- return {
5597
- ...(input.TruststoreUri != null && { truststoreUri: input.TruststoreUri }),
5598
- ...(input.TruststoreVersion != null && { truststoreVersion: input.TruststoreVersion }),
5599
- };
4764
+ return take(input, {
4765
+ truststoreUri: [, , `TruststoreUri`],
4766
+ truststoreVersion: [, , `TruststoreVersion`],
4767
+ });
5600
4768
  };
5601
4769
  const se_ParameterConstraints = (input, context) => {
5602
- return {
5603
- ...(input.Required != null && { required: input.Required }),
5604
- };
5605
- };
5606
- const se_ResponseParameters = (input, context) => {
5607
- return Object.entries(input).reduce((acc, [key, value]) => {
5608
- if (value === null) {
5609
- return acc;
5610
- }
5611
- acc[key] = se_IntegrationParameters(value, context);
5612
- return acc;
5613
- }, {});
5614
- };
5615
- const se_RouteModels = (input, context) => {
5616
- return Object.entries(input).reduce((acc, [key, value]) => {
5617
- if (value === null) {
5618
- return acc;
5619
- }
5620
- acc[key] = value;
5621
- return acc;
5622
- }, {});
4770
+ return take(input, {
4771
+ required: [, , `Required`],
4772
+ });
5623
4773
  };
5624
4774
  const se_RouteParameters = (input, context) => {
5625
4775
  return Object.entries(input).reduce((acc, [key, value]) => {
@@ -5631,13 +4781,13 @@ const se_RouteParameters = (input, context) => {
5631
4781
  }, {});
5632
4782
  };
5633
4783
  const se_RouteSettings = (input, context) => {
5634
- return {
5635
- ...(input.DataTraceEnabled != null && { dataTraceEnabled: input.DataTraceEnabled }),
5636
- ...(input.DetailedMetricsEnabled != null && { detailedMetricsEnabled: input.DetailedMetricsEnabled }),
5637
- ...(input.LoggingLevel != null && { loggingLevel: input.LoggingLevel }),
5638
- ...(input.ThrottlingBurstLimit != null && { throttlingBurstLimit: input.ThrottlingBurstLimit }),
5639
- ...(input.ThrottlingRateLimit != null && { throttlingRateLimit: __serializeFloat(input.ThrottlingRateLimit) }),
5640
- };
4784
+ return take(input, {
4785
+ dataTraceEnabled: [, , `DataTraceEnabled`],
4786
+ detailedMetricsEnabled: [, , `DetailedMetricsEnabled`],
4787
+ loggingLevel: [, , `LoggingLevel`],
4788
+ throttlingBurstLimit: [, , `ThrottlingBurstLimit`],
4789
+ throttlingRateLimit: [, __serializeFloat, `ThrottlingRateLimit`],
4790
+ });
5641
4791
  };
5642
4792
  const se_RouteSettingsMap = (input, context) => {
5643
4793
  return Object.entries(input).reduce((acc, [key, value]) => {
@@ -5648,70 +4798,15 @@ const se_RouteSettingsMap = (input, context) => {
5648
4798
  return acc;
5649
4799
  }, {});
5650
4800
  };
5651
- const se_SecurityGroupIdList = (input, context) => {
5652
- return input
5653
- .filter((e) => e != null)
5654
- .map((entry) => {
5655
- return entry;
5656
- });
5657
- };
5658
- const se_StageVariablesMap = (input, context) => {
5659
- return Object.entries(input).reduce((acc, [key, value]) => {
5660
- if (value === null) {
5661
- return acc;
5662
- }
5663
- acc[key] = value;
5664
- return acc;
5665
- }, {});
5666
- };
5667
- const se_SubnetIdList = (input, context) => {
5668
- return input
5669
- .filter((e) => e != null)
5670
- .map((entry) => {
5671
- return entry;
5672
- });
5673
- };
5674
- const se_Tags = (input, context) => {
5675
- return Object.entries(input).reduce((acc, [key, value]) => {
5676
- if (value === null) {
5677
- return acc;
5678
- }
5679
- acc[key] = value;
5680
- return acc;
5681
- }, {});
5682
- };
5683
- const se_TemplateMap = (input, context) => {
5684
- return Object.entries(input).reduce((acc, [key, value]) => {
5685
- if (value === null) {
5686
- return acc;
5687
- }
5688
- acc[key] = value;
5689
- return acc;
5690
- }, {});
5691
- };
5692
4801
  const se_TlsConfigInput = (input, context) => {
5693
- return {
5694
- ...(input.ServerNameToVerify != null && { serverNameToVerify: input.ServerNameToVerify }),
5695
- };
5696
- };
5697
- const de___listOf__string = (output, context) => {
5698
- const retVal = (output || [])
5699
- .filter((e) => e != null)
5700
- .map((entry) => {
5701
- if (entry === null) {
5702
- return null;
5703
- }
5704
- return __expectString(entry);
4802
+ return take(input, {
4803
+ serverNameToVerify: [, , `ServerNameToVerify`],
5705
4804
  });
5706
- return retVal;
5707
4805
  };
5708
4806
  const de___listOfApi = (output, context) => {
5709
4807
  const retVal = (output || [])
5710
4808
  .filter((e) => e != null)
5711
4809
  .map((entry) => {
5712
- if (entry === null) {
5713
- return null;
5714
- }
5715
4810
  return de_Api(entry, context);
5716
4811
  });
5717
4812
  return retVal;
@@ -5720,9 +4815,6 @@ const de___listOfApiMapping = (output, context) => {
5720
4815
  const retVal = (output || [])
5721
4816
  .filter((e) => e != null)
5722
4817
  .map((entry) => {
5723
- if (entry === null) {
5724
- return null;
5725
- }
5726
4818
  return de_ApiMapping(entry, context);
5727
4819
  });
5728
4820
  return retVal;
@@ -5731,9 +4823,6 @@ const de___listOfAuthorizer = (output, context) => {
5731
4823
  const retVal = (output || [])
5732
4824
  .filter((e) => e != null)
5733
4825
  .map((entry) => {
5734
- if (entry === null) {
5735
- return null;
5736
- }
5737
4826
  return de_Authorizer(entry, context);
5738
4827
  });
5739
4828
  return retVal;
@@ -5742,9 +4831,6 @@ const de___listOfDeployment = (output, context) => {
5742
4831
  const retVal = (output || [])
5743
4832
  .filter((e) => e != null)
5744
4833
  .map((entry) => {
5745
- if (entry === null) {
5746
- return null;
5747
- }
5748
4834
  return de_Deployment(entry, context);
5749
4835
  });
5750
4836
  return retVal;
@@ -5753,9 +4839,6 @@ const de___listOfDomainName = (output, context) => {
5753
4839
  const retVal = (output || [])
5754
4840
  .filter((e) => e != null)
5755
4841
  .map((entry) => {
5756
- if (entry === null) {
5757
- return null;
5758
- }
5759
4842
  return de_DomainName(entry, context);
5760
4843
  });
5761
4844
  return retVal;
@@ -5764,9 +4847,6 @@ const de___listOfIntegration = (output, context) => {
5764
4847
  const retVal = (output || [])
5765
4848
  .filter((e) => e != null)
5766
4849
  .map((entry) => {
5767
- if (entry === null) {
5768
- return null;
5769
- }
5770
4850
  return de_Integration(entry, context);
5771
4851
  });
5772
4852
  return retVal;
@@ -5775,9 +4855,6 @@ const de___listOfIntegrationResponse = (output, context) => {
5775
4855
  const retVal = (output || [])
5776
4856
  .filter((e) => e != null)
5777
4857
  .map((entry) => {
5778
- if (entry === null) {
5779
- return null;
5780
- }
5781
4858
  return de_IntegrationResponse(entry, context);
5782
4859
  });
5783
4860
  return retVal;
@@ -5786,9 +4863,6 @@ const de___listOfModel = (output, context) => {
5786
4863
  const retVal = (output || [])
5787
4864
  .filter((e) => e != null)
5788
4865
  .map((entry) => {
5789
- if (entry === null) {
5790
- return null;
5791
- }
5792
4866
  return de_Model(entry, context);
5793
4867
  });
5794
4868
  return retVal;
@@ -5797,9 +4871,6 @@ const de___listOfRoute = (output, context) => {
5797
4871
  const retVal = (output || [])
5798
4872
  .filter((e) => e != null)
5799
4873
  .map((entry) => {
5800
- if (entry === null) {
5801
- return null;
5802
- }
5803
4874
  return de_Route(entry, context);
5804
4875
  });
5805
4876
  return retVal;
@@ -5808,9 +4879,6 @@ const de___listOfRouteResponse = (output, context) => {
5808
4879
  const retVal = (output || [])
5809
4880
  .filter((e) => e != null)
5810
4881
  .map((entry) => {
5811
- if (entry === null) {
5812
- return null;
5813
- }
5814
4882
  return de_RouteResponse(entry, context);
5815
4883
  });
5816
4884
  return retVal;
@@ -5819,9 +4887,6 @@ const de___listOfStage = (output, context) => {
5819
4887
  const retVal = (output || [])
5820
4888
  .filter((e) => e != null)
5821
4889
  .map((entry) => {
5822
- if (entry === null) {
5823
- return null;
5824
- }
5825
4890
  return de_Stage(entry, context);
5826
4891
  });
5827
4892
  return retVal;
@@ -5830,281 +4895,187 @@ const de___listOfVpcLink = (output, context) => {
5830
4895
  const retVal = (output || [])
5831
4896
  .filter((e) => e != null)
5832
4897
  .map((entry) => {
5833
- if (entry === null) {
5834
- return null;
5835
- }
5836
4898
  return de_VpcLink(entry, context);
5837
4899
  });
5838
4900
  return retVal;
5839
4901
  };
5840
4902
  const de_AccessLogSettings = (output, context) => {
5841
- return {
5842
- DestinationArn: __expectString(output.destinationArn),
5843
- Format: __expectString(output.format),
5844
- };
4903
+ return take(output, {
4904
+ DestinationArn: [, __expectString, `destinationArn`],
4905
+ Format: [, __expectString, `format`],
4906
+ });
5845
4907
  };
5846
4908
  const de_Api = (output, context) => {
5847
- return {
5848
- ApiEndpoint: __expectString(output.apiEndpoint),
5849
- ApiGatewayManaged: __expectBoolean(output.apiGatewayManaged),
5850
- ApiId: __expectString(output.apiId),
5851
- ApiKeySelectionExpression: __expectString(output.apiKeySelectionExpression),
5852
- CorsConfiguration: output.corsConfiguration != null ? de_Cors(output.corsConfiguration, context) : undefined,
5853
- CreatedDate: output.createdDate != null ? __expectNonNull(__parseRfc3339DateTimeWithOffset(output.createdDate)) : undefined,
5854
- Description: __expectString(output.description),
5855
- DisableExecuteApiEndpoint: __expectBoolean(output.disableExecuteApiEndpoint),
5856
- DisableSchemaValidation: __expectBoolean(output.disableSchemaValidation),
5857
- ImportInfo: output.importInfo != null ? de___listOf__string(output.importInfo, context) : undefined,
5858
- Name: __expectString(output.name),
5859
- ProtocolType: __expectString(output.protocolType),
5860
- RouteSelectionExpression: __expectString(output.routeSelectionExpression),
5861
- Tags: output.tags != null ? de_Tags(output.tags, context) : undefined,
5862
- Version: __expectString(output.version),
5863
- Warnings: output.warnings != null ? de___listOf__string(output.warnings, context) : undefined,
5864
- };
4909
+ return take(output, {
4910
+ ApiEndpoint: [, __expectString, `apiEndpoint`],
4911
+ ApiGatewayManaged: [, __expectBoolean, `apiGatewayManaged`],
4912
+ ApiId: [, __expectString, `apiId`],
4913
+ ApiKeySelectionExpression: [, __expectString, `apiKeySelectionExpression`],
4914
+ CorsConfiguration: (_) => [, de_Cors(_, context), `corsConfiguration`],
4915
+ CreatedDate: (_) => [, __expectNonNull(__parseRfc3339DateTimeWithOffset(_)), `createdDate`],
4916
+ Description: [, __expectString, `description`],
4917
+ DisableExecuteApiEndpoint: [, __expectBoolean, `disableExecuteApiEndpoint`],
4918
+ DisableSchemaValidation: [, __expectBoolean, `disableSchemaValidation`],
4919
+ ImportInfo: [, _json, `importInfo`],
4920
+ Name: [, __expectString, `name`],
4921
+ ProtocolType: [, __expectString, `protocolType`],
4922
+ RouteSelectionExpression: [, __expectString, `routeSelectionExpression`],
4923
+ Tags: [, _json, `tags`],
4924
+ Version: [, __expectString, `version`],
4925
+ Warnings: [, _json, `warnings`],
4926
+ });
5865
4927
  };
5866
4928
  const de_ApiMapping = (output, context) => {
5867
- return {
5868
- ApiId: __expectString(output.apiId),
5869
- ApiMappingId: __expectString(output.apiMappingId),
5870
- ApiMappingKey: __expectString(output.apiMappingKey),
5871
- Stage: __expectString(output.stage),
5872
- };
5873
- };
5874
- const de_AuthorizationScopes = (output, context) => {
5875
- const retVal = (output || [])
5876
- .filter((e) => e != null)
5877
- .map((entry) => {
5878
- if (entry === null) {
5879
- return null;
5880
- }
5881
- return __expectString(entry);
4929
+ return take(output, {
4930
+ ApiId: [, __expectString, `apiId`],
4931
+ ApiMappingId: [, __expectString, `apiMappingId`],
4932
+ ApiMappingKey: [, __expectString, `apiMappingKey`],
4933
+ Stage: [, __expectString, `stage`],
5882
4934
  });
5883
- return retVal;
5884
4935
  };
5885
4936
  const de_Authorizer = (output, context) => {
5886
- return {
5887
- AuthorizerCredentialsArn: __expectString(output.authorizerCredentialsArn),
5888
- AuthorizerId: __expectString(output.authorizerId),
5889
- AuthorizerPayloadFormatVersion: __expectString(output.authorizerPayloadFormatVersion),
5890
- AuthorizerResultTtlInSeconds: __expectInt32(output.authorizerResultTtlInSeconds),
5891
- AuthorizerType: __expectString(output.authorizerType),
5892
- AuthorizerUri: __expectString(output.authorizerUri),
5893
- EnableSimpleResponses: __expectBoolean(output.enableSimpleResponses),
5894
- IdentitySource: output.identitySource != null ? de_IdentitySourceList(output.identitySource, context) : undefined,
5895
- IdentityValidationExpression: __expectString(output.identityValidationExpression),
5896
- JwtConfiguration: output.jwtConfiguration != null ? de_JWTConfiguration(output.jwtConfiguration, context) : undefined,
5897
- Name: __expectString(output.name),
5898
- };
5899
- };
5900
- const de_Cors = (output, context) => {
5901
- return {
5902
- AllowCredentials: __expectBoolean(output.allowCredentials),
5903
- AllowHeaders: output.allowHeaders != null ? de_CorsHeaderList(output.allowHeaders, context) : undefined,
5904
- AllowMethods: output.allowMethods != null ? de_CorsMethodList(output.allowMethods, context) : undefined,
5905
- AllowOrigins: output.allowOrigins != null ? de_CorsOriginList(output.allowOrigins, context) : undefined,
5906
- ExposeHeaders: output.exposeHeaders != null ? de_CorsHeaderList(output.exposeHeaders, context) : undefined,
5907
- MaxAge: __expectInt32(output.maxAge),
5908
- };
5909
- };
5910
- const de_CorsHeaderList = (output, context) => {
5911
- const retVal = (output || [])
5912
- .filter((e) => e != null)
5913
- .map((entry) => {
5914
- if (entry === null) {
5915
- return null;
5916
- }
5917
- return __expectString(entry);
5918
- });
5919
- return retVal;
5920
- };
5921
- const de_CorsMethodList = (output, context) => {
5922
- const retVal = (output || [])
5923
- .filter((e) => e != null)
5924
- .map((entry) => {
5925
- if (entry === null) {
5926
- return null;
5927
- }
5928
- return __expectString(entry);
4937
+ return take(output, {
4938
+ AuthorizerCredentialsArn: [, __expectString, `authorizerCredentialsArn`],
4939
+ AuthorizerId: [, __expectString, `authorizerId`],
4940
+ AuthorizerPayloadFormatVersion: [, __expectString, `authorizerPayloadFormatVersion`],
4941
+ AuthorizerResultTtlInSeconds: [, __expectInt32, `authorizerResultTtlInSeconds`],
4942
+ AuthorizerType: [, __expectString, `authorizerType`],
4943
+ AuthorizerUri: [, __expectString, `authorizerUri`],
4944
+ EnableSimpleResponses: [, __expectBoolean, `enableSimpleResponses`],
4945
+ IdentitySource: [, _json, `identitySource`],
4946
+ IdentityValidationExpression: [, __expectString, `identityValidationExpression`],
4947
+ JwtConfiguration: (_) => [, de_JWTConfiguration(_, context), `jwtConfiguration`],
4948
+ Name: [, __expectString, `name`],
5929
4949
  });
5930
- return retVal;
5931
4950
  };
5932
- const de_CorsOriginList = (output, context) => {
5933
- const retVal = (output || [])
5934
- .filter((e) => e != null)
5935
- .map((entry) => {
5936
- if (entry === null) {
5937
- return null;
5938
- }
5939
- return __expectString(entry);
4951
+ const de_Cors = (output, context) => {
4952
+ return take(output, {
4953
+ AllowCredentials: [, __expectBoolean, `allowCredentials`],
4954
+ AllowHeaders: [, _json, `allowHeaders`],
4955
+ AllowMethods: [, _json, `allowMethods`],
4956
+ AllowOrigins: [, _json, `allowOrigins`],
4957
+ ExposeHeaders: [, _json, `exposeHeaders`],
4958
+ MaxAge: [, __expectInt32, `maxAge`],
5940
4959
  });
5941
- return retVal;
5942
4960
  };
5943
4961
  const de_Deployment = (output, context) => {
5944
- return {
5945
- AutoDeployed: __expectBoolean(output.autoDeployed),
5946
- CreatedDate: output.createdDate != null ? __expectNonNull(__parseRfc3339DateTimeWithOffset(output.createdDate)) : undefined,
5947
- DeploymentId: __expectString(output.deploymentId),
5948
- DeploymentStatus: __expectString(output.deploymentStatus),
5949
- DeploymentStatusMessage: __expectString(output.deploymentStatusMessage),
5950
- Description: __expectString(output.description),
5951
- };
4962
+ return take(output, {
4963
+ AutoDeployed: [, __expectBoolean, `autoDeployed`],
4964
+ CreatedDate: (_) => [, __expectNonNull(__parseRfc3339DateTimeWithOffset(_)), `createdDate`],
4965
+ DeploymentId: [, __expectString, `deploymentId`],
4966
+ DeploymentStatus: [, __expectString, `deploymentStatus`],
4967
+ DeploymentStatusMessage: [, __expectString, `deploymentStatusMessage`],
4968
+ Description: [, __expectString, `description`],
4969
+ });
5952
4970
  };
5953
4971
  const de_DomainName = (output, context) => {
5954
- return {
5955
- ApiMappingSelectionExpression: __expectString(output.apiMappingSelectionExpression),
5956
- DomainName: __expectString(output.domainName),
5957
- DomainNameConfigurations: output.domainNameConfigurations != null
5958
- ? de_DomainNameConfigurations(output.domainNameConfigurations, context)
5959
- : undefined,
5960
- MutualTlsAuthentication: output.mutualTlsAuthentication != null
5961
- ? de_MutualTlsAuthentication(output.mutualTlsAuthentication, context)
5962
- : undefined,
5963
- Tags: output.tags != null ? de_Tags(output.tags, context) : undefined,
5964
- };
4972
+ return take(output, {
4973
+ ApiMappingSelectionExpression: [, __expectString, `apiMappingSelectionExpression`],
4974
+ DomainName: [, __expectString, `domainName`],
4975
+ DomainNameConfigurations: (_) => [, de_DomainNameConfigurations(_, context), `domainNameConfigurations`],
4976
+ MutualTlsAuthentication: (_) => [, de_MutualTlsAuthentication(_, context), `mutualTlsAuthentication`],
4977
+ Tags: [, _json, `tags`],
4978
+ });
5965
4979
  };
5966
4980
  const de_DomainNameConfiguration = (output, context) => {
5967
- return {
5968
- ApiGatewayDomainName: __expectString(output.apiGatewayDomainName),
5969
- CertificateArn: __expectString(output.certificateArn),
5970
- CertificateName: __expectString(output.certificateName),
5971
- CertificateUploadDate: output.certificateUploadDate != null
5972
- ? __expectNonNull(__parseRfc3339DateTimeWithOffset(output.certificateUploadDate))
5973
- : undefined,
5974
- DomainNameStatus: __expectString(output.domainNameStatus),
5975
- DomainNameStatusMessage: __expectString(output.domainNameStatusMessage),
5976
- EndpointType: __expectString(output.endpointType),
5977
- HostedZoneId: __expectString(output.hostedZoneId),
5978
- OwnershipVerificationCertificateArn: __expectString(output.ownershipVerificationCertificateArn),
5979
- SecurityPolicy: __expectString(output.securityPolicy),
5980
- };
4981
+ return take(output, {
4982
+ ApiGatewayDomainName: [, __expectString, `apiGatewayDomainName`],
4983
+ CertificateArn: [, __expectString, `certificateArn`],
4984
+ CertificateName: [, __expectString, `certificateName`],
4985
+ CertificateUploadDate: (_) => [, __expectNonNull(__parseRfc3339DateTimeWithOffset(_)), `certificateUploadDate`],
4986
+ DomainNameStatus: [, __expectString, `domainNameStatus`],
4987
+ DomainNameStatusMessage: [, __expectString, `domainNameStatusMessage`],
4988
+ EndpointType: [, __expectString, `endpointType`],
4989
+ HostedZoneId: [, __expectString, `hostedZoneId`],
4990
+ OwnershipVerificationCertificateArn: [, __expectString, `ownershipVerificationCertificateArn`],
4991
+ SecurityPolicy: [, __expectString, `securityPolicy`],
4992
+ });
5981
4993
  };
5982
4994
  const de_DomainNameConfigurations = (output, context) => {
5983
4995
  const retVal = (output || [])
5984
4996
  .filter((e) => e != null)
5985
4997
  .map((entry) => {
5986
- if (entry === null) {
5987
- return null;
5988
- }
5989
4998
  return de_DomainNameConfiguration(entry, context);
5990
4999
  });
5991
5000
  return retVal;
5992
5001
  };
5993
- const de_IdentitySourceList = (output, context) => {
5994
- const retVal = (output || [])
5995
- .filter((e) => e != null)
5996
- .map((entry) => {
5997
- if (entry === null) {
5998
- return null;
5999
- }
6000
- return __expectString(entry);
6001
- });
6002
- return retVal;
6003
- };
6004
5002
  const de_Integration = (output, context) => {
6005
- return {
6006
- ApiGatewayManaged: __expectBoolean(output.apiGatewayManaged),
6007
- ConnectionId: __expectString(output.connectionId),
6008
- ConnectionType: __expectString(output.connectionType),
6009
- ContentHandlingStrategy: __expectString(output.contentHandlingStrategy),
6010
- CredentialsArn: __expectString(output.credentialsArn),
6011
- Description: __expectString(output.description),
6012
- IntegrationId: __expectString(output.integrationId),
6013
- IntegrationMethod: __expectString(output.integrationMethod),
6014
- IntegrationResponseSelectionExpression: __expectString(output.integrationResponseSelectionExpression),
6015
- IntegrationSubtype: __expectString(output.integrationSubtype),
6016
- IntegrationType: __expectString(output.integrationType),
6017
- IntegrationUri: __expectString(output.integrationUri),
6018
- PassthroughBehavior: __expectString(output.passthroughBehavior),
6019
- PayloadFormatVersion: __expectString(output.payloadFormatVersion),
6020
- RequestParameters: output.requestParameters != null ? de_IntegrationParameters(output.requestParameters, context) : undefined,
6021
- RequestTemplates: output.requestTemplates != null ? de_TemplateMap(output.requestTemplates, context) : undefined,
6022
- ResponseParameters: output.responseParameters != null ? de_ResponseParameters(output.responseParameters, context) : undefined,
6023
- TemplateSelectionExpression: __expectString(output.templateSelectionExpression),
6024
- TimeoutInMillis: __expectInt32(output.timeoutInMillis),
6025
- TlsConfig: output.tlsConfig != null ? de_TlsConfig(output.tlsConfig, context) : undefined,
6026
- };
6027
- };
6028
- const de_IntegrationParameters = (output, context) => {
6029
- return Object.entries(output).reduce((acc, [key, value]) => {
6030
- if (value === null) {
6031
- return acc;
6032
- }
6033
- acc[key] = __expectString(value);
6034
- return acc;
6035
- }, {});
5003
+ return take(output, {
5004
+ ApiGatewayManaged: [, __expectBoolean, `apiGatewayManaged`],
5005
+ ConnectionId: [, __expectString, `connectionId`],
5006
+ ConnectionType: [, __expectString, `connectionType`],
5007
+ ContentHandlingStrategy: [, __expectString, `contentHandlingStrategy`],
5008
+ CredentialsArn: [, __expectString, `credentialsArn`],
5009
+ Description: [, __expectString, `description`],
5010
+ IntegrationId: [, __expectString, `integrationId`],
5011
+ IntegrationMethod: [, __expectString, `integrationMethod`],
5012
+ IntegrationResponseSelectionExpression: [, __expectString, `integrationResponseSelectionExpression`],
5013
+ IntegrationSubtype: [, __expectString, `integrationSubtype`],
5014
+ IntegrationType: [, __expectString, `integrationType`],
5015
+ IntegrationUri: [, __expectString, `integrationUri`],
5016
+ PassthroughBehavior: [, __expectString, `passthroughBehavior`],
5017
+ PayloadFormatVersion: [, __expectString, `payloadFormatVersion`],
5018
+ RequestParameters: [, _json, `requestParameters`],
5019
+ RequestTemplates: [, _json, `requestTemplates`],
5020
+ ResponseParameters: [, _json, `responseParameters`],
5021
+ TemplateSelectionExpression: [, __expectString, `templateSelectionExpression`],
5022
+ TimeoutInMillis: [, __expectInt32, `timeoutInMillis`],
5023
+ TlsConfig: (_) => [, de_TlsConfig(_, context), `tlsConfig`],
5024
+ });
6036
5025
  };
6037
5026
  const de_IntegrationResponse = (output, context) => {
6038
- return {
6039
- ContentHandlingStrategy: __expectString(output.contentHandlingStrategy),
6040
- IntegrationResponseId: __expectString(output.integrationResponseId),
6041
- IntegrationResponseKey: __expectString(output.integrationResponseKey),
6042
- ResponseParameters: output.responseParameters != null ? de_IntegrationParameters(output.responseParameters, context) : undefined,
6043
- ResponseTemplates: output.responseTemplates != null ? de_TemplateMap(output.responseTemplates, context) : undefined,
6044
- TemplateSelectionExpression: __expectString(output.templateSelectionExpression),
6045
- };
5027
+ return take(output, {
5028
+ ContentHandlingStrategy: [, __expectString, `contentHandlingStrategy`],
5029
+ IntegrationResponseId: [, __expectString, `integrationResponseId`],
5030
+ IntegrationResponseKey: [, __expectString, `integrationResponseKey`],
5031
+ ResponseParameters: [, _json, `responseParameters`],
5032
+ ResponseTemplates: [, _json, `responseTemplates`],
5033
+ TemplateSelectionExpression: [, __expectString, `templateSelectionExpression`],
5034
+ });
6046
5035
  };
6047
5036
  const de_JWTConfiguration = (output, context) => {
6048
- return {
6049
- Audience: output.audience != null ? de___listOf__string(output.audience, context) : undefined,
6050
- Issuer: __expectString(output.issuer),
6051
- };
5037
+ return take(output, {
5038
+ Audience: [, _json, `audience`],
5039
+ Issuer: [, __expectString, `issuer`],
5040
+ });
6052
5041
  };
6053
5042
  const de_Model = (output, context) => {
6054
- return {
6055
- ContentType: __expectString(output.contentType),
6056
- Description: __expectString(output.description),
6057
- ModelId: __expectString(output.modelId),
6058
- Name: __expectString(output.name),
6059
- Schema: __expectString(output.schema),
6060
- };
5043
+ return take(output, {
5044
+ ContentType: [, __expectString, `contentType`],
5045
+ Description: [, __expectString, `description`],
5046
+ ModelId: [, __expectString, `modelId`],
5047
+ Name: [, __expectString, `name`],
5048
+ Schema: [, __expectString, `schema`],
5049
+ });
6061
5050
  };
6062
5051
  const de_MutualTlsAuthentication = (output, context) => {
6063
- return {
6064
- TruststoreUri: __expectString(output.truststoreUri),
6065
- TruststoreVersion: __expectString(output.truststoreVersion),
6066
- TruststoreWarnings: output.truststoreWarnings != null ? de___listOf__string(output.truststoreWarnings, context) : undefined,
6067
- };
5052
+ return take(output, {
5053
+ TruststoreUri: [, __expectString, `truststoreUri`],
5054
+ TruststoreVersion: [, __expectString, `truststoreVersion`],
5055
+ TruststoreWarnings: [, _json, `truststoreWarnings`],
5056
+ });
6068
5057
  };
6069
5058
  const de_ParameterConstraints = (output, context) => {
6070
- return {
6071
- Required: __expectBoolean(output.required),
6072
- };
6073
- };
6074
- const de_ResponseParameters = (output, context) => {
6075
- return Object.entries(output).reduce((acc, [key, value]) => {
6076
- if (value === null) {
6077
- return acc;
6078
- }
6079
- acc[key] = de_IntegrationParameters(value, context);
6080
- return acc;
6081
- }, {});
5059
+ return take(output, {
5060
+ Required: [, __expectBoolean, `required`],
5061
+ });
6082
5062
  };
6083
5063
  const de_Route = (output, context) => {
6084
- return {
6085
- ApiGatewayManaged: __expectBoolean(output.apiGatewayManaged),
6086
- ApiKeyRequired: __expectBoolean(output.apiKeyRequired),
6087
- AuthorizationScopes: output.authorizationScopes != null ? de_AuthorizationScopes(output.authorizationScopes, context) : undefined,
6088
- AuthorizationType: __expectString(output.authorizationType),
6089
- AuthorizerId: __expectString(output.authorizerId),
6090
- ModelSelectionExpression: __expectString(output.modelSelectionExpression),
6091
- OperationName: __expectString(output.operationName),
6092
- RequestModels: output.requestModels != null ? de_RouteModels(output.requestModels, context) : undefined,
6093
- RequestParameters: output.requestParameters != null ? de_RouteParameters(output.requestParameters, context) : undefined,
6094
- RouteId: __expectString(output.routeId),
6095
- RouteKey: __expectString(output.routeKey),
6096
- RouteResponseSelectionExpression: __expectString(output.routeResponseSelectionExpression),
6097
- Target: __expectString(output.target),
6098
- };
6099
- };
6100
- const de_RouteModels = (output, context) => {
6101
- return Object.entries(output).reduce((acc, [key, value]) => {
6102
- if (value === null) {
6103
- return acc;
6104
- }
6105
- acc[key] = __expectString(value);
6106
- return acc;
6107
- }, {});
5064
+ return take(output, {
5065
+ ApiGatewayManaged: [, __expectBoolean, `apiGatewayManaged`],
5066
+ ApiKeyRequired: [, __expectBoolean, `apiKeyRequired`],
5067
+ AuthorizationScopes: [, _json, `authorizationScopes`],
5068
+ AuthorizationType: [, __expectString, `authorizationType`],
5069
+ AuthorizerId: [, __expectString, `authorizerId`],
5070
+ ModelSelectionExpression: [, __expectString, `modelSelectionExpression`],
5071
+ OperationName: [, __expectString, `operationName`],
5072
+ RequestModels: [, _json, `requestModels`],
5073
+ RequestParameters: (_) => [, de_RouteParameters(_, context), `requestParameters`],
5074
+ RouteId: [, __expectString, `routeId`],
5075
+ RouteKey: [, __expectString, `routeKey`],
5076
+ RouteResponseSelectionExpression: [, __expectString, `routeResponseSelectionExpression`],
5077
+ Target: [, __expectString, `target`],
5078
+ });
6108
5079
  };
6109
5080
  const de_RouteParameters = (output, context) => {
6110
5081
  return Object.entries(output).reduce((acc, [key, value]) => {
@@ -6116,22 +5087,22 @@ const de_RouteParameters = (output, context) => {
6116
5087
  }, {});
6117
5088
  };
6118
5089
  const de_RouteResponse = (output, context) => {
6119
- return {
6120
- ModelSelectionExpression: __expectString(output.modelSelectionExpression),
6121
- ResponseModels: output.responseModels != null ? de_RouteModels(output.responseModels, context) : undefined,
6122
- ResponseParameters: output.responseParameters != null ? de_RouteParameters(output.responseParameters, context) : undefined,
6123
- RouteResponseId: __expectString(output.routeResponseId),
6124
- RouteResponseKey: __expectString(output.routeResponseKey),
6125
- };
5090
+ return take(output, {
5091
+ ModelSelectionExpression: [, __expectString, `modelSelectionExpression`],
5092
+ ResponseModels: [, _json, `responseModels`],
5093
+ ResponseParameters: (_) => [, de_RouteParameters(_, context), `responseParameters`],
5094
+ RouteResponseId: [, __expectString, `routeResponseId`],
5095
+ RouteResponseKey: [, __expectString, `routeResponseKey`],
5096
+ });
6126
5097
  };
6127
5098
  const de_RouteSettings = (output, context) => {
6128
- return {
6129
- DataTraceEnabled: __expectBoolean(output.dataTraceEnabled),
6130
- DetailedMetricsEnabled: __expectBoolean(output.detailedMetricsEnabled),
6131
- LoggingLevel: __expectString(output.loggingLevel),
6132
- ThrottlingBurstLimit: __expectInt32(output.throttlingBurstLimit),
6133
- ThrottlingRateLimit: __limitedParseDouble(output.throttlingRateLimit),
6134
- };
5099
+ return take(output, {
5100
+ DataTraceEnabled: [, __expectBoolean, `dataTraceEnabled`],
5101
+ DetailedMetricsEnabled: [, __expectBoolean, `detailedMetricsEnabled`],
5102
+ LoggingLevel: [, __expectString, `loggingLevel`],
5103
+ ThrottlingBurstLimit: [, __expectInt32, `throttlingBurstLimit`],
5104
+ ThrottlingRateLimit: [, __limitedParseDouble, `throttlingRateLimit`],
5105
+ });
6135
5106
  };
6136
5107
  const de_RouteSettingsMap = (output, context) => {
6137
5108
  return Object.entries(output).reduce((acc, [key, value]) => {
@@ -6142,92 +5113,41 @@ const de_RouteSettingsMap = (output, context) => {
6142
5113
  return acc;
6143
5114
  }, {});
6144
5115
  };
6145
- const de_SecurityGroupIdList = (output, context) => {
6146
- const retVal = (output || [])
6147
- .filter((e) => e != null)
6148
- .map((entry) => {
6149
- if (entry === null) {
6150
- return null;
6151
- }
6152
- return __expectString(entry);
6153
- });
6154
- return retVal;
6155
- };
6156
5116
  const de_Stage = (output, context) => {
6157
- return {
6158
- AccessLogSettings: output.accessLogSettings != null ? de_AccessLogSettings(output.accessLogSettings, context) : undefined,
6159
- ApiGatewayManaged: __expectBoolean(output.apiGatewayManaged),
6160
- AutoDeploy: __expectBoolean(output.autoDeploy),
6161
- ClientCertificateId: __expectString(output.clientCertificateId),
6162
- CreatedDate: output.createdDate != null ? __expectNonNull(__parseRfc3339DateTimeWithOffset(output.createdDate)) : undefined,
6163
- DefaultRouteSettings: output.defaultRouteSettings != null ? de_RouteSettings(output.defaultRouteSettings, context) : undefined,
6164
- DeploymentId: __expectString(output.deploymentId),
6165
- Description: __expectString(output.description),
6166
- LastDeploymentStatusMessage: __expectString(output.lastDeploymentStatusMessage),
6167
- LastUpdatedDate: output.lastUpdatedDate != null
6168
- ? __expectNonNull(__parseRfc3339DateTimeWithOffset(output.lastUpdatedDate))
6169
- : undefined,
6170
- RouteSettings: output.routeSettings != null ? de_RouteSettingsMap(output.routeSettings, context) : undefined,
6171
- StageName: __expectString(output.stageName),
6172
- StageVariables: output.stageVariables != null ? de_StageVariablesMap(output.stageVariables, context) : undefined,
6173
- Tags: output.tags != null ? de_Tags(output.tags, context) : undefined,
6174
- };
6175
- };
6176
- const de_StageVariablesMap = (output, context) => {
6177
- return Object.entries(output).reduce((acc, [key, value]) => {
6178
- if (value === null) {
6179
- return acc;
6180
- }
6181
- acc[key] = __expectString(value);
6182
- return acc;
6183
- }, {});
6184
- };
6185
- const de_SubnetIdList = (output, context) => {
6186
- const retVal = (output || [])
6187
- .filter((e) => e != null)
6188
- .map((entry) => {
6189
- if (entry === null) {
6190
- return null;
6191
- }
6192
- return __expectString(entry);
5117
+ return take(output, {
5118
+ AccessLogSettings: (_) => [, de_AccessLogSettings(_, context), `accessLogSettings`],
5119
+ ApiGatewayManaged: [, __expectBoolean, `apiGatewayManaged`],
5120
+ AutoDeploy: [, __expectBoolean, `autoDeploy`],
5121
+ ClientCertificateId: [, __expectString, `clientCertificateId`],
5122
+ CreatedDate: (_) => [, __expectNonNull(__parseRfc3339DateTimeWithOffset(_)), `createdDate`],
5123
+ DefaultRouteSettings: (_) => [, de_RouteSettings(_, context), `defaultRouteSettings`],
5124
+ DeploymentId: [, __expectString, `deploymentId`],
5125
+ Description: [, __expectString, `description`],
5126
+ LastDeploymentStatusMessage: [, __expectString, `lastDeploymentStatusMessage`],
5127
+ LastUpdatedDate: (_) => [, __expectNonNull(__parseRfc3339DateTimeWithOffset(_)), `lastUpdatedDate`],
5128
+ RouteSettings: (_) => [, de_RouteSettingsMap(_, context), `routeSettings`],
5129
+ StageName: [, __expectString, `stageName`],
5130
+ StageVariables: [, _json, `stageVariables`],
5131
+ Tags: [, _json, `tags`],
6193
5132
  });
6194
- return retVal;
6195
- };
6196
- const de_Tags = (output, context) => {
6197
- return Object.entries(output).reduce((acc, [key, value]) => {
6198
- if (value === null) {
6199
- return acc;
6200
- }
6201
- acc[key] = __expectString(value);
6202
- return acc;
6203
- }, {});
6204
- };
6205
- const de_TemplateMap = (output, context) => {
6206
- return Object.entries(output).reduce((acc, [key, value]) => {
6207
- if (value === null) {
6208
- return acc;
6209
- }
6210
- acc[key] = __expectString(value);
6211
- return acc;
6212
- }, {});
6213
5133
  };
6214
5134
  const de_TlsConfig = (output, context) => {
6215
- return {
6216
- ServerNameToVerify: __expectString(output.serverNameToVerify),
6217
- };
5135
+ return take(output, {
5136
+ ServerNameToVerify: [, __expectString, `serverNameToVerify`],
5137
+ });
6218
5138
  };
6219
5139
  const de_VpcLink = (output, context) => {
6220
- return {
6221
- CreatedDate: output.createdDate != null ? __expectNonNull(__parseRfc3339DateTimeWithOffset(output.createdDate)) : undefined,
6222
- Name: __expectString(output.name),
6223
- SecurityGroupIds: output.securityGroupIds != null ? de_SecurityGroupIdList(output.securityGroupIds, context) : undefined,
6224
- SubnetIds: output.subnetIds != null ? de_SubnetIdList(output.subnetIds, context) : undefined,
6225
- Tags: output.tags != null ? de_Tags(output.tags, context) : undefined,
6226
- VpcLinkId: __expectString(output.vpcLinkId),
6227
- VpcLinkStatus: __expectString(output.vpcLinkStatus),
6228
- VpcLinkStatusMessage: __expectString(output.vpcLinkStatusMessage),
6229
- VpcLinkVersion: __expectString(output.vpcLinkVersion),
6230
- };
5140
+ return take(output, {
5141
+ CreatedDate: (_) => [, __expectNonNull(__parseRfc3339DateTimeWithOffset(_)), `createdDate`],
5142
+ Name: [, __expectString, `name`],
5143
+ SecurityGroupIds: [, _json, `securityGroupIds`],
5144
+ SubnetIds: [, _json, `subnetIds`],
5145
+ Tags: [, _json, `tags`],
5146
+ VpcLinkId: [, __expectString, `vpcLinkId`],
5147
+ VpcLinkStatus: [, __expectString, `vpcLinkStatus`],
5148
+ VpcLinkStatusMessage: [, __expectString, `vpcLinkStatusMessage`],
5149
+ VpcLinkVersion: [, __expectString, `vpcLinkVersion`],
5150
+ });
6231
5151
  };
6232
5152
  const deserializeMetadata = (output) => ({
6233
5153
  httpStatusCode: output.statusCode,