@aws-sdk/client-app-mesh 3.141.0 → 3.150.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 (6) hide show
  1. package/CHANGELOG.md +30 -0
  2. package/dist-cjs/endpoints.js +16 -0
  3. package/dist-cjs/protocols/Aws_restJson1.js +563 -1329
  4. package/dist-es/endpoints.js +16 -0
  5. package/dist-es/protocols/Aws_restJson1.js +711 -1278
  6. package/package.json +11 -6
package/dist-cjs/protocols/Aws_restJson1.js CHANGED
@@ -15,29 +15,11 @@ const serializeAws_restJson1CreateGatewayRouteCommand = async (input, context) =
15
15
  };
16
16
  let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` +
17
17
  "/v20190125/meshes/{meshName}/virtualGateway/{virtualGatewayName}/gatewayRoutes";
18
- if (input.meshName !== undefined) {
19
- const labelValue = input.meshName;
20
- if (labelValue.length <= 0) {
21
- throw new Error("Empty value provided for input HTTP label: meshName.");
22
- }
23
- resolvedPath = resolvedPath.replace("{meshName}", (0, smithy_client_1.extendedEncodeURIComponent)(labelValue));
24
- }
25
- else {
26
- throw new Error("No value provided for input HTTP label: meshName.");
27
- }
28
- if (input.virtualGatewayName !== undefined) {
29
- const labelValue = input.virtualGatewayName;
30
- if (labelValue.length <= 0) {
31
- throw new Error("Empty value provided for input HTTP label: virtualGatewayName.");
32
- }
33
- resolvedPath = resolvedPath.replace("{virtualGatewayName}", (0, smithy_client_1.extendedEncodeURIComponent)(labelValue));
34
- }
35
- else {
36
- throw new Error("No value provided for input HTTP label: virtualGatewayName.");
37
- }
38
- const query = {
39
- ...(input.meshOwner !== undefined && { meshOwner: input.meshOwner }),
40
- };
18
+ resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "meshName", () => input.meshName, "{meshName}", false);
19
+ resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "virtualGatewayName", () => input.virtualGatewayName, "{virtualGatewayName}", false);
20
+ const query = map({
21
+ meshOwner: [, input.meshOwner],
22
+ });
41
23
  let body;
42
24
  body = JSON.stringify({
43
25
  clientToken: (_a = input.clientToken) !== null && _a !== void 0 ? _a : (0, uuid_1.v4)(),
@@ -90,29 +72,11 @@ const serializeAws_restJson1CreateRouteCommand = async (input, context) => {
90
72
  };
91
73
  let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` +
92
74
  "/v20190125/meshes/{meshName}/virtualRouter/{virtualRouterName}/routes";
93
- if (input.meshName !== undefined) {
94
- const labelValue = input.meshName;
95
- if (labelValue.length <= 0) {
96
- throw new Error("Empty value provided for input HTTP label: meshName.");
97
- }
98
- resolvedPath = resolvedPath.replace("{meshName}", (0, smithy_client_1.extendedEncodeURIComponent)(labelValue));
99
- }
100
- else {
101
- throw new Error("No value provided for input HTTP label: meshName.");
102
- }
103
- if (input.virtualRouterName !== undefined) {
104
- const labelValue = input.virtualRouterName;
105
- if (labelValue.length <= 0) {
106
- throw new Error("Empty value provided for input HTTP label: virtualRouterName.");
107
- }
108
- resolvedPath = resolvedPath.replace("{virtualRouterName}", (0, smithy_client_1.extendedEncodeURIComponent)(labelValue));
109
- }
110
- else {
111
- throw new Error("No value provided for input HTTP label: virtualRouterName.");
112
- }
113
- const query = {
114
- ...(input.meshOwner !== undefined && { meshOwner: input.meshOwner }),
115
- };
75
+ resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "meshName", () => input.meshName, "{meshName}", false);
76
+ resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "virtualRouterName", () => input.virtualRouterName, "{virtualRouterName}", false);
77
+ const query = map({
78
+ meshOwner: [, input.meshOwner],
79
+ });
116
80
  let body;
117
81
  body = JSON.stringify({
118
82
  clientToken: (_a = input.clientToken) !== null && _a !== void 0 ? _a : (0, uuid_1.v4)(),
@@ -140,19 +104,10 @@ const serializeAws_restJson1CreateVirtualGatewayCommand = async (input, context)
140
104
  };
141
105
  let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` +
142
106
  "/v20190125/meshes/{meshName}/virtualGateways";
143
- if (input.meshName !== undefined) {
144
- const labelValue = input.meshName;
145
- if (labelValue.length <= 0) {
146
- throw new Error("Empty value provided for input HTTP label: meshName.");
147
- }
148
- resolvedPath = resolvedPath.replace("{meshName}", (0, smithy_client_1.extendedEncodeURIComponent)(labelValue));
149
- }
150
- else {
151
- throw new Error("No value provided for input HTTP label: meshName.");
152
- }
153
- const query = {
154
- ...(input.meshOwner !== undefined && { meshOwner: input.meshOwner }),
155
- };
107
+ resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "meshName", () => input.meshName, "{meshName}", false);
108
+ const query = map({
109
+ meshOwner: [, input.meshOwner],
110
+ });
156
111
  let body;
157
112
  body = JSON.stringify({
158
113
  clientToken: (_a = input.clientToken) !== null && _a !== void 0 ? _a : (0, uuid_1.v4)(),
@@ -179,19 +134,10 @@ const serializeAws_restJson1CreateVirtualNodeCommand = async (input, context) =>
179
134
  "content-type": "application/json",
180
135
  };
181
136
  let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/v20190125/meshes/{meshName}/virtualNodes";
182
- if (input.meshName !== undefined) {
183
- const labelValue = input.meshName;
184
- if (labelValue.length <= 0) {
185
- throw new Error("Empty value provided for input HTTP label: meshName.");
186
- }
187
- resolvedPath = resolvedPath.replace("{meshName}", (0, smithy_client_1.extendedEncodeURIComponent)(labelValue));
188
- }
189
- else {
190
- throw new Error("No value provided for input HTTP label: meshName.");
191
- }
192
- const query = {
193
- ...(input.meshOwner !== undefined && { meshOwner: input.meshOwner }),
194
- };
137
+ resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "meshName", () => input.meshName, "{meshName}", false);
138
+ const query = map({
139
+ meshOwner: [, input.meshOwner],
140
+ });
195
141
  let body;
196
142
  body = JSON.stringify({
197
143
  clientToken: (_a = input.clientToken) !== null && _a !== void 0 ? _a : (0, uuid_1.v4)(),
@@ -219,19 +165,10 @@ const serializeAws_restJson1CreateVirtualRouterCommand = async (input, context)
219
165
  };
220
166
  let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` +
221
167
  "/v20190125/meshes/{meshName}/virtualRouters";
222
- if (input.meshName !== undefined) {
223
- const labelValue = input.meshName;
224
- if (labelValue.length <= 0) {
225
- throw new Error("Empty value provided for input HTTP label: meshName.");
226
- }
227
- resolvedPath = resolvedPath.replace("{meshName}", (0, smithy_client_1.extendedEncodeURIComponent)(labelValue));
228
- }
229
- else {
230
- throw new Error("No value provided for input HTTP label: meshName.");
231
- }
232
- const query = {
233
- ...(input.meshOwner !== undefined && { meshOwner: input.meshOwner }),
234
- };
168
+ resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "meshName", () => input.meshName, "{meshName}", false);
169
+ const query = map({
170
+ meshOwner: [, input.meshOwner],
171
+ });
235
172
  let body;
236
173
  body = JSON.stringify({
237
174
  clientToken: (_a = input.clientToken) !== null && _a !== void 0 ? _a : (0, uuid_1.v4)(),
@@ -259,19 +196,10 @@ const serializeAws_restJson1CreateVirtualServiceCommand = async (input, context)
259
196
  };
260
197
  let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` +
261
198
  "/v20190125/meshes/{meshName}/virtualServices";
262
- if (input.meshName !== undefined) {
263
- const labelValue = input.meshName;
264
- if (labelValue.length <= 0) {
265
- throw new Error("Empty value provided for input HTTP label: meshName.");
266
- }
267
- resolvedPath = resolvedPath.replace("{meshName}", (0, smithy_client_1.extendedEncodeURIComponent)(labelValue));
268
- }
269
- else {
270
- throw new Error("No value provided for input HTTP label: meshName.");
271
- }
272
- const query = {
273
- ...(input.meshOwner !== undefined && { meshOwner: input.meshOwner }),
274
- };
199
+ resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "meshName", () => input.meshName, "{meshName}", false);
200
+ const query = map({
201
+ meshOwner: [, input.meshOwner],
202
+ });
275
203
  let body;
276
204
  body = JSON.stringify({
277
205
  clientToken: (_a = input.clientToken) !== null && _a !== void 0 ? _a : (0, uuid_1.v4)(),
@@ -296,39 +224,12 @@ const serializeAws_restJson1DeleteGatewayRouteCommand = async (input, context) =
296
224
  const headers = {};
297
225
  let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` +
298
226
  "/v20190125/meshes/{meshName}/virtualGateway/{virtualGatewayName}/gatewayRoutes/{gatewayRouteName}";
299
- if (input.gatewayRouteName !== undefined) {
300
- const labelValue = input.gatewayRouteName;
301
- if (labelValue.length <= 0) {
302
- throw new Error("Empty value provided for input HTTP label: gatewayRouteName.");
303
- }
304
- resolvedPath = resolvedPath.replace("{gatewayRouteName}", (0, smithy_client_1.extendedEncodeURIComponent)(labelValue));
305
- }
306
- else {
307
- throw new Error("No value provided for input HTTP label: gatewayRouteName.");
308
- }
309
- if (input.meshName !== undefined) {
310
- const labelValue = input.meshName;
311
- if (labelValue.length <= 0) {
312
- throw new Error("Empty value provided for input HTTP label: meshName.");
313
- }
314
- resolvedPath = resolvedPath.replace("{meshName}", (0, smithy_client_1.extendedEncodeURIComponent)(labelValue));
315
- }
316
- else {
317
- throw new Error("No value provided for input HTTP label: meshName.");
318
- }
319
- if (input.virtualGatewayName !== undefined) {
320
- const labelValue = input.virtualGatewayName;
321
- if (labelValue.length <= 0) {
322
- throw new Error("Empty value provided for input HTTP label: virtualGatewayName.");
323
- }
324
- resolvedPath = resolvedPath.replace("{virtualGatewayName}", (0, smithy_client_1.extendedEncodeURIComponent)(labelValue));
325
- }
326
- else {
327
- throw new Error("No value provided for input HTTP label: virtualGatewayName.");
328
- }
329
- const query = {
330
- ...(input.meshOwner !== undefined && { meshOwner: input.meshOwner }),
331
- };
227
+ resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "gatewayRouteName", () => input.gatewayRouteName, "{gatewayRouteName}", false);
228
+ resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "meshName", () => input.meshName, "{meshName}", false);
229
+ resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "virtualGatewayName", () => input.virtualGatewayName, "{virtualGatewayName}", false);
230
+ const query = map({
231
+ meshOwner: [, input.meshOwner],
232
+ });
332
233
  let body;
333
234
  return new protocol_http_1.HttpRequest({
334
235
  protocol,
@@ -346,16 +247,7 @@ const serializeAws_restJson1DeleteMeshCommand = async (input, context) => {
346
247
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
347
248
  const headers = {};
348
249
  let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/v20190125/meshes/{meshName}";
349
- if (input.meshName !== undefined) {
350
- const labelValue = input.meshName;
351
- if (labelValue.length <= 0) {
352
- throw new Error("Empty value provided for input HTTP label: meshName.");
353
- }
354
- resolvedPath = resolvedPath.replace("{meshName}", (0, smithy_client_1.extendedEncodeURIComponent)(labelValue));
355
- }
356
- else {
357
- throw new Error("No value provided for input HTTP label: meshName.");
358
- }
250
+ resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "meshName", () => input.meshName, "{meshName}", false);
359
251
  let body;
360
252
  return new protocol_http_1.HttpRequest({
361
253
  protocol,
@@ -373,39 +265,12 @@ const serializeAws_restJson1DeleteRouteCommand = async (input, context) => {
373
265
  const headers = {};
374
266
  let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` +
375
267
  "/v20190125/meshes/{meshName}/virtualRouter/{virtualRouterName}/routes/{routeName}";
376
- if (input.routeName !== undefined) {
377
- const labelValue = input.routeName;
378
- if (labelValue.length <= 0) {
379
- throw new Error("Empty value provided for input HTTP label: routeName.");
380
- }
381
- resolvedPath = resolvedPath.replace("{routeName}", (0, smithy_client_1.extendedEncodeURIComponent)(labelValue));
382
- }
383
- else {
384
- throw new Error("No value provided for input HTTP label: routeName.");
385
- }
386
- if (input.meshName !== undefined) {
387
- const labelValue = input.meshName;
388
- if (labelValue.length <= 0) {
389
- throw new Error("Empty value provided for input HTTP label: meshName.");
390
- }
391
- resolvedPath = resolvedPath.replace("{meshName}", (0, smithy_client_1.extendedEncodeURIComponent)(labelValue));
392
- }
393
- else {
394
- throw new Error("No value provided for input HTTP label: meshName.");
395
- }
396
- if (input.virtualRouterName !== undefined) {
397
- const labelValue = input.virtualRouterName;
398
- if (labelValue.length <= 0) {
399
- throw new Error("Empty value provided for input HTTP label: virtualRouterName.");
400
- }
401
- resolvedPath = resolvedPath.replace("{virtualRouterName}", (0, smithy_client_1.extendedEncodeURIComponent)(labelValue));
402
- }
403
- else {
404
- throw new Error("No value provided for input HTTP label: virtualRouterName.");
405
- }
406
- const query = {
407
- ...(input.meshOwner !== undefined && { meshOwner: input.meshOwner }),
408
- };
268
+ resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "routeName", () => input.routeName, "{routeName}", false);
269
+ resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "meshName", () => input.meshName, "{meshName}", false);
270
+ resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "virtualRouterName", () => input.virtualRouterName, "{virtualRouterName}", false);
271
+ const query = map({
272
+ meshOwner: [, input.meshOwner],
273
+ });
409
274
  let body;
410
275
  return new protocol_http_1.HttpRequest({
411
276
  protocol,
@@ -424,29 +289,11 @@ const serializeAws_restJson1DeleteVirtualGatewayCommand = async (input, context)
424
289
  const headers = {};
425
290
  let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` +
426
291
  "/v20190125/meshes/{meshName}/virtualGateways/{virtualGatewayName}";
427
- if (input.virtualGatewayName !== undefined) {
428
- const labelValue = input.virtualGatewayName;
429
- if (labelValue.length <= 0) {
430
- throw new Error("Empty value provided for input HTTP label: virtualGatewayName.");
431
- }
432
- resolvedPath = resolvedPath.replace("{virtualGatewayName}", (0, smithy_client_1.extendedEncodeURIComponent)(labelValue));
433
- }
434
- else {
435
- throw new Error("No value provided for input HTTP label: virtualGatewayName.");
436
- }
437
- if (input.meshName !== undefined) {
438
- const labelValue = input.meshName;
439
- if (labelValue.length <= 0) {
440
- throw new Error("Empty value provided for input HTTP label: meshName.");
441
- }
442
- resolvedPath = resolvedPath.replace("{meshName}", (0, smithy_client_1.extendedEncodeURIComponent)(labelValue));
443
- }
444
- else {
445
- throw new Error("No value provided for input HTTP label: meshName.");
446
- }
447
- const query = {
448
- ...(input.meshOwner !== undefined && { meshOwner: input.meshOwner }),
449
- };
292
+ resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "virtualGatewayName", () => input.virtualGatewayName, "{virtualGatewayName}", false);
293
+ resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "meshName", () => input.meshName, "{meshName}", false);
294
+ const query = map({
295
+ meshOwner: [, input.meshOwner],
296
+ });
450
297
  let body;
451
298
  return new protocol_http_1.HttpRequest({
452
299
  protocol,
@@ -465,29 +312,11 @@ const serializeAws_restJson1DeleteVirtualNodeCommand = async (input, context) =>
465
312
  const headers = {};
466
313
  let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` +
467
314
  "/v20190125/meshes/{meshName}/virtualNodes/{virtualNodeName}";
468
- if (input.virtualNodeName !== undefined) {
469
- const labelValue = input.virtualNodeName;
470
- if (labelValue.length <= 0) {
471
- throw new Error("Empty value provided for input HTTP label: virtualNodeName.");
472
- }
473
- resolvedPath = resolvedPath.replace("{virtualNodeName}", (0, smithy_client_1.extendedEncodeURIComponent)(labelValue));
474
- }
475
- else {
476
- throw new Error("No value provided for input HTTP label: virtualNodeName.");
477
- }
478
- if (input.meshName !== undefined) {
479
- const labelValue = input.meshName;
480
- if (labelValue.length <= 0) {
481
- throw new Error("Empty value provided for input HTTP label: meshName.");
482
- }
483
- resolvedPath = resolvedPath.replace("{meshName}", (0, smithy_client_1.extendedEncodeURIComponent)(labelValue));
484
- }
485
- else {
486
- throw new Error("No value provided for input HTTP label: meshName.");
487
- }
488
- const query = {
489
- ...(input.meshOwner !== undefined && { meshOwner: input.meshOwner }),
490
- };
315
+ resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "virtualNodeName", () => input.virtualNodeName, "{virtualNodeName}", false);
316
+ resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "meshName", () => input.meshName, "{meshName}", false);
317
+ const query = map({
318
+ meshOwner: [, input.meshOwner],
319
+ });
491
320
  let body;
492
321
  return new protocol_http_1.HttpRequest({
493
322
  protocol,
@@ -506,29 +335,11 @@ const serializeAws_restJson1DeleteVirtualRouterCommand = async (input, context)
506
335
  const headers = {};
507
336
  let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` +
508
337
  "/v20190125/meshes/{meshName}/virtualRouters/{virtualRouterName}";
509
- if (input.virtualRouterName !== undefined) {
510
- const labelValue = input.virtualRouterName;
511
- if (labelValue.length <= 0) {
512
- throw new Error("Empty value provided for input HTTP label: virtualRouterName.");
513
- }
514
- resolvedPath = resolvedPath.replace("{virtualRouterName}", (0, smithy_client_1.extendedEncodeURIComponent)(labelValue));
515
- }
516
- else {
517
- throw new Error("No value provided for input HTTP label: virtualRouterName.");
518
- }
519
- if (input.meshName !== undefined) {
520
- const labelValue = input.meshName;
521
- if (labelValue.length <= 0) {
522
- throw new Error("Empty value provided for input HTTP label: meshName.");
523
- }
524
- resolvedPath = resolvedPath.replace("{meshName}", (0, smithy_client_1.extendedEncodeURIComponent)(labelValue));
525
- }
526
- else {
527
- throw new Error("No value provided for input HTTP label: meshName.");
528
- }
529
- const query = {
530
- ...(input.meshOwner !== undefined && { meshOwner: input.meshOwner }),
531
- };
338
+ resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "virtualRouterName", () => input.virtualRouterName, "{virtualRouterName}", false);
339
+ resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "meshName", () => input.meshName, "{meshName}", false);
340
+ const query = map({
341
+ meshOwner: [, input.meshOwner],
342
+ });
532
343
  let body;
533
344
  return new protocol_http_1.HttpRequest({
534
345
  protocol,
@@ -547,29 +358,11 @@ const serializeAws_restJson1DeleteVirtualServiceCommand = async (input, context)
547
358
  const headers = {};
548
359
  let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` +
549
360
  "/v20190125/meshes/{meshName}/virtualServices/{virtualServiceName}";
550
- if (input.virtualServiceName !== undefined) {
551
- const labelValue = input.virtualServiceName;
552
- if (labelValue.length <= 0) {
553
- throw new Error("Empty value provided for input HTTP label: virtualServiceName.");
554
- }
555
- resolvedPath = resolvedPath.replace("{virtualServiceName}", (0, smithy_client_1.extendedEncodeURIComponent)(labelValue));
556
- }
557
- else {
558
- throw new Error("No value provided for input HTTP label: virtualServiceName.");
559
- }
560
- if (input.meshName !== undefined) {
561
- const labelValue = input.meshName;
562
- if (labelValue.length <= 0) {
563
- throw new Error("Empty value provided for input HTTP label: meshName.");
564
- }
565
- resolvedPath = resolvedPath.replace("{meshName}", (0, smithy_client_1.extendedEncodeURIComponent)(labelValue));
566
- }
567
- else {
568
- throw new Error("No value provided for input HTTP label: meshName.");
569
- }
570
- const query = {
571
- ...(input.meshOwner !== undefined && { meshOwner: input.meshOwner }),
572
- };
361
+ resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "virtualServiceName", () => input.virtualServiceName, "{virtualServiceName}", false);
362
+ resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "meshName", () => input.meshName, "{meshName}", false);
363
+ const query = map({
364
+ meshOwner: [, input.meshOwner],
365
+ });
573
366
  let body;
574
367
  return new protocol_http_1.HttpRequest({
575
368
  protocol,
@@ -588,39 +381,12 @@ const serializeAws_restJson1DescribeGatewayRouteCommand = async (input, context)
588
381
  const headers = {};
589
382
  let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` +
590
383
  "/v20190125/meshes/{meshName}/virtualGateway/{virtualGatewayName}/gatewayRoutes/{gatewayRouteName}";
591
- if (input.gatewayRouteName !== undefined) {
592
- const labelValue = input.gatewayRouteName;
593
- if (labelValue.length <= 0) {
594
- throw new Error("Empty value provided for input HTTP label: gatewayRouteName.");
595
- }
596
- resolvedPath = resolvedPath.replace("{gatewayRouteName}", (0, smithy_client_1.extendedEncodeURIComponent)(labelValue));
597
- }
598
- else {
599
- throw new Error("No value provided for input HTTP label: gatewayRouteName.");
600
- }
601
- if (input.meshName !== undefined) {
602
- const labelValue = input.meshName;
603
- if (labelValue.length <= 0) {
604
- throw new Error("Empty value provided for input HTTP label: meshName.");
605
- }
606
- resolvedPath = resolvedPath.replace("{meshName}", (0, smithy_client_1.extendedEncodeURIComponent)(labelValue));
607
- }
608
- else {
609
- throw new Error("No value provided for input HTTP label: meshName.");
610
- }
611
- if (input.virtualGatewayName !== undefined) {
612
- const labelValue = input.virtualGatewayName;
613
- if (labelValue.length <= 0) {
614
- throw new Error("Empty value provided for input HTTP label: virtualGatewayName.");
615
- }
616
- resolvedPath = resolvedPath.replace("{virtualGatewayName}", (0, smithy_client_1.extendedEncodeURIComponent)(labelValue));
617
- }
618
- else {
619
- throw new Error("No value provided for input HTTP label: virtualGatewayName.");
620
- }
621
- const query = {
622
- ...(input.meshOwner !== undefined && { meshOwner: input.meshOwner }),
623
- };
384
+ resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "gatewayRouteName", () => input.gatewayRouteName, "{gatewayRouteName}", false);
385
+ resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "meshName", () => input.meshName, "{meshName}", false);
386
+ resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "virtualGatewayName", () => input.virtualGatewayName, "{virtualGatewayName}", false);
387
+ const query = map({
388
+ meshOwner: [, input.meshOwner],
389
+ });
624
390
  let body;
625
391
  return new protocol_http_1.HttpRequest({
626
392
  protocol,
@@ -638,19 +404,10 @@ const serializeAws_restJson1DescribeMeshCommand = async (input, context) => {
638
404
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
639
405
  const headers = {};
640
406
  let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/v20190125/meshes/{meshName}";
641
- if (input.meshName !== undefined) {
642
- const labelValue = input.meshName;
643
- if (labelValue.length <= 0) {
644
- throw new Error("Empty value provided for input HTTP label: meshName.");
645
- }
646
- resolvedPath = resolvedPath.replace("{meshName}", (0, smithy_client_1.extendedEncodeURIComponent)(labelValue));
647
- }
648
- else {
649
- throw new Error("No value provided for input HTTP label: meshName.");
650
- }
651
- const query = {
652
- ...(input.meshOwner !== undefined && { meshOwner: input.meshOwner }),
653
- };
407
+ resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "meshName", () => input.meshName, "{meshName}", false);
408
+ const query = map({
409
+ meshOwner: [, input.meshOwner],
410
+ });
654
411
  let body;
655
412
  return new protocol_http_1.HttpRequest({
656
413
  protocol,
@@ -669,39 +426,12 @@ const serializeAws_restJson1DescribeRouteCommand = async (input, context) => {
669
426
  const headers = {};
670
427
  let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` +
671
428
  "/v20190125/meshes/{meshName}/virtualRouter/{virtualRouterName}/routes/{routeName}";
672
- if (input.routeName !== undefined) {
673
- const labelValue = input.routeName;
674
- if (labelValue.length <= 0) {
675
- throw new Error("Empty value provided for input HTTP label: routeName.");
676
- }
677
- resolvedPath = resolvedPath.replace("{routeName}", (0, smithy_client_1.extendedEncodeURIComponent)(labelValue));
678
- }
679
- else {
680
- throw new Error("No value provided for input HTTP label: routeName.");
681
- }
682
- if (input.meshName !== undefined) {
683
- const labelValue = input.meshName;
684
- if (labelValue.length <= 0) {
685
- throw new Error("Empty value provided for input HTTP label: meshName.");
686
- }
687
- resolvedPath = resolvedPath.replace("{meshName}", (0, smithy_client_1.extendedEncodeURIComponent)(labelValue));
688
- }
689
- else {
690
- throw new Error("No value provided for input HTTP label: meshName.");
691
- }
692
- if (input.virtualRouterName !== undefined) {
693
- const labelValue = input.virtualRouterName;
694
- if (labelValue.length <= 0) {
695
- throw new Error("Empty value provided for input HTTP label: virtualRouterName.");
696
- }
697
- resolvedPath = resolvedPath.replace("{virtualRouterName}", (0, smithy_client_1.extendedEncodeURIComponent)(labelValue));
698
- }
699
- else {
700
- throw new Error("No value provided for input HTTP label: virtualRouterName.");
701
- }
702
- const query = {
703
- ...(input.meshOwner !== undefined && { meshOwner: input.meshOwner }),
704
- };
429
+ resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "routeName", () => input.routeName, "{routeName}", false);
430
+ resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "meshName", () => input.meshName, "{meshName}", false);
431
+ resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "virtualRouterName", () => input.virtualRouterName, "{virtualRouterName}", false);
432
+ const query = map({
433
+ meshOwner: [, input.meshOwner],
434
+ });
705
435
  let body;
706
436
  return new protocol_http_1.HttpRequest({
707
437
  protocol,
@@ -720,29 +450,11 @@ const serializeAws_restJson1DescribeVirtualGatewayCommand = async (input, contex
720
450
  const headers = {};
721
451
  let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` +
722
452
  "/v20190125/meshes/{meshName}/virtualGateways/{virtualGatewayName}";
723
- if (input.virtualGatewayName !== undefined) {
724
- const labelValue = input.virtualGatewayName;
725
- if (labelValue.length <= 0) {
726
- throw new Error("Empty value provided for input HTTP label: virtualGatewayName.");
727
- }
728
- resolvedPath = resolvedPath.replace("{virtualGatewayName}", (0, smithy_client_1.extendedEncodeURIComponent)(labelValue));
729
- }
730
- else {
731
- throw new Error("No value provided for input HTTP label: virtualGatewayName.");
732
- }
733
- if (input.meshName !== undefined) {
734
- const labelValue = input.meshName;
735
- if (labelValue.length <= 0) {
736
- throw new Error("Empty value provided for input HTTP label: meshName.");
737
- }
738
- resolvedPath = resolvedPath.replace("{meshName}", (0, smithy_client_1.extendedEncodeURIComponent)(labelValue));
739
- }
740
- else {
741
- throw new Error("No value provided for input HTTP label: meshName.");
742
- }
743
- const query = {
744
- ...(input.meshOwner !== undefined && { meshOwner: input.meshOwner }),
745
- };
453
+ resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "virtualGatewayName", () => input.virtualGatewayName, "{virtualGatewayName}", false);
454
+ resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "meshName", () => input.meshName, "{meshName}", false);
455
+ const query = map({
456
+ meshOwner: [, input.meshOwner],
457
+ });
746
458
  let body;
747
459
  return new protocol_http_1.HttpRequest({
748
460
  protocol,
@@ -761,29 +473,11 @@ const serializeAws_restJson1DescribeVirtualNodeCommand = async (input, context)
761
473
  const headers = {};
762
474
  let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` +
763
475
  "/v20190125/meshes/{meshName}/virtualNodes/{virtualNodeName}";
764
- if (input.virtualNodeName !== undefined) {
765
- const labelValue = input.virtualNodeName;
766
- if (labelValue.length <= 0) {
767
- throw new Error("Empty value provided for input HTTP label: virtualNodeName.");
768
- }
769
- resolvedPath = resolvedPath.replace("{virtualNodeName}", (0, smithy_client_1.extendedEncodeURIComponent)(labelValue));
770
- }
771
- else {
772
- throw new Error("No value provided for input HTTP label: virtualNodeName.");
773
- }
774
- if (input.meshName !== undefined) {
775
- const labelValue = input.meshName;
776
- if (labelValue.length <= 0) {
777
- throw new Error("Empty value provided for input HTTP label: meshName.");
778
- }
779
- resolvedPath = resolvedPath.replace("{meshName}", (0, smithy_client_1.extendedEncodeURIComponent)(labelValue));
780
- }
781
- else {
782
- throw new Error("No value provided for input HTTP label: meshName.");
783
- }
784
- const query = {
785
- ...(input.meshOwner !== undefined && { meshOwner: input.meshOwner }),
786
- };
476
+ resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "virtualNodeName", () => input.virtualNodeName, "{virtualNodeName}", false);
477
+ resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "meshName", () => input.meshName, "{meshName}", false);
478
+ const query = map({
479
+ meshOwner: [, input.meshOwner],
480
+ });
787
481
  let body;
788
482
  return new protocol_http_1.HttpRequest({
789
483
  protocol,
@@ -802,29 +496,11 @@ const serializeAws_restJson1DescribeVirtualRouterCommand = async (input, context
802
496
  const headers = {};
803
497
  let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` +
804
498
  "/v20190125/meshes/{meshName}/virtualRouters/{virtualRouterName}";
805
- if (input.virtualRouterName !== undefined) {
806
- const labelValue = input.virtualRouterName;
807
- if (labelValue.length <= 0) {
808
- throw new Error("Empty value provided for input HTTP label: virtualRouterName.");
809
- }
810
- resolvedPath = resolvedPath.replace("{virtualRouterName}", (0, smithy_client_1.extendedEncodeURIComponent)(labelValue));
811
- }
812
- else {
813
- throw new Error("No value provided for input HTTP label: virtualRouterName.");
814
- }
815
- if (input.meshName !== undefined) {
816
- const labelValue = input.meshName;
817
- if (labelValue.length <= 0) {
818
- throw new Error("Empty value provided for input HTTP label: meshName.");
819
- }
820
- resolvedPath = resolvedPath.replace("{meshName}", (0, smithy_client_1.extendedEncodeURIComponent)(labelValue));
821
- }
822
- else {
823
- throw new Error("No value provided for input HTTP label: meshName.");
824
- }
825
- const query = {
826
- ...(input.meshOwner !== undefined && { meshOwner: input.meshOwner }),
827
- };
499
+ resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "virtualRouterName", () => input.virtualRouterName, "{virtualRouterName}", false);
500
+ resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "meshName", () => input.meshName, "{meshName}", false);
501
+ const query = map({
502
+ meshOwner: [, input.meshOwner],
503
+ });
828
504
  let body;
829
505
  return new protocol_http_1.HttpRequest({
830
506
  protocol,
@@ -843,29 +519,11 @@ const serializeAws_restJson1DescribeVirtualServiceCommand = async (input, contex
843
519
  const headers = {};
844
520
  let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` +
845
521
  "/v20190125/meshes/{meshName}/virtualServices/{virtualServiceName}";
846
- if (input.virtualServiceName !== undefined) {
847
- const labelValue = input.virtualServiceName;
848
- if (labelValue.length <= 0) {
849
- throw new Error("Empty value provided for input HTTP label: virtualServiceName.");
850
- }
851
- resolvedPath = resolvedPath.replace("{virtualServiceName}", (0, smithy_client_1.extendedEncodeURIComponent)(labelValue));
852
- }
853
- else {
854
- throw new Error("No value provided for input HTTP label: virtualServiceName.");
855
- }
856
- if (input.meshName !== undefined) {
857
- const labelValue = input.meshName;
858
- if (labelValue.length <= 0) {
859
- throw new Error("Empty value provided for input HTTP label: meshName.");
860
- }
861
- resolvedPath = resolvedPath.replace("{meshName}", (0, smithy_client_1.extendedEncodeURIComponent)(labelValue));
862
- }
863
- else {
864
- throw new Error("No value provided for input HTTP label: meshName.");
865
- }
866
- const query = {
867
- ...(input.meshOwner !== undefined && { meshOwner: input.meshOwner }),
868
- };
522
+ resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "virtualServiceName", () => input.virtualServiceName, "{virtualServiceName}", false);
523
+ resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "meshName", () => input.meshName, "{meshName}", false);
524
+ const query = map({
525
+ meshOwner: [, input.meshOwner],
526
+ });
869
527
  let body;
870
528
  return new protocol_http_1.HttpRequest({
871
529
  protocol,
@@ -884,31 +542,13 @@ const serializeAws_restJson1ListGatewayRoutesCommand = async (input, context) =>
884
542
  const headers = {};
885
543
  let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` +
886
544
  "/v20190125/meshes/{meshName}/virtualGateway/{virtualGatewayName}/gatewayRoutes";
887
- if (input.meshName !== undefined) {
888
- const labelValue = input.meshName;
889
- if (labelValue.length <= 0) {
890
- throw new Error("Empty value provided for input HTTP label: meshName.");
891
- }
892
- resolvedPath = resolvedPath.replace("{meshName}", (0, smithy_client_1.extendedEncodeURIComponent)(labelValue));
893
- }
894
- else {
895
- throw new Error("No value provided for input HTTP label: meshName.");
896
- }
897
- if (input.virtualGatewayName !== undefined) {
898
- const labelValue = input.virtualGatewayName;
899
- if (labelValue.length <= 0) {
900
- throw new Error("Empty value provided for input HTTP label: virtualGatewayName.");
901
- }
902
- resolvedPath = resolvedPath.replace("{virtualGatewayName}", (0, smithy_client_1.extendedEncodeURIComponent)(labelValue));
903
- }
904
- else {
905
- throw new Error("No value provided for input HTTP label: virtualGatewayName.");
906
- }
907
- const query = {
908
- ...(input.nextToken !== undefined && { nextToken: input.nextToken }),
909
- ...(input.limit !== undefined && { limit: input.limit.toString() }),
910
- ...(input.meshOwner !== undefined && { meshOwner: input.meshOwner }),
911
- };
545
+ resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "meshName", () => input.meshName, "{meshName}", false);
546
+ resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "virtualGatewayName", () => input.virtualGatewayName, "{virtualGatewayName}", false);
547
+ const query = map({
548
+ nextToken: [, input.nextToken],
549
+ limit: [() => input.limit !== void 0, () => input.limit.toString()],
550
+ meshOwner: [, input.meshOwner],
551
+ });
912
552
  let body;
913
553
  return new protocol_http_1.HttpRequest({
914
554
  protocol,
@@ -926,10 +566,10 @@ const serializeAws_restJson1ListMeshesCommand = async (input, context) => {
926
566
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
927
567
  const headers = {};
928
568
  const resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/v20190125/meshes";
929
- const query = {
930
- ...(input.nextToken !== undefined && { nextToken: input.nextToken }),
931
- ...(input.limit !== undefined && { limit: input.limit.toString() }),
932
- };
569
+ const query = map({
570
+ nextToken: [, input.nextToken],
571
+ limit: [() => input.limit !== void 0, () => input.limit.toString()],
572
+ });
933
573
  let body;
934
574
  return new protocol_http_1.HttpRequest({
935
575
  protocol,
@@ -948,31 +588,13 @@ const serializeAws_restJson1ListRoutesCommand = async (input, context) => {
948
588
  const headers = {};
949
589
  let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` +
950
590
  "/v20190125/meshes/{meshName}/virtualRouter/{virtualRouterName}/routes";
951
- if (input.meshName !== undefined) {
952
- const labelValue = input.meshName;
953
- if (labelValue.length <= 0) {
954
- throw new Error("Empty value provided for input HTTP label: meshName.");
955
- }
956
- resolvedPath = resolvedPath.replace("{meshName}", (0, smithy_client_1.extendedEncodeURIComponent)(labelValue));
957
- }
958
- else {
959
- throw new Error("No value provided for input HTTP label: meshName.");
960
- }
961
- if (input.virtualRouterName !== undefined) {
962
- const labelValue = input.virtualRouterName;
963
- if (labelValue.length <= 0) {
964
- throw new Error("Empty value provided for input HTTP label: virtualRouterName.");
965
- }
966
- resolvedPath = resolvedPath.replace("{virtualRouterName}", (0, smithy_client_1.extendedEncodeURIComponent)(labelValue));
967
- }
968
- else {
969
- throw new Error("No value provided for input HTTP label: virtualRouterName.");
970
- }
971
- const query = {
972
- ...(input.nextToken !== undefined && { nextToken: input.nextToken }),
973
- ...(input.limit !== undefined && { limit: input.limit.toString() }),
974
- ...(input.meshOwner !== undefined && { meshOwner: input.meshOwner }),
975
- };
591
+ resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "meshName", () => input.meshName, "{meshName}", false);
592
+ resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "virtualRouterName", () => input.virtualRouterName, "{virtualRouterName}", false);
593
+ const query = map({
594
+ nextToken: [, input.nextToken],
595
+ limit: [() => input.limit !== void 0, () => input.limit.toString()],
596
+ meshOwner: [, input.meshOwner],
597
+ });
976
598
  let body;
977
599
  return new protocol_http_1.HttpRequest({
978
600
  protocol,
@@ -990,11 +612,11 @@ const serializeAws_restJson1ListTagsForResourceCommand = async (input, context)
990
612
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
991
613
  const headers = {};
992
614
  const resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/v20190125/tags";
993
- const query = {
994
- ...(input.resourceArn !== undefined && { resourceArn: input.resourceArn }),
995
- ...(input.nextToken !== undefined && { nextToken: input.nextToken }),
996
- ...(input.limit !== undefined && { limit: input.limit.toString() }),
997
- };
615
+ const query = map({
616
+ resourceArn: [, input.resourceArn],
617
+ nextToken: [, input.nextToken],
618
+ limit: [() => input.limit !== void 0, () => input.limit.toString()],
619
+ });
998
620
  let body;
999
621
  return new protocol_http_1.HttpRequest({
1000
622
  protocol,
@@ -1013,21 +635,12 @@ const serializeAws_restJson1ListVirtualGatewaysCommand = async (input, context)
1013
635
  const headers = {};
1014
636
  let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` +
1015
637
  "/v20190125/meshes/{meshName}/virtualGateways";
1016
- if (input.meshName !== undefined) {
1017
- const labelValue = input.meshName;
1018
- if (labelValue.length <= 0) {
1019
- throw new Error("Empty value provided for input HTTP label: meshName.");
1020
- }
1021
- resolvedPath = resolvedPath.replace("{meshName}", (0, smithy_client_1.extendedEncodeURIComponent)(labelValue));
1022
- }
1023
- else {
1024
- throw new Error("No value provided for input HTTP label: meshName.");
1025
- }
1026
- const query = {
1027
- ...(input.nextToken !== undefined && { nextToken: input.nextToken }),
1028
- ...(input.limit !== undefined && { limit: input.limit.toString() }),
1029
- ...(input.meshOwner !== undefined && { meshOwner: input.meshOwner }),
1030
- };
638
+ resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "meshName", () => input.meshName, "{meshName}", false);
639
+ const query = map({
640
+ nextToken: [, input.nextToken],
641
+ limit: [() => input.limit !== void 0, () => input.limit.toString()],
642
+ meshOwner: [, input.meshOwner],
643
+ });
1031
644
  let body;
1032
645
  return new protocol_http_1.HttpRequest({
1033
646
  protocol,
@@ -1045,21 +658,12 @@ const serializeAws_restJson1ListVirtualNodesCommand = async (input, context) =>
1045
658
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1046
659
  const headers = {};
1047
660
  let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/v20190125/meshes/{meshName}/virtualNodes";
1048
- if (input.meshName !== undefined) {
1049
- const labelValue = input.meshName;
1050
- if (labelValue.length <= 0) {
1051
- throw new Error("Empty value provided for input HTTP label: meshName.");
1052
- }
1053
- resolvedPath = resolvedPath.replace("{meshName}", (0, smithy_client_1.extendedEncodeURIComponent)(labelValue));
1054
- }
1055
- else {
1056
- throw new Error("No value provided for input HTTP label: meshName.");
1057
- }
1058
- const query = {
1059
- ...(input.nextToken !== undefined && { nextToken: input.nextToken }),
1060
- ...(input.limit !== undefined && { limit: input.limit.toString() }),
1061
- ...(input.meshOwner !== undefined && { meshOwner: input.meshOwner }),
1062
- };
661
+ resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "meshName", () => input.meshName, "{meshName}", false);
662
+ const query = map({
663
+ nextToken: [, input.nextToken],
664
+ limit: [() => input.limit !== void 0, () => input.limit.toString()],
665
+ meshOwner: [, input.meshOwner],
666
+ });
1063
667
  let body;
1064
668
  return new protocol_http_1.HttpRequest({
1065
669
  protocol,
@@ -1078,21 +682,12 @@ const serializeAws_restJson1ListVirtualRoutersCommand = async (input, context) =
1078
682
  const headers = {};
1079
683
  let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` +
1080
684
  "/v20190125/meshes/{meshName}/virtualRouters";
1081
- if (input.meshName !== undefined) {
1082
- const labelValue = input.meshName;
1083
- if (labelValue.length <= 0) {
1084
- throw new Error("Empty value provided for input HTTP label: meshName.");
1085
- }
1086
- resolvedPath = resolvedPath.replace("{meshName}", (0, smithy_client_1.extendedEncodeURIComponent)(labelValue));
1087
- }
1088
- else {
1089
- throw new Error("No value provided for input HTTP label: meshName.");
1090
- }
1091
- const query = {
1092
- ...(input.nextToken !== undefined && { nextToken: input.nextToken }),
1093
- ...(input.limit !== undefined && { limit: input.limit.toString() }),
1094
- ...(input.meshOwner !== undefined && { meshOwner: input.meshOwner }),
1095
- };
685
+ resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "meshName", () => input.meshName, "{meshName}", false);
686
+ const query = map({
687
+ nextToken: [, input.nextToken],
688
+ limit: [() => input.limit !== void 0, () => input.limit.toString()],
689
+ meshOwner: [, input.meshOwner],
690
+ });
1096
691
  let body;
1097
692
  return new protocol_http_1.HttpRequest({
1098
693
  protocol,
@@ -1111,21 +706,12 @@ const serializeAws_restJson1ListVirtualServicesCommand = async (input, context)
1111
706
  const headers = {};
1112
707
  let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` +
1113
708
  "/v20190125/meshes/{meshName}/virtualServices";
1114
- if (input.meshName !== undefined) {
1115
- const labelValue = input.meshName;
1116
- if (labelValue.length <= 0) {
1117
- throw new Error("Empty value provided for input HTTP label: meshName.");
1118
- }
1119
- resolvedPath = resolvedPath.replace("{meshName}", (0, smithy_client_1.extendedEncodeURIComponent)(labelValue));
1120
- }
1121
- else {
1122
- throw new Error("No value provided for input HTTP label: meshName.");
1123
- }
1124
- const query = {
1125
- ...(input.nextToken !== undefined && { nextToken: input.nextToken }),
1126
- ...(input.limit !== undefined && { limit: input.limit.toString() }),
1127
- ...(input.meshOwner !== undefined && { meshOwner: input.meshOwner }),
1128
- };
709
+ resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "meshName", () => input.meshName, "{meshName}", false);
710
+ const query = map({
711
+ nextToken: [, input.nextToken],
712
+ limit: [() => input.limit !== void 0, () => input.limit.toString()],
713
+ meshOwner: [, input.meshOwner],
714
+ });
1129
715
  let body;
1130
716
  return new protocol_http_1.HttpRequest({
1131
717
  protocol,
@@ -1145,9 +731,9 @@ const serializeAws_restJson1TagResourceCommand = async (input, context) => {
1145
731
  "content-type": "application/json",
1146
732
  };
1147
733
  const resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/v20190125/tag";
1148
- const query = {
1149
- ...(input.resourceArn !== undefined && { resourceArn: input.resourceArn }),
1150
- };
734
+ const query = map({
735
+ resourceArn: [, input.resourceArn],
736
+ });
1151
737
  let body;
1152
738
  body = JSON.stringify({
1153
739
  ...(input.tags != null && { tags: serializeAws_restJson1TagList(input.tags, context) }),
@@ -1170,9 +756,9 @@ const serializeAws_restJson1UntagResourceCommand = async (input, context) => {
1170
756
  "content-type": "application/json",
1171
757
  };
1172
758
  const resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/v20190125/untag";
1173
- const query = {
1174
- ...(input.resourceArn !== undefined && { resourceArn: input.resourceArn }),
1175
- };
759
+ const query = map({
760
+ resourceArn: [, input.resourceArn],
761
+ });
1176
762
  let body;
1177
763
  body = JSON.stringify({
1178
764
  ...(input.tagKeys != null && { tagKeys: serializeAws_restJson1TagKeyList(input.tagKeys, context) }),
@@ -1197,39 +783,12 @@ const serializeAws_restJson1UpdateGatewayRouteCommand = async (input, context) =
1197
783
  };
1198
784
  let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` +
1199
785
  "/v20190125/meshes/{meshName}/virtualGateway/{virtualGatewayName}/gatewayRoutes/{gatewayRouteName}";
1200
- if (input.gatewayRouteName !== undefined) {
1201
- const labelValue = input.gatewayRouteName;
1202
- if (labelValue.length <= 0) {
1203
- throw new Error("Empty value provided for input HTTP label: gatewayRouteName.");
1204
- }
1205
- resolvedPath = resolvedPath.replace("{gatewayRouteName}", (0, smithy_client_1.extendedEncodeURIComponent)(labelValue));
1206
- }
1207
- else {
1208
- throw new Error("No value provided for input HTTP label: gatewayRouteName.");
1209
- }
1210
- if (input.meshName !== undefined) {
1211
- const labelValue = input.meshName;
1212
- if (labelValue.length <= 0) {
1213
- throw new Error("Empty value provided for input HTTP label: meshName.");
1214
- }
1215
- resolvedPath = resolvedPath.replace("{meshName}", (0, smithy_client_1.extendedEncodeURIComponent)(labelValue));
1216
- }
1217
- else {
1218
- throw new Error("No value provided for input HTTP label: meshName.");
1219
- }
1220
- if (input.virtualGatewayName !== undefined) {
1221
- const labelValue = input.virtualGatewayName;
1222
- if (labelValue.length <= 0) {
1223
- throw new Error("Empty value provided for input HTTP label: virtualGatewayName.");
1224
- }
1225
- resolvedPath = resolvedPath.replace("{virtualGatewayName}", (0, smithy_client_1.extendedEncodeURIComponent)(labelValue));
1226
- }
1227
- else {
1228
- throw new Error("No value provided for input HTTP label: virtualGatewayName.");
1229
- }
1230
- const query = {
1231
- ...(input.meshOwner !== undefined && { meshOwner: input.meshOwner }),
1232
- };
786
+ resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "gatewayRouteName", () => input.gatewayRouteName, "{gatewayRouteName}", false);
787
+ resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "meshName", () => input.meshName, "{meshName}", false);
788
+ resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "virtualGatewayName", () => input.virtualGatewayName, "{virtualGatewayName}", false);
789
+ const query = map({
790
+ meshOwner: [, input.meshOwner],
791
+ });
1233
792
  let body;
1234
793
  body = JSON.stringify({
1235
794
  clientToken: (_a = input.clientToken) !== null && _a !== void 0 ? _a : (0, uuid_1.v4)(),
@@ -1254,16 +813,7 @@ const serializeAws_restJson1UpdateMeshCommand = async (input, context) => {
1254
813
  "content-type": "application/json",
1255
814
  };
1256
815
  let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/v20190125/meshes/{meshName}";
1257
- if (input.meshName !== undefined) {
1258
- const labelValue = input.meshName;
1259
- if (labelValue.length <= 0) {
1260
- throw new Error("Empty value provided for input HTTP label: meshName.");
1261
- }
1262
- resolvedPath = resolvedPath.replace("{meshName}", (0, smithy_client_1.extendedEncodeURIComponent)(labelValue));
1263
- }
1264
- else {
1265
- throw new Error("No value provided for input HTTP label: meshName.");
1266
- }
816
+ resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "meshName", () => input.meshName, "{meshName}", false);
1267
817
  let body;
1268
818
  body = JSON.stringify({
1269
819
  clientToken: (_a = input.clientToken) !== null && _a !== void 0 ? _a : (0, uuid_1.v4)(),
@@ -1288,39 +838,12 @@ const serializeAws_restJson1UpdateRouteCommand = async (input, context) => {
1288
838
  };
1289
839
  let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` +
1290
840
  "/v20190125/meshes/{meshName}/virtualRouter/{virtualRouterName}/routes/{routeName}";
1291
- if (input.routeName !== undefined) {
1292
- const labelValue = input.routeName;
1293
- if (labelValue.length <= 0) {
1294
- throw new Error("Empty value provided for input HTTP label: routeName.");
1295
- }
1296
- resolvedPath = resolvedPath.replace("{routeName}", (0, smithy_client_1.extendedEncodeURIComponent)(labelValue));
1297
- }
1298
- else {
1299
- throw new Error("No value provided for input HTTP label: routeName.");
1300
- }
1301
- if (input.meshName !== undefined) {
1302
- const labelValue = input.meshName;
1303
- if (labelValue.length <= 0) {
1304
- throw new Error("Empty value provided for input HTTP label: meshName.");
1305
- }
1306
- resolvedPath = resolvedPath.replace("{meshName}", (0, smithy_client_1.extendedEncodeURIComponent)(labelValue));
1307
- }
1308
- else {
1309
- throw new Error("No value provided for input HTTP label: meshName.");
1310
- }
1311
- if (input.virtualRouterName !== undefined) {
1312
- const labelValue = input.virtualRouterName;
1313
- if (labelValue.length <= 0) {
1314
- throw new Error("Empty value provided for input HTTP label: virtualRouterName.");
1315
- }
1316
- resolvedPath = resolvedPath.replace("{virtualRouterName}", (0, smithy_client_1.extendedEncodeURIComponent)(labelValue));
1317
- }
1318
- else {
1319
- throw new Error("No value provided for input HTTP label: virtualRouterName.");
1320
- }
1321
- const query = {
1322
- ...(input.meshOwner !== undefined && { meshOwner: input.meshOwner }),
1323
- };
841
+ resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "routeName", () => input.routeName, "{routeName}", false);
842
+ resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "meshName", () => input.meshName, "{meshName}", false);
843
+ resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "virtualRouterName", () => input.virtualRouterName, "{virtualRouterName}", false);
844
+ const query = map({
845
+ meshOwner: [, input.meshOwner],
846
+ });
1324
847
  let body;
1325
848
  body = JSON.stringify({
1326
849
  clientToken: (_a = input.clientToken) !== null && _a !== void 0 ? _a : (0, uuid_1.v4)(),
@@ -1346,29 +869,11 @@ const serializeAws_restJson1UpdateVirtualGatewayCommand = async (input, context)
1346
869
  };
1347
870
  let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` +
1348
871
  "/v20190125/meshes/{meshName}/virtualGateways/{virtualGatewayName}";
1349
- if (input.virtualGatewayName !== undefined) {
1350
- const labelValue = input.virtualGatewayName;
1351
- if (labelValue.length <= 0) {
1352
- throw new Error("Empty value provided for input HTTP label: virtualGatewayName.");
1353
- }
1354
- resolvedPath = resolvedPath.replace("{virtualGatewayName}", (0, smithy_client_1.extendedEncodeURIComponent)(labelValue));
1355
- }
1356
- else {
1357
- throw new Error("No value provided for input HTTP label: virtualGatewayName.");
1358
- }
1359
- if (input.meshName !== undefined) {
1360
- const labelValue = input.meshName;
1361
- if (labelValue.length <= 0) {
1362
- throw new Error("Empty value provided for input HTTP label: meshName.");
1363
- }
1364
- resolvedPath = resolvedPath.replace("{meshName}", (0, smithy_client_1.extendedEncodeURIComponent)(labelValue));
1365
- }
1366
- else {
1367
- throw new Error("No value provided for input HTTP label: meshName.");
1368
- }
1369
- const query = {
1370
- ...(input.meshOwner !== undefined && { meshOwner: input.meshOwner }),
1371
- };
872
+ resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "virtualGatewayName", () => input.virtualGatewayName, "{virtualGatewayName}", false);
873
+ resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "meshName", () => input.meshName, "{meshName}", false);
874
+ const query = map({
875
+ meshOwner: [, input.meshOwner],
876
+ });
1372
877
  let body;
1373
878
  body = JSON.stringify({
1374
879
  clientToken: (_a = input.clientToken) !== null && _a !== void 0 ? _a : (0, uuid_1.v4)(),
@@ -1394,29 +899,11 @@ const serializeAws_restJson1UpdateVirtualNodeCommand = async (input, context) =>
1394
899
  };
1395
900
  let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` +
1396
901
  "/v20190125/meshes/{meshName}/virtualNodes/{virtualNodeName}";
1397
- if (input.virtualNodeName !== undefined) {
1398
- const labelValue = input.virtualNodeName;
1399
- if (labelValue.length <= 0) {
1400
- throw new Error("Empty value provided for input HTTP label: virtualNodeName.");
1401
- }
1402
- resolvedPath = resolvedPath.replace("{virtualNodeName}", (0, smithy_client_1.extendedEncodeURIComponent)(labelValue));
1403
- }
1404
- else {
1405
- throw new Error("No value provided for input HTTP label: virtualNodeName.");
1406
- }
1407
- if (input.meshName !== undefined) {
1408
- const labelValue = input.meshName;
1409
- if (labelValue.length <= 0) {
1410
- throw new Error("Empty value provided for input HTTP label: meshName.");
1411
- }
1412
- resolvedPath = resolvedPath.replace("{meshName}", (0, smithy_client_1.extendedEncodeURIComponent)(labelValue));
1413
- }
1414
- else {
1415
- throw new Error("No value provided for input HTTP label: meshName.");
1416
- }
1417
- const query = {
1418
- ...(input.meshOwner !== undefined && { meshOwner: input.meshOwner }),
1419
- };
902
+ resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "virtualNodeName", () => input.virtualNodeName, "{virtualNodeName}", false);
903
+ resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "meshName", () => input.meshName, "{meshName}", false);
904
+ const query = map({
905
+ meshOwner: [, input.meshOwner],
906
+ });
1420
907
  let body;
1421
908
  body = JSON.stringify({
1422
909
  clientToken: (_a = input.clientToken) !== null && _a !== void 0 ? _a : (0, uuid_1.v4)(),
@@ -1442,29 +929,11 @@ const serializeAws_restJson1UpdateVirtualRouterCommand = async (input, context)
1442
929
  };
1443
930
  let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` +
1444
931
  "/v20190125/meshes/{meshName}/virtualRouters/{virtualRouterName}";
1445
- if (input.virtualRouterName !== undefined) {
1446
- const labelValue = input.virtualRouterName;
1447
- if (labelValue.length <= 0) {
1448
- throw new Error("Empty value provided for input HTTP label: virtualRouterName.");
1449
- }
1450
- resolvedPath = resolvedPath.replace("{virtualRouterName}", (0, smithy_client_1.extendedEncodeURIComponent)(labelValue));
1451
- }
1452
- else {
1453
- throw new Error("No value provided for input HTTP label: virtualRouterName.");
1454
- }
1455
- if (input.meshName !== undefined) {
1456
- const labelValue = input.meshName;
1457
- if (labelValue.length <= 0) {
1458
- throw new Error("Empty value provided for input HTTP label: meshName.");
1459
- }
1460
- resolvedPath = resolvedPath.replace("{meshName}", (0, smithy_client_1.extendedEncodeURIComponent)(labelValue));
1461
- }
1462
- else {
1463
- throw new Error("No value provided for input HTTP label: meshName.");
1464
- }
1465
- const query = {
1466
- ...(input.meshOwner !== undefined && { meshOwner: input.meshOwner }),
1467
- };
932
+ resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "virtualRouterName", () => input.virtualRouterName, "{virtualRouterName}", false);
933
+ resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "meshName", () => input.meshName, "{meshName}", false);
934
+ const query = map({
935
+ meshOwner: [, input.meshOwner],
936
+ });
1468
937
  let body;
1469
938
  body = JSON.stringify({
1470
939
  clientToken: (_a = input.clientToken) !== null && _a !== void 0 ? _a : (0, uuid_1.v4)(),
@@ -1490,29 +959,11 @@ const serializeAws_restJson1UpdateVirtualServiceCommand = async (input, context)
1490
959
  };
1491
960
  let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` +
1492
961
  "/v20190125/meshes/{meshName}/virtualServices/{virtualServiceName}";
1493
- if (input.virtualServiceName !== undefined) {
1494
- const labelValue = input.virtualServiceName;
1495
- if (labelValue.length <= 0) {
1496
- throw new Error("Empty value provided for input HTTP label: virtualServiceName.");
1497
- }
1498
- resolvedPath = resolvedPath.replace("{virtualServiceName}", (0, smithy_client_1.extendedEncodeURIComponent)(labelValue));
1499
- }
1500
- else {
1501
- throw new Error("No value provided for input HTTP label: virtualServiceName.");
1502
- }
1503
- if (input.meshName !== undefined) {
1504
- const labelValue = input.meshName;
1505
- if (labelValue.length <= 0) {
1506
- throw new Error("Empty value provided for input HTTP label: meshName.");
1507
- }
1508
- resolvedPath = resolvedPath.replace("{meshName}", (0, smithy_client_1.extendedEncodeURIComponent)(labelValue));
1509
- }
1510
- else {
1511
- throw new Error("No value provided for input HTTP label: meshName.");
1512
- }
1513
- const query = {
1514
- ...(input.meshOwner !== undefined && { meshOwner: input.meshOwner }),
1515
- };
962
+ resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "virtualServiceName", () => input.virtualServiceName, "{virtualServiceName}", false);
963
+ resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "meshName", () => input.meshName, "{meshName}", false);
964
+ const query = map({
965
+ meshOwner: [, input.meshOwner],
966
+ });
1516
967
  let body;
1517
968
  body = JSON.stringify({
1518
969
  clientToken: (_a = input.clientToken) !== null && _a !== void 0 ? _a : (0, uuid_1.v4)(),
@@ -1534,13 +985,12 @@ const deserializeAws_restJson1CreateGatewayRouteCommand = async (output, context
1534
985
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1535
986
  return deserializeAws_restJson1CreateGatewayRouteCommandError(output, context);
1536
987
  }
1537
- const contents = {
988
+ const contents = map({
1538
989
  $metadata: deserializeMetadata(output),
1539
- gatewayRoute: undefined,
1540
- };
990
+ });
1541
991
  const data = (0, smithy_client_1.expectObject)(await parseBody(output.body, context));
1542
992
  contents.gatewayRoute = deserializeAws_restJson1GatewayRouteData(data, context);
1543
- return Promise.resolve(contents);
993
+ return contents;
1544
994
  };
1545
995
  exports.deserializeAws_restJson1CreateGatewayRouteCommand = deserializeAws_restJson1CreateGatewayRouteCommand;
1546
996
  const deserializeAws_restJson1CreateGatewayRouteCommandError = async (output, context) => {
@@ -1548,7 +998,6 @@ const deserializeAws_restJson1CreateGatewayRouteCommandError = async (output, co
1548
998
  ...output,
1549
999
  body: await parseBody(output.body, context),
1550
1000
  };
1551
- let response;
1552
1001
  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1553
1002
  switch (errorCode) {
1554
1003
  case "BadRequestException":
@@ -1577,27 +1026,24 @@ const deserializeAws_restJson1CreateGatewayRouteCommandError = async (output, co
1577
1026
  throw await deserializeAws_restJson1TooManyRequestsExceptionResponse(parsedOutput, context);
1578
1027
  default:
1579
1028
  const parsedBody = parsedOutput.body;
1580
- const $metadata = deserializeMetadata(output);
1581
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
1582
- response = new AppMeshServiceException_1.AppMeshServiceException({
1583
- name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
1584
- $fault: "client",
1585
- $metadata,
1029
+ (0, smithy_client_1.throwDefaultError)({
1030
+ output,
1031
+ parsedBody,
1032
+ exceptionCtor: AppMeshServiceException_1.AppMeshServiceException,
1033
+ errorCode,
1586
1034
  });
1587
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
1588
1035
  }
1589
1036
  };
1590
1037
  const deserializeAws_restJson1CreateMeshCommand = async (output, context) => {
1591
1038
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1592
1039
  return deserializeAws_restJson1CreateMeshCommandError(output, context);
1593
1040
  }
1594
- const contents = {
1041
+ const contents = map({
1595
1042
  $metadata: deserializeMetadata(output),
1596
- mesh: undefined,
1597
- };
1043
+ });
1598
1044
  const data = (0, smithy_client_1.expectObject)(await parseBody(output.body, context));
1599
1045
  contents.mesh = deserializeAws_restJson1MeshData(data, context);
1600
- return Promise.resolve(contents);
1046
+ return contents;
1601
1047
  };
1602
1048
  exports.deserializeAws_restJson1CreateMeshCommand = deserializeAws_restJson1CreateMeshCommand;
1603
1049
  const deserializeAws_restJson1CreateMeshCommandError = async (output, context) => {
@@ -1605,7 +1051,6 @@ const deserializeAws_restJson1CreateMeshCommandError = async (output, context) =
1605
1051
  ...output,
1606
1052
  body: await parseBody(output.body, context),
1607
1053
  };
1608
- let response;
1609
1054
  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1610
1055
  switch (errorCode) {
1611
1056
  case "BadRequestException":
@@ -1634,27 +1079,24 @@ const deserializeAws_restJson1CreateMeshCommandError = async (output, context) =
1634
1079
  throw await deserializeAws_restJson1TooManyRequestsExceptionResponse(parsedOutput, context);
1635
1080
  default:
1636
1081
  const parsedBody = parsedOutput.body;
1637
- const $metadata = deserializeMetadata(output);
1638
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
1639
- response = new AppMeshServiceException_1.AppMeshServiceException({
1640
- name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
1641
- $fault: "client",
1642
- $metadata,
1082
+ (0, smithy_client_1.throwDefaultError)({
1083
+ output,
1084
+ parsedBody,
1085
+ exceptionCtor: AppMeshServiceException_1.AppMeshServiceException,
1086
+ errorCode,
1643
1087
  });
1644
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
1645
1088
  }
1646
1089
  };
1647
1090
  const deserializeAws_restJson1CreateRouteCommand = async (output, context) => {
1648
1091
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1649
1092
  return deserializeAws_restJson1CreateRouteCommandError(output, context);
1650
1093
  }
1651
- const contents = {
1094
+ const contents = map({
1652
1095
  $metadata: deserializeMetadata(output),
1653
- route: undefined,
1654
- };
1096
+ });
1655
1097
  const data = (0, smithy_client_1.expectObject)(await parseBody(output.body, context));
1656
1098
  contents.route = deserializeAws_restJson1RouteData(data, context);
1657
- return Promise.resolve(contents);
1099
+ return contents;
1658
1100
  };
1659
1101
  exports.deserializeAws_restJson1CreateRouteCommand = deserializeAws_restJson1CreateRouteCommand;
1660
1102
  const deserializeAws_restJson1CreateRouteCommandError = async (output, context) => {
@@ -1662,7 +1104,6 @@ const deserializeAws_restJson1CreateRouteCommandError = async (output, context)
1662
1104
  ...output,
1663
1105
  body: await parseBody(output.body, context),
1664
1106
  };
1665
- let response;
1666
1107
  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1667
1108
  switch (errorCode) {
1668
1109
  case "BadRequestException":
@@ -1691,27 +1132,24 @@ const deserializeAws_restJson1CreateRouteCommandError = async (output, context)
1691
1132
  throw await deserializeAws_restJson1TooManyRequestsExceptionResponse(parsedOutput, context);
1692
1133
  default:
1693
1134
  const parsedBody = parsedOutput.body;
1694
- const $metadata = deserializeMetadata(output);
1695
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
1696
- response = new AppMeshServiceException_1.AppMeshServiceException({
1697
- name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
1698
- $fault: "client",
1699
- $metadata,
1135
+ (0, smithy_client_1.throwDefaultError)({
1136
+ output,
1137
+ parsedBody,
1138
+ exceptionCtor: AppMeshServiceException_1.AppMeshServiceException,
1139
+ errorCode,
1700
1140
  });
1701
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
1702
1141
  }
1703
1142
  };
1704
1143
  const deserializeAws_restJson1CreateVirtualGatewayCommand = async (output, context) => {
1705
1144
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1706
1145
  return deserializeAws_restJson1CreateVirtualGatewayCommandError(output, context);
1707
1146
  }
1708
- const contents = {
1147
+ const contents = map({
1709
1148
  $metadata: deserializeMetadata(output),
1710
- virtualGateway: undefined,
1711
- };
1149
+ });
1712
1150
  const data = (0, smithy_client_1.expectObject)(await parseBody(output.body, context));
1713
1151
  contents.virtualGateway = deserializeAws_restJson1VirtualGatewayData(data, context);
1714
- return Promise.resolve(contents);
1152
+ return contents;
1715
1153
  };
1716
1154
  exports.deserializeAws_restJson1CreateVirtualGatewayCommand = deserializeAws_restJson1CreateVirtualGatewayCommand;
1717
1155
  const deserializeAws_restJson1CreateVirtualGatewayCommandError = async (output, context) => {
@@ -1719,7 +1157,6 @@ const deserializeAws_restJson1CreateVirtualGatewayCommandError = async (output,
1719
1157
  ...output,
1720
1158
  body: await parseBody(output.body, context),
1721
1159
  };
1722
- let response;
1723
1160
  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1724
1161
  switch (errorCode) {
1725
1162
  case "BadRequestException":
@@ -1748,27 +1185,24 @@ const deserializeAws_restJson1CreateVirtualGatewayCommandError = async (output,
1748
1185
  throw await deserializeAws_restJson1TooManyRequestsExceptionResponse(parsedOutput, context);
1749
1186
  default:
1750
1187
  const parsedBody = parsedOutput.body;
1751
- const $metadata = deserializeMetadata(output);
1752
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
1753
- response = new AppMeshServiceException_1.AppMeshServiceException({
1754
- name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
1755
- $fault: "client",
1756
- $metadata,
1188
+ (0, smithy_client_1.throwDefaultError)({
1189
+ output,
1190
+ parsedBody,
1191
+ exceptionCtor: AppMeshServiceException_1.AppMeshServiceException,
1192
+ errorCode,
1757
1193
  });
1758
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
1759
1194
  }
1760
1195
  };
1761
1196
  const deserializeAws_restJson1CreateVirtualNodeCommand = async (output, context) => {
1762
1197
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1763
1198
  return deserializeAws_restJson1CreateVirtualNodeCommandError(output, context);
1764
1199
  }
1765
- const contents = {
1200
+ const contents = map({
1766
1201
  $metadata: deserializeMetadata(output),
1767
- virtualNode: undefined,
1768
- };
1202
+ });
1769
1203
  const data = (0, smithy_client_1.expectObject)(await parseBody(output.body, context));
1770
1204
  contents.virtualNode = deserializeAws_restJson1VirtualNodeData(data, context);
1771
- return Promise.resolve(contents);
1205
+ return contents;
1772
1206
  };
1773
1207
  exports.deserializeAws_restJson1CreateVirtualNodeCommand = deserializeAws_restJson1CreateVirtualNodeCommand;
1774
1208
  const deserializeAws_restJson1CreateVirtualNodeCommandError = async (output, context) => {
@@ -1776,7 +1210,6 @@ const deserializeAws_restJson1CreateVirtualNodeCommandError = async (output, con
1776
1210
  ...output,
1777
1211
  body: await parseBody(output.body, context),
1778
1212
  };
1779
- let response;
1780
1213
  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1781
1214
  switch (errorCode) {
1782
1215
  case "BadRequestException":
@@ -1805,27 +1238,24 @@ const deserializeAws_restJson1CreateVirtualNodeCommandError = async (output, con
1805
1238
  throw await deserializeAws_restJson1TooManyRequestsExceptionResponse(parsedOutput, context);
1806
1239
  default:
1807
1240
  const parsedBody = parsedOutput.body;
1808
- const $metadata = deserializeMetadata(output);
1809
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
1810
- response = new AppMeshServiceException_1.AppMeshServiceException({
1811
- name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
1812
- $fault: "client",
1813
- $metadata,
1241
+ (0, smithy_client_1.throwDefaultError)({
1242
+ output,
1243
+ parsedBody,
1244
+ exceptionCtor: AppMeshServiceException_1.AppMeshServiceException,
1245
+ errorCode,
1814
1246
  });
1815
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
1816
1247
  }
1817
1248
  };
1818
1249
  const deserializeAws_restJson1CreateVirtualRouterCommand = async (output, context) => {
1819
1250
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1820
1251
  return deserializeAws_restJson1CreateVirtualRouterCommandError(output, context);
1821
1252
  }
1822
- const contents = {
1253
+ const contents = map({
1823
1254
  $metadata: deserializeMetadata(output),
1824
- virtualRouter: undefined,
1825
- };
1255
+ });
1826
1256
  const data = (0, smithy_client_1.expectObject)(await parseBody(output.body, context));
1827
1257
  contents.virtualRouter = deserializeAws_restJson1VirtualRouterData(data, context);
1828
- return Promise.resolve(contents);
1258
+ return contents;
1829
1259
  };
1830
1260
  exports.deserializeAws_restJson1CreateVirtualRouterCommand = deserializeAws_restJson1CreateVirtualRouterCommand;
1831
1261
  const deserializeAws_restJson1CreateVirtualRouterCommandError = async (output, context) => {
@@ -1833,7 +1263,6 @@ const deserializeAws_restJson1CreateVirtualRouterCommandError = async (output, c
1833
1263
  ...output,
1834
1264
  body: await parseBody(output.body, context),
1835
1265
  };
1836
- let response;
1837
1266
  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1838
1267
  switch (errorCode) {
1839
1268
  case "BadRequestException":
@@ -1862,27 +1291,24 @@ const deserializeAws_restJson1CreateVirtualRouterCommandError = async (output, c
1862
1291
  throw await deserializeAws_restJson1TooManyRequestsExceptionResponse(parsedOutput, context);
1863
1292
  default:
1864
1293
  const parsedBody = parsedOutput.body;
1865
- const $metadata = deserializeMetadata(output);
1866
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
1867
- response = new AppMeshServiceException_1.AppMeshServiceException({
1868
- name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
1869
- $fault: "client",
1870
- $metadata,
1294
+ (0, smithy_client_1.throwDefaultError)({
1295
+ output,
1296
+ parsedBody,
1297
+ exceptionCtor: AppMeshServiceException_1.AppMeshServiceException,
1298
+ errorCode,
1871
1299
  });
1872
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
1873
1300
  }
1874
1301
  };
1875
1302
  const deserializeAws_restJson1CreateVirtualServiceCommand = async (output, context) => {
1876
1303
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1877
1304
  return deserializeAws_restJson1CreateVirtualServiceCommandError(output, context);
1878
1305
  }
1879
- const contents = {
1306
+ const contents = map({
1880
1307
  $metadata: deserializeMetadata(output),
1881
- virtualService: undefined,
1882
- };
1308
+ });
1883
1309
  const data = (0, smithy_client_1.expectObject)(await parseBody(output.body, context));
1884
1310
  contents.virtualService = deserializeAws_restJson1VirtualServiceData(data, context);
1885
- return Promise.resolve(contents);
1311
+ return contents;
1886
1312
  };
1887
1313
  exports.deserializeAws_restJson1CreateVirtualServiceCommand = deserializeAws_restJson1CreateVirtualServiceCommand;
1888
1314
  const deserializeAws_restJson1CreateVirtualServiceCommandError = async (output, context) => {
@@ -1890,7 +1316,6 @@ const deserializeAws_restJson1CreateVirtualServiceCommandError = async (output,
1890
1316
  ...output,
1891
1317
  body: await parseBody(output.body, context),
1892
1318
  };
1893
- let response;
1894
1319
  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1895
1320
  switch (errorCode) {
1896
1321
  case "BadRequestException":
@@ -1919,27 +1344,24 @@ const deserializeAws_restJson1CreateVirtualServiceCommandError = async (output,
1919
1344
  throw await deserializeAws_restJson1TooManyRequestsExceptionResponse(parsedOutput, context);
1920
1345
  default:
1921
1346
  const parsedBody = parsedOutput.body;
1922
- const $metadata = deserializeMetadata(output);
1923
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
1924
- response = new AppMeshServiceException_1.AppMeshServiceException({
1925
- name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
1926
- $fault: "client",
1927
- $metadata,
1347
+ (0, smithy_client_1.throwDefaultError)({
1348
+ output,
1349
+ parsedBody,
1350
+ exceptionCtor: AppMeshServiceException_1.AppMeshServiceException,
1351
+ errorCode,
1928
1352
  });
1929
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
1930
1353
  }
1931
1354
  };
1932
1355
  const deserializeAws_restJson1DeleteGatewayRouteCommand = async (output, context) => {
1933
1356
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1934
1357
  return deserializeAws_restJson1DeleteGatewayRouteCommandError(output, context);
1935
1358
  }
1936
- const contents = {
1359
+ const contents = map({
1937
1360
  $metadata: deserializeMetadata(output),
1938
- gatewayRoute: undefined,
1939
- };
1361
+ });
1940
1362
  const data = (0, smithy_client_1.expectObject)(await parseBody(output.body, context));
1941
1363
  contents.gatewayRoute = deserializeAws_restJson1GatewayRouteData(data, context);
1942
- return Promise.resolve(contents);
1364
+ return contents;
1943
1365
  };
1944
1366
  exports.deserializeAws_restJson1DeleteGatewayRouteCommand = deserializeAws_restJson1DeleteGatewayRouteCommand;
1945
1367
  const deserializeAws_restJson1DeleteGatewayRouteCommandError = async (output, context) => {
@@ -1947,7 +1369,6 @@ const deserializeAws_restJson1DeleteGatewayRouteCommandError = async (output, co
1947
1369
  ...output,
1948
1370
  body: await parseBody(output.body, context),
1949
1371
  };
1950
- let response;
1951
1372
  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1952
1373
  switch (errorCode) {
1953
1374
  case "BadRequestException":
@@ -1973,27 +1394,24 @@ const deserializeAws_restJson1DeleteGatewayRouteCommandError = async (output, co
1973
1394
  throw await deserializeAws_restJson1TooManyRequestsExceptionResponse(parsedOutput, context);
1974
1395
  default:
1975
1396
  const parsedBody = parsedOutput.body;
1976
- const $metadata = deserializeMetadata(output);
1977
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
1978
- response = new AppMeshServiceException_1.AppMeshServiceException({
1979
- name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
1980
- $fault: "client",
1981
- $metadata,
1397
+ (0, smithy_client_1.throwDefaultError)({
1398
+ output,
1399
+ parsedBody,
1400
+ exceptionCtor: AppMeshServiceException_1.AppMeshServiceException,
1401
+ errorCode,
1982
1402
  });
1983
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
1984
1403
  }
1985
1404
  };
1986
1405
  const deserializeAws_restJson1DeleteMeshCommand = async (output, context) => {
1987
1406
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1988
1407
  return deserializeAws_restJson1DeleteMeshCommandError(output, context);
1989
1408
  }
1990
- const contents = {
1409
+ const contents = map({
1991
1410
  $metadata: deserializeMetadata(output),
1992
- mesh: undefined,
1993
- };
1411
+ });
1994
1412
  const data = (0, smithy_client_1.expectObject)(await parseBody(output.body, context));
1995
1413
  contents.mesh = deserializeAws_restJson1MeshData(data, context);
1996
- return Promise.resolve(contents);
1414
+ return contents;
1997
1415
  };
1998
1416
  exports.deserializeAws_restJson1DeleteMeshCommand = deserializeAws_restJson1DeleteMeshCommand;
1999
1417
  const deserializeAws_restJson1DeleteMeshCommandError = async (output, context) => {
@@ -2001,7 +1419,6 @@ const deserializeAws_restJson1DeleteMeshCommandError = async (output, context) =
2001
1419
  ...output,
2002
1420
  body: await parseBody(output.body, context),
2003
1421
  };
2004
- let response;
2005
1422
  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2006
1423
  switch (errorCode) {
2007
1424
  case "BadRequestException":
@@ -2027,27 +1444,24 @@ const deserializeAws_restJson1DeleteMeshCommandError = async (output, context) =
2027
1444
  throw await deserializeAws_restJson1TooManyRequestsExceptionResponse(parsedOutput, context);
2028
1445
  default:
2029
1446
  const parsedBody = parsedOutput.body;
2030
- const $metadata = deserializeMetadata(output);
2031
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
2032
- response = new AppMeshServiceException_1.AppMeshServiceException({
2033
- name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
2034
- $fault: "client",
2035
- $metadata,
1447
+ (0, smithy_client_1.throwDefaultError)({
1448
+ output,
1449
+ parsedBody,
1450
+ exceptionCtor: AppMeshServiceException_1.AppMeshServiceException,
1451
+ errorCode,
2036
1452
  });
2037
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
2038
1453
  }
2039
1454
  };
2040
1455
  const deserializeAws_restJson1DeleteRouteCommand = async (output, context) => {
2041
1456
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2042
1457
  return deserializeAws_restJson1DeleteRouteCommandError(output, context);
2043
1458
  }
2044
- const contents = {
1459
+ const contents = map({
2045
1460
  $metadata: deserializeMetadata(output),
2046
- route: undefined,
2047
- };
1461
+ });
2048
1462
  const data = (0, smithy_client_1.expectObject)(await parseBody(output.body, context));
2049
1463
  contents.route = deserializeAws_restJson1RouteData(data, context);
2050
- return Promise.resolve(contents);
1464
+ return contents;
2051
1465
  };
2052
1466
  exports.deserializeAws_restJson1DeleteRouteCommand = deserializeAws_restJson1DeleteRouteCommand;
2053
1467
  const deserializeAws_restJson1DeleteRouteCommandError = async (output, context) => {
@@ -2055,7 +1469,6 @@ const deserializeAws_restJson1DeleteRouteCommandError = async (output, context)
2055
1469
  ...output,
2056
1470
  body: await parseBody(output.body, context),
2057
1471
  };
2058
- let response;
2059
1472
  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2060
1473
  switch (errorCode) {
2061
1474
  case "BadRequestException":
@@ -2081,27 +1494,24 @@ const deserializeAws_restJson1DeleteRouteCommandError = async (output, context)
2081
1494
  throw await deserializeAws_restJson1TooManyRequestsExceptionResponse(parsedOutput, context);
2082
1495
  default:
2083
1496
  const parsedBody = parsedOutput.body;
2084
- const $metadata = deserializeMetadata(output);
2085
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
2086
- response = new AppMeshServiceException_1.AppMeshServiceException({
2087
- name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
2088
- $fault: "client",
2089
- $metadata,
1497
+ (0, smithy_client_1.throwDefaultError)({
1498
+ output,
1499
+ parsedBody,
1500
+ exceptionCtor: AppMeshServiceException_1.AppMeshServiceException,
1501
+ errorCode,
2090
1502
  });
2091
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
2092
1503
  }
2093
1504
  };
2094
1505
  const deserializeAws_restJson1DeleteVirtualGatewayCommand = async (output, context) => {
2095
1506
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2096
1507
  return deserializeAws_restJson1DeleteVirtualGatewayCommandError(output, context);
2097
1508
  }
2098
- const contents = {
1509
+ const contents = map({
2099
1510
  $metadata: deserializeMetadata(output),
2100
- virtualGateway: undefined,
2101
- };
1511
+ });
2102
1512
  const data = (0, smithy_client_1.expectObject)(await parseBody(output.body, context));
2103
1513
  contents.virtualGateway = deserializeAws_restJson1VirtualGatewayData(data, context);
2104
- return Promise.resolve(contents);
1514
+ return contents;
2105
1515
  };
2106
1516
  exports.deserializeAws_restJson1DeleteVirtualGatewayCommand = deserializeAws_restJson1DeleteVirtualGatewayCommand;
2107
1517
  const deserializeAws_restJson1DeleteVirtualGatewayCommandError = async (output, context) => {
@@ -2109,7 +1519,6 @@ const deserializeAws_restJson1DeleteVirtualGatewayCommandError = async (output,
2109
1519
  ...output,
2110
1520
  body: await parseBody(output.body, context),
2111
1521
  };
2112
- let response;
2113
1522
  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2114
1523
  switch (errorCode) {
2115
1524
  case "BadRequestException":
@@ -2135,27 +1544,24 @@ const deserializeAws_restJson1DeleteVirtualGatewayCommandError = async (output,
2135
1544
  throw await deserializeAws_restJson1TooManyRequestsExceptionResponse(parsedOutput, context);
2136
1545
  default:
2137
1546
  const parsedBody = parsedOutput.body;
2138
- const $metadata = deserializeMetadata(output);
2139
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
2140
- response = new AppMeshServiceException_1.AppMeshServiceException({
2141
- name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
2142
- $fault: "client",
2143
- $metadata,
1547
+ (0, smithy_client_1.throwDefaultError)({
1548
+ output,
1549
+ parsedBody,
1550
+ exceptionCtor: AppMeshServiceException_1.AppMeshServiceException,
1551
+ errorCode,
2144
1552
  });
2145
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
2146
1553
  }
2147
1554
  };
2148
1555
  const deserializeAws_restJson1DeleteVirtualNodeCommand = async (output, context) => {
2149
1556
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2150
1557
  return deserializeAws_restJson1DeleteVirtualNodeCommandError(output, context);
2151
1558
  }
2152
- const contents = {
1559
+ const contents = map({
2153
1560
  $metadata: deserializeMetadata(output),
2154
- virtualNode: undefined,
2155
- };
1561
+ });
2156
1562
  const data = (0, smithy_client_1.expectObject)(await parseBody(output.body, context));
2157
1563
  contents.virtualNode = deserializeAws_restJson1VirtualNodeData(data, context);
2158
- return Promise.resolve(contents);
1564
+ return contents;
2159
1565
  };
2160
1566
  exports.deserializeAws_restJson1DeleteVirtualNodeCommand = deserializeAws_restJson1DeleteVirtualNodeCommand;
2161
1567
  const deserializeAws_restJson1DeleteVirtualNodeCommandError = async (output, context) => {
@@ -2163,7 +1569,6 @@ const deserializeAws_restJson1DeleteVirtualNodeCommandError = async (output, con
2163
1569
  ...output,
2164
1570
  body: await parseBody(output.body, context),
2165
1571
  };
2166
- let response;
2167
1572
  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2168
1573
  switch (errorCode) {
2169
1574
  case "BadRequestException":
@@ -2189,27 +1594,24 @@ const deserializeAws_restJson1DeleteVirtualNodeCommandError = async (output, con
2189
1594
  throw await deserializeAws_restJson1TooManyRequestsExceptionResponse(parsedOutput, context);
2190
1595
  default:
2191
1596
  const parsedBody = parsedOutput.body;
2192
- const $metadata = deserializeMetadata(output);
2193
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
2194
- response = new AppMeshServiceException_1.AppMeshServiceException({
2195
- name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
2196
- $fault: "client",
2197
- $metadata,
1597
+ (0, smithy_client_1.throwDefaultError)({
1598
+ output,
1599
+ parsedBody,
1600
+ exceptionCtor: AppMeshServiceException_1.AppMeshServiceException,
1601
+ errorCode,
2198
1602
  });
2199
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
2200
1603
  }
2201
1604
  };
2202
1605
  const deserializeAws_restJson1DeleteVirtualRouterCommand = async (output, context) => {
2203
1606
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2204
1607
  return deserializeAws_restJson1DeleteVirtualRouterCommandError(output, context);
2205
1608
  }
2206
- const contents = {
1609
+ const contents = map({
2207
1610
  $metadata: deserializeMetadata(output),
2208
- virtualRouter: undefined,
2209
- };
1611
+ });
2210
1612
  const data = (0, smithy_client_1.expectObject)(await parseBody(output.body, context));
2211
1613
  contents.virtualRouter = deserializeAws_restJson1VirtualRouterData(data, context);
2212
- return Promise.resolve(contents);
1614
+ return contents;
2213
1615
  };
2214
1616
  exports.deserializeAws_restJson1DeleteVirtualRouterCommand = deserializeAws_restJson1DeleteVirtualRouterCommand;
2215
1617
  const deserializeAws_restJson1DeleteVirtualRouterCommandError = async (output, context) => {
@@ -2217,7 +1619,6 @@ const deserializeAws_restJson1DeleteVirtualRouterCommandError = async (output, c
2217
1619
  ...output,
2218
1620
  body: await parseBody(output.body, context),
2219
1621
  };
2220
- let response;
2221
1622
  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2222
1623
  switch (errorCode) {
2223
1624
  case "BadRequestException":
@@ -2243,27 +1644,24 @@ const deserializeAws_restJson1DeleteVirtualRouterCommandError = async (output, c
2243
1644
  throw await deserializeAws_restJson1TooManyRequestsExceptionResponse(parsedOutput, context);
2244
1645
  default:
2245
1646
  const parsedBody = parsedOutput.body;
2246
- const $metadata = deserializeMetadata(output);
2247
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
2248
- response = new AppMeshServiceException_1.AppMeshServiceException({
2249
- name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
2250
- $fault: "client",
2251
- $metadata,
1647
+ (0, smithy_client_1.throwDefaultError)({
1648
+ output,
1649
+ parsedBody,
1650
+ exceptionCtor: AppMeshServiceException_1.AppMeshServiceException,
1651
+ errorCode,
2252
1652
  });
2253
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
2254
1653
  }
2255
1654
  };
2256
1655
  const deserializeAws_restJson1DeleteVirtualServiceCommand = async (output, context) => {
2257
1656
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2258
1657
  return deserializeAws_restJson1DeleteVirtualServiceCommandError(output, context);
2259
1658
  }
2260
- const contents = {
1659
+ const contents = map({
2261
1660
  $metadata: deserializeMetadata(output),
2262
- virtualService: undefined,
2263
- };
1661
+ });
2264
1662
  const data = (0, smithy_client_1.expectObject)(await parseBody(output.body, context));
2265
1663
  contents.virtualService = deserializeAws_restJson1VirtualServiceData(data, context);
2266
- return Promise.resolve(contents);
1664
+ return contents;
2267
1665
  };
2268
1666
  exports.deserializeAws_restJson1DeleteVirtualServiceCommand = deserializeAws_restJson1DeleteVirtualServiceCommand;
2269
1667
  const deserializeAws_restJson1DeleteVirtualServiceCommandError = async (output, context) => {
@@ -2271,7 +1669,6 @@ const deserializeAws_restJson1DeleteVirtualServiceCommandError = async (output,
2271
1669
  ...output,
2272
1670
  body: await parseBody(output.body, context),
2273
1671
  };
2274
- let response;
2275
1672
  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2276
1673
  switch (errorCode) {
2277
1674
  case "BadRequestException":
@@ -2297,27 +1694,24 @@ const deserializeAws_restJson1DeleteVirtualServiceCommandError = async (output,
2297
1694
  throw await deserializeAws_restJson1TooManyRequestsExceptionResponse(parsedOutput, context);
2298
1695
  default:
2299
1696
  const parsedBody = parsedOutput.body;
2300
- const $metadata = deserializeMetadata(output);
2301
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
2302
- response = new AppMeshServiceException_1.AppMeshServiceException({
2303
- name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
2304
- $fault: "client",
2305
- $metadata,
1697
+ (0, smithy_client_1.throwDefaultError)({
1698
+ output,
1699
+ parsedBody,
1700
+ exceptionCtor: AppMeshServiceException_1.AppMeshServiceException,
1701
+ errorCode,
2306
1702
  });
2307
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
2308
1703
  }
2309
1704
  };
2310
1705
  const deserializeAws_restJson1DescribeGatewayRouteCommand = async (output, context) => {
2311
1706
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2312
1707
  return deserializeAws_restJson1DescribeGatewayRouteCommandError(output, context);
2313
1708
  }
2314
- const contents = {
1709
+ const contents = map({
2315
1710
  $metadata: deserializeMetadata(output),
2316
- gatewayRoute: undefined,
2317
- };
1711
+ });
2318
1712
  const data = (0, smithy_client_1.expectObject)(await parseBody(output.body, context));
2319
1713
  contents.gatewayRoute = deserializeAws_restJson1GatewayRouteData(data, context);
2320
- return Promise.resolve(contents);
1714
+ return contents;
2321
1715
  };
2322
1716
  exports.deserializeAws_restJson1DescribeGatewayRouteCommand = deserializeAws_restJson1DescribeGatewayRouteCommand;
2323
1717
  const deserializeAws_restJson1DescribeGatewayRouteCommandError = async (output, context) => {
@@ -2325,7 +1719,6 @@ const deserializeAws_restJson1DescribeGatewayRouteCommandError = async (output,
2325
1719
  ...output,
2326
1720
  body: await parseBody(output.body, context),
2327
1721
  };
2328
- let response;
2329
1722
  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2330
1723
  switch (errorCode) {
2331
1724
  case "BadRequestException":
@@ -2348,27 +1741,24 @@ const deserializeAws_restJson1DescribeGatewayRouteCommandError = async (output,
2348
1741
  throw await deserializeAws_restJson1TooManyRequestsExceptionResponse(parsedOutput, context);
2349
1742
  default:
2350
1743
  const parsedBody = parsedOutput.body;
2351
- const $metadata = deserializeMetadata(output);
2352
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
2353
- response = new AppMeshServiceException_1.AppMeshServiceException({
2354
- name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
2355
- $fault: "client",
2356
- $metadata,
1744
+ (0, smithy_client_1.throwDefaultError)({
1745
+ output,
1746
+ parsedBody,
1747
+ exceptionCtor: AppMeshServiceException_1.AppMeshServiceException,
1748
+ errorCode,
2357
1749
  });
2358
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
2359
1750
  }
2360
1751
  };
2361
1752
  const deserializeAws_restJson1DescribeMeshCommand = async (output, context) => {
2362
1753
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2363
1754
  return deserializeAws_restJson1DescribeMeshCommandError(output, context);
2364
1755
  }
2365
- const contents = {
1756
+ const contents = map({
2366
1757
  $metadata: deserializeMetadata(output),
2367
- mesh: undefined,
2368
- };
1758
+ });
2369
1759
  const data = (0, smithy_client_1.expectObject)(await parseBody(output.body, context));
2370
1760
  contents.mesh = deserializeAws_restJson1MeshData(data, context);
2371
- return Promise.resolve(contents);
1761
+ return contents;
2372
1762
  };
2373
1763
  exports.deserializeAws_restJson1DescribeMeshCommand = deserializeAws_restJson1DescribeMeshCommand;
2374
1764
  const deserializeAws_restJson1DescribeMeshCommandError = async (output, context) => {
@@ -2376,7 +1766,6 @@ const deserializeAws_restJson1DescribeMeshCommandError = async (output, context)
2376
1766
  ...output,
2377
1767
  body: await parseBody(output.body, context),
2378
1768
  };
2379
- let response;
2380
1769
  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2381
1770
  switch (errorCode) {
2382
1771
  case "BadRequestException":
@@ -2399,27 +1788,24 @@ const deserializeAws_restJson1DescribeMeshCommandError = async (output, context)
2399
1788
  throw await deserializeAws_restJson1TooManyRequestsExceptionResponse(parsedOutput, context);
2400
1789
  default:
2401
1790
  const parsedBody = parsedOutput.body;
2402
- const $metadata = deserializeMetadata(output);
2403
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
2404
- response = new AppMeshServiceException_1.AppMeshServiceException({
2405
- name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
2406
- $fault: "client",
2407
- $metadata,
1791
+ (0, smithy_client_1.throwDefaultError)({
1792
+ output,
1793
+ parsedBody,
1794
+ exceptionCtor: AppMeshServiceException_1.AppMeshServiceException,
1795
+ errorCode,
2408
1796
  });
2409
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
2410
1797
  }
2411
1798
  };
2412
1799
  const deserializeAws_restJson1DescribeRouteCommand = async (output, context) => {
2413
1800
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2414
1801
  return deserializeAws_restJson1DescribeRouteCommandError(output, context);
2415
1802
  }
2416
- const contents = {
1803
+ const contents = map({
2417
1804
  $metadata: deserializeMetadata(output),
2418
- route: undefined,
2419
- };
1805
+ });
2420
1806
  const data = (0, smithy_client_1.expectObject)(await parseBody(output.body, context));
2421
1807
  contents.route = deserializeAws_restJson1RouteData(data, context);
2422
- return Promise.resolve(contents);
1808
+ return contents;
2423
1809
  };
2424
1810
  exports.deserializeAws_restJson1DescribeRouteCommand = deserializeAws_restJson1DescribeRouteCommand;
2425
1811
  const deserializeAws_restJson1DescribeRouteCommandError = async (output, context) => {
@@ -2427,7 +1813,6 @@ const deserializeAws_restJson1DescribeRouteCommandError = async (output, context
2427
1813
  ...output,
2428
1814
  body: await parseBody(output.body, context),
2429
1815
  };
2430
- let response;
2431
1816
  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2432
1817
  switch (errorCode) {
2433
1818
  case "BadRequestException":
@@ -2450,27 +1835,24 @@ const deserializeAws_restJson1DescribeRouteCommandError = async (output, context
2450
1835
  throw await deserializeAws_restJson1TooManyRequestsExceptionResponse(parsedOutput, context);
2451
1836
  default:
2452
1837
  const parsedBody = parsedOutput.body;
2453
- const $metadata = deserializeMetadata(output);
2454
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
2455
- response = new AppMeshServiceException_1.AppMeshServiceException({
2456
- name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
2457
- $fault: "client",
2458
- $metadata,
1838
+ (0, smithy_client_1.throwDefaultError)({
1839
+ output,
1840
+ parsedBody,
1841
+ exceptionCtor: AppMeshServiceException_1.AppMeshServiceException,
1842
+ errorCode,
2459
1843
  });
2460
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
2461
1844
  }
2462
1845
  };
2463
1846
  const deserializeAws_restJson1DescribeVirtualGatewayCommand = async (output, context) => {
2464
1847
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2465
1848
  return deserializeAws_restJson1DescribeVirtualGatewayCommandError(output, context);
2466
1849
  }
2467
- const contents = {
1850
+ const contents = map({
2468
1851
  $metadata: deserializeMetadata(output),
2469
- virtualGateway: undefined,
2470
- };
1852
+ });
2471
1853
  const data = (0, smithy_client_1.expectObject)(await parseBody(output.body, context));
2472
1854
  contents.virtualGateway = deserializeAws_restJson1VirtualGatewayData(data, context);
2473
- return Promise.resolve(contents);
1855
+ return contents;
2474
1856
  };
2475
1857
  exports.deserializeAws_restJson1DescribeVirtualGatewayCommand = deserializeAws_restJson1DescribeVirtualGatewayCommand;
2476
1858
  const deserializeAws_restJson1DescribeVirtualGatewayCommandError = async (output, context) => {
@@ -2478,7 +1860,6 @@ const deserializeAws_restJson1DescribeVirtualGatewayCommandError = async (output
2478
1860
  ...output,
2479
1861
  body: await parseBody(output.body, context),
2480
1862
  };
2481
- let response;
2482
1863
  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2483
1864
  switch (errorCode) {
2484
1865
  case "BadRequestException":
@@ -2501,27 +1882,24 @@ const deserializeAws_restJson1DescribeVirtualGatewayCommandError = async (output
2501
1882
  throw await deserializeAws_restJson1TooManyRequestsExceptionResponse(parsedOutput, context);
2502
1883
  default:
2503
1884
  const parsedBody = parsedOutput.body;
2504
- const $metadata = deserializeMetadata(output);
2505
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
2506
- response = new AppMeshServiceException_1.AppMeshServiceException({
2507
- name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
2508
- $fault: "client",
2509
- $metadata,
1885
+ (0, smithy_client_1.throwDefaultError)({
1886
+ output,
1887
+ parsedBody,
1888
+ exceptionCtor: AppMeshServiceException_1.AppMeshServiceException,
1889
+ errorCode,
2510
1890
  });
2511
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
2512
1891
  }
2513
1892
  };
2514
1893
  const deserializeAws_restJson1DescribeVirtualNodeCommand = async (output, context) => {
2515
1894
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2516
1895
  return deserializeAws_restJson1DescribeVirtualNodeCommandError(output, context);
2517
1896
  }
2518
- const contents = {
1897
+ const contents = map({
2519
1898
  $metadata: deserializeMetadata(output),
2520
- virtualNode: undefined,
2521
- };
1899
+ });
2522
1900
  const data = (0, smithy_client_1.expectObject)(await parseBody(output.body, context));
2523
1901
  contents.virtualNode = deserializeAws_restJson1VirtualNodeData(data, context);
2524
- return Promise.resolve(contents);
1902
+ return contents;
2525
1903
  };
2526
1904
  exports.deserializeAws_restJson1DescribeVirtualNodeCommand = deserializeAws_restJson1DescribeVirtualNodeCommand;
2527
1905
  const deserializeAws_restJson1DescribeVirtualNodeCommandError = async (output, context) => {
@@ -2529,7 +1907,6 @@ const deserializeAws_restJson1DescribeVirtualNodeCommandError = async (output, c
2529
1907
  ...output,
2530
1908
  body: await parseBody(output.body, context),
2531
1909
  };
2532
- let response;
2533
1910
  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2534
1911
  switch (errorCode) {
2535
1912
  case "BadRequestException":
@@ -2552,27 +1929,24 @@ const deserializeAws_restJson1DescribeVirtualNodeCommandError = async (output, c
2552
1929
  throw await deserializeAws_restJson1TooManyRequestsExceptionResponse(parsedOutput, context);
2553
1930
  default:
2554
1931
  const parsedBody = parsedOutput.body;
2555
- const $metadata = deserializeMetadata(output);
2556
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
2557
- response = new AppMeshServiceException_1.AppMeshServiceException({
2558
- name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
2559
- $fault: "client",
2560
- $metadata,
1932
+ (0, smithy_client_1.throwDefaultError)({
1933
+ output,
1934
+ parsedBody,
1935
+ exceptionCtor: AppMeshServiceException_1.AppMeshServiceException,
1936
+ errorCode,
2561
1937
  });
2562
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
2563
1938
  }
2564
1939
  };
2565
1940
  const deserializeAws_restJson1DescribeVirtualRouterCommand = async (output, context) => {
2566
1941
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2567
1942
  return deserializeAws_restJson1DescribeVirtualRouterCommandError(output, context);
2568
1943
  }
2569
- const contents = {
1944
+ const contents = map({
2570
1945
  $metadata: deserializeMetadata(output),
2571
- virtualRouter: undefined,
2572
- };
1946
+ });
2573
1947
  const data = (0, smithy_client_1.expectObject)(await parseBody(output.body, context));
2574
1948
  contents.virtualRouter = deserializeAws_restJson1VirtualRouterData(data, context);
2575
- return Promise.resolve(contents);
1949
+ return contents;
2576
1950
  };
2577
1951
  exports.deserializeAws_restJson1DescribeVirtualRouterCommand = deserializeAws_restJson1DescribeVirtualRouterCommand;
2578
1952
  const deserializeAws_restJson1DescribeVirtualRouterCommandError = async (output, context) => {
@@ -2580,7 +1954,6 @@ const deserializeAws_restJson1DescribeVirtualRouterCommandError = async (output,
2580
1954
  ...output,
2581
1955
  body: await parseBody(output.body, context),
2582
1956
  };
2583
- let response;
2584
1957
  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2585
1958
  switch (errorCode) {
2586
1959
  case "BadRequestException":
@@ -2603,27 +1976,24 @@ const deserializeAws_restJson1DescribeVirtualRouterCommandError = async (output,
2603
1976
  throw await deserializeAws_restJson1TooManyRequestsExceptionResponse(parsedOutput, context);
2604
1977
  default:
2605
1978
  const parsedBody = parsedOutput.body;
2606
- const $metadata = deserializeMetadata(output);
2607
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
2608
- response = new AppMeshServiceException_1.AppMeshServiceException({
2609
- name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
2610
- $fault: "client",
2611
- $metadata,
1979
+ (0, smithy_client_1.throwDefaultError)({
1980
+ output,
1981
+ parsedBody,
1982
+ exceptionCtor: AppMeshServiceException_1.AppMeshServiceException,
1983
+ errorCode,
2612
1984
  });
2613
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
2614
1985
  }
2615
1986
  };
2616
1987
  const deserializeAws_restJson1DescribeVirtualServiceCommand = async (output, context) => {
2617
1988
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2618
1989
  return deserializeAws_restJson1DescribeVirtualServiceCommandError(output, context);
2619
1990
  }
2620
- const contents = {
1991
+ const contents = map({
2621
1992
  $metadata: deserializeMetadata(output),
2622
- virtualService: undefined,
2623
- };
1993
+ });
2624
1994
  const data = (0, smithy_client_1.expectObject)(await parseBody(output.body, context));
2625
1995
  contents.virtualService = deserializeAws_restJson1VirtualServiceData(data, context);
2626
- return Promise.resolve(contents);
1996
+ return contents;
2627
1997
  };
2628
1998
  exports.deserializeAws_restJson1DescribeVirtualServiceCommand = deserializeAws_restJson1DescribeVirtualServiceCommand;
2629
1999
  const deserializeAws_restJson1DescribeVirtualServiceCommandError = async (output, context) => {
@@ -2631,7 +2001,6 @@ const deserializeAws_restJson1DescribeVirtualServiceCommandError = async (output
2631
2001
  ...output,
2632
2002
  body: await parseBody(output.body, context),
2633
2003
  };
2634
- let response;
2635
2004
  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2636
2005
  switch (errorCode) {
2637
2006
  case "BadRequestException":
@@ -2654,33 +2023,29 @@ const deserializeAws_restJson1DescribeVirtualServiceCommandError = async (output
2654
2023
  throw await deserializeAws_restJson1TooManyRequestsExceptionResponse(parsedOutput, context);
2655
2024
  default:
2656
2025
  const parsedBody = parsedOutput.body;
2657
- const $metadata = deserializeMetadata(output);
2658
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
2659
- response = new AppMeshServiceException_1.AppMeshServiceException({
2660
- name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
2661
- $fault: "client",
2662
- $metadata,
2026
+ (0, smithy_client_1.throwDefaultError)({
2027
+ output,
2028
+ parsedBody,
2029
+ exceptionCtor: AppMeshServiceException_1.AppMeshServiceException,
2030
+ errorCode,
2663
2031
  });
2664
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
2665
2032
  }
2666
2033
  };
2667
2034
  const deserializeAws_restJson1ListGatewayRoutesCommand = async (output, context) => {
2668
2035
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2669
2036
  return deserializeAws_restJson1ListGatewayRoutesCommandError(output, context);
2670
2037
  }
2671
- const contents = {
2038
+ const contents = map({
2672
2039
  $metadata: deserializeMetadata(output),
2673
- gatewayRoutes: undefined,
2674
- nextToken: undefined,
2675
- };
2040
+ });
2676
2041
  const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
2677
- if (data.gatewayRoutes !== undefined && data.gatewayRoutes !== null) {
2042
+ if (data.gatewayRoutes != null) {
2678
2043
  contents.gatewayRoutes = deserializeAws_restJson1GatewayRouteList(data.gatewayRoutes, context);
2679
2044
  }
2680
- if (data.nextToken !== undefined && data.nextToken !== null) {
2045
+ if (data.nextToken != null) {
2681
2046
  contents.nextToken = (0, smithy_client_1.expectString)(data.nextToken);
2682
2047
  }
2683
- return Promise.resolve(contents);
2048
+ return contents;
2684
2049
  };
2685
2050
  exports.deserializeAws_restJson1ListGatewayRoutesCommand = deserializeAws_restJson1ListGatewayRoutesCommand;
2686
2051
  const deserializeAws_restJson1ListGatewayRoutesCommandError = async (output, context) => {
@@ -2688,7 +2053,6 @@ const deserializeAws_restJson1ListGatewayRoutesCommandError = async (output, con
2688
2053
  ...output,
2689
2054
  body: await parseBody(output.body, context),
2690
2055
  };
2691
- let response;
2692
2056
  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2693
2057
  switch (errorCode) {
2694
2058
  case "BadRequestException":
@@ -2711,33 +2075,29 @@ const deserializeAws_restJson1ListGatewayRoutesCommandError = async (output, con
2711
2075
  throw await deserializeAws_restJson1TooManyRequestsExceptionResponse(parsedOutput, context);
2712
2076
  default:
2713
2077
  const parsedBody = parsedOutput.body;
2714
- const $metadata = deserializeMetadata(output);
2715
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
2716
- response = new AppMeshServiceException_1.AppMeshServiceException({
2717
- name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
2718
- $fault: "client",
2719
- $metadata,
2078
+ (0, smithy_client_1.throwDefaultError)({
2079
+ output,
2080
+ parsedBody,
2081
+ exceptionCtor: AppMeshServiceException_1.AppMeshServiceException,
2082
+ errorCode,
2720
2083
  });
2721
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
2722
2084
  }
2723
2085
  };
2724
2086
  const deserializeAws_restJson1ListMeshesCommand = async (output, context) => {
2725
2087
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2726
2088
  return deserializeAws_restJson1ListMeshesCommandError(output, context);
2727
2089
  }
2728
- const contents = {
2090
+ const contents = map({
2729
2091
  $metadata: deserializeMetadata(output),
2730
- meshes: undefined,
2731
- nextToken: undefined,
2732
- };
2092
+ });
2733
2093
  const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
2734
- if (data.meshes !== undefined && data.meshes !== null) {
2094
+ if (data.meshes != null) {
2735
2095
  contents.meshes = deserializeAws_restJson1MeshList(data.meshes, context);
2736
2096
  }
2737
- if (data.nextToken !== undefined && data.nextToken !== null) {
2097
+ if (data.nextToken != null) {
2738
2098
  contents.nextToken = (0, smithy_client_1.expectString)(data.nextToken);
2739
2099
  }
2740
- return Promise.resolve(contents);
2100
+ return contents;
2741
2101
  };
2742
2102
  exports.deserializeAws_restJson1ListMeshesCommand = deserializeAws_restJson1ListMeshesCommand;
2743
2103
  const deserializeAws_restJson1ListMeshesCommandError = async (output, context) => {
@@ -2745,7 +2105,6 @@ const deserializeAws_restJson1ListMeshesCommandError = async (output, context) =
2745
2105
  ...output,
2746
2106
  body: await parseBody(output.body, context),
2747
2107
  };
2748
- let response;
2749
2108
  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2750
2109
  switch (errorCode) {
2751
2110
  case "BadRequestException":
@@ -2768,33 +2127,29 @@ const deserializeAws_restJson1ListMeshesCommandError = async (output, context) =
2768
2127
  throw await deserializeAws_restJson1TooManyRequestsExceptionResponse(parsedOutput, context);
2769
2128
  default:
2770
2129
  const parsedBody = parsedOutput.body;
2771
- const $metadata = deserializeMetadata(output);
2772
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
2773
- response = new AppMeshServiceException_1.AppMeshServiceException({
2774
- name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
2775
- $fault: "client",
2776
- $metadata,
2130
+ (0, smithy_client_1.throwDefaultError)({
2131
+ output,
2132
+ parsedBody,
2133
+ exceptionCtor: AppMeshServiceException_1.AppMeshServiceException,
2134
+ errorCode,
2777
2135
  });
2778
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
2779
2136
  }
2780
2137
  };
2781
2138
  const deserializeAws_restJson1ListRoutesCommand = async (output, context) => {
2782
2139
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2783
2140
  return deserializeAws_restJson1ListRoutesCommandError(output, context);
2784
2141
  }
2785
- const contents = {
2142
+ const contents = map({
2786
2143
  $metadata: deserializeMetadata(output),
2787
- nextToken: undefined,
2788
- routes: undefined,
2789
- };
2144
+ });
2790
2145
  const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
2791
- if (data.nextToken !== undefined && data.nextToken !== null) {
2146
+ if (data.nextToken != null) {
2792
2147
  contents.nextToken = (0, smithy_client_1.expectString)(data.nextToken);
2793
2148
  }
2794
- if (data.routes !== undefined && data.routes !== null) {
2149
+ if (data.routes != null) {
2795
2150
  contents.routes = deserializeAws_restJson1RouteList(data.routes, context);
2796
2151
  }
2797
- return Promise.resolve(contents);
2152
+ return contents;
2798
2153
  };
2799
2154
  exports.deserializeAws_restJson1ListRoutesCommand = deserializeAws_restJson1ListRoutesCommand;
2800
2155
  const deserializeAws_restJson1ListRoutesCommandError = async (output, context) => {
@@ -2802,7 +2157,6 @@ const deserializeAws_restJson1ListRoutesCommandError = async (output, context) =
2802
2157
  ...output,
2803
2158
  body: await parseBody(output.body, context),
2804
2159
  };
2805
- let response;
2806
2160
  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2807
2161
  switch (errorCode) {
2808
2162
  case "BadRequestException":
@@ -2825,33 +2179,29 @@ const deserializeAws_restJson1ListRoutesCommandError = async (output, context) =
2825
2179
  throw await deserializeAws_restJson1TooManyRequestsExceptionResponse(parsedOutput, context);
2826
2180
  default:
2827
2181
  const parsedBody = parsedOutput.body;
2828
- const $metadata = deserializeMetadata(output);
2829
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
2830
- response = new AppMeshServiceException_1.AppMeshServiceException({
2831
- name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
2832
- $fault: "client",
2833
- $metadata,
2182
+ (0, smithy_client_1.throwDefaultError)({
2183
+ output,
2184
+ parsedBody,
2185
+ exceptionCtor: AppMeshServiceException_1.AppMeshServiceException,
2186
+ errorCode,
2834
2187
  });
2835
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
2836
2188
  }
2837
2189
  };
2838
2190
  const deserializeAws_restJson1ListTagsForResourceCommand = async (output, context) => {
2839
2191
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2840
2192
  return deserializeAws_restJson1ListTagsForResourceCommandError(output, context);
2841
2193
  }
2842
- const contents = {
2194
+ const contents = map({
2843
2195
  $metadata: deserializeMetadata(output),
2844
- nextToken: undefined,
2845
- tags: undefined,
2846
- };
2196
+ });
2847
2197
  const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
2848
- if (data.nextToken !== undefined && data.nextToken !== null) {
2198
+ if (data.nextToken != null) {
2849
2199
  contents.nextToken = (0, smithy_client_1.expectString)(data.nextToken);
2850
2200
  }
2851
- if (data.tags !== undefined && data.tags !== null) {
2201
+ if (data.tags != null) {
2852
2202
  contents.tags = deserializeAws_restJson1TagList(data.tags, context);
2853
2203
  }
2854
- return Promise.resolve(contents);
2204
+ return contents;
2855
2205
  };
2856
2206
  exports.deserializeAws_restJson1ListTagsForResourceCommand = deserializeAws_restJson1ListTagsForResourceCommand;
2857
2207
  const deserializeAws_restJson1ListTagsForResourceCommandError = async (output, context) => {
@@ -2859,7 +2209,6 @@ const deserializeAws_restJson1ListTagsForResourceCommandError = async (output, c
2859
2209
  ...output,
2860
2210
  body: await parseBody(output.body, context),
2861
2211
  };
2862
- let response;
2863
2212
  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2864
2213
  switch (errorCode) {
2865
2214
  case "BadRequestException":
@@ -2882,33 +2231,29 @@ const deserializeAws_restJson1ListTagsForResourceCommandError = async (output, c
2882
2231
  throw await deserializeAws_restJson1TooManyRequestsExceptionResponse(parsedOutput, context);
2883
2232
  default:
2884
2233
  const parsedBody = parsedOutput.body;
2885
- const $metadata = deserializeMetadata(output);
2886
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
2887
- response = new AppMeshServiceException_1.AppMeshServiceException({
2888
- name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
2889
- $fault: "client",
2890
- $metadata,
2234
+ (0, smithy_client_1.throwDefaultError)({
2235
+ output,
2236
+ parsedBody,
2237
+ exceptionCtor: AppMeshServiceException_1.AppMeshServiceException,
2238
+ errorCode,
2891
2239
  });
2892
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
2893
2240
  }
2894
2241
  };
2895
2242
  const deserializeAws_restJson1ListVirtualGatewaysCommand = async (output, context) => {
2896
2243
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2897
2244
  return deserializeAws_restJson1ListVirtualGatewaysCommandError(output, context);
2898
2245
  }
2899
- const contents = {
2246
+ const contents = map({
2900
2247
  $metadata: deserializeMetadata(output),
2901
- nextToken: undefined,
2902
- virtualGateways: undefined,
2903
- };
2248
+ });
2904
2249
  const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
2905
- if (data.nextToken !== undefined && data.nextToken !== null) {
2250
+ if (data.nextToken != null) {
2906
2251
  contents.nextToken = (0, smithy_client_1.expectString)(data.nextToken);
2907
2252
  }
2908
- if (data.virtualGateways !== undefined && data.virtualGateways !== null) {
2253
+ if (data.virtualGateways != null) {
2909
2254
  contents.virtualGateways = deserializeAws_restJson1VirtualGatewayList(data.virtualGateways, context);
2910
2255
  }
2911
- return Promise.resolve(contents);
2256
+ return contents;
2912
2257
  };
2913
2258
  exports.deserializeAws_restJson1ListVirtualGatewaysCommand = deserializeAws_restJson1ListVirtualGatewaysCommand;
2914
2259
  const deserializeAws_restJson1ListVirtualGatewaysCommandError = async (output, context) => {
@@ -2916,7 +2261,6 @@ const deserializeAws_restJson1ListVirtualGatewaysCommandError = async (output, c
2916
2261
  ...output,
2917
2262
  body: await parseBody(output.body, context),
2918
2263
  };
2919
- let response;
2920
2264
  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2921
2265
  switch (errorCode) {
2922
2266
  case "BadRequestException":
@@ -2939,33 +2283,29 @@ const deserializeAws_restJson1ListVirtualGatewaysCommandError = async (output, c
2939
2283
  throw await deserializeAws_restJson1TooManyRequestsExceptionResponse(parsedOutput, context);
2940
2284
  default:
2941
2285
  const parsedBody = parsedOutput.body;
2942
- const $metadata = deserializeMetadata(output);
2943
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
2944
- response = new AppMeshServiceException_1.AppMeshServiceException({
2945
- name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
2946
- $fault: "client",
2947
- $metadata,
2286
+ (0, smithy_client_1.throwDefaultError)({
2287
+ output,
2288
+ parsedBody,
2289
+ exceptionCtor: AppMeshServiceException_1.AppMeshServiceException,
2290
+ errorCode,
2948
2291
  });
2949
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
2950
2292
  }
2951
2293
  };
2952
2294
  const deserializeAws_restJson1ListVirtualNodesCommand = async (output, context) => {
2953
2295
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2954
2296
  return deserializeAws_restJson1ListVirtualNodesCommandError(output, context);
2955
2297
  }
2956
- const contents = {
2298
+ const contents = map({
2957
2299
  $metadata: deserializeMetadata(output),
2958
- nextToken: undefined,
2959
- virtualNodes: undefined,
2960
- };
2300
+ });
2961
2301
  const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
2962
- if (data.nextToken !== undefined && data.nextToken !== null) {
2302
+ if (data.nextToken != null) {
2963
2303
  contents.nextToken = (0, smithy_client_1.expectString)(data.nextToken);
2964
2304
  }
2965
- if (data.virtualNodes !== undefined && data.virtualNodes !== null) {
2305
+ if (data.virtualNodes != null) {
2966
2306
  contents.virtualNodes = deserializeAws_restJson1VirtualNodeList(data.virtualNodes, context);
2967
2307
  }
2968
- return Promise.resolve(contents);
2308
+ return contents;
2969
2309
  };
2970
2310
  exports.deserializeAws_restJson1ListVirtualNodesCommand = deserializeAws_restJson1ListVirtualNodesCommand;
2971
2311
  const deserializeAws_restJson1ListVirtualNodesCommandError = async (output, context) => {
@@ -2973,7 +2313,6 @@ const deserializeAws_restJson1ListVirtualNodesCommandError = async (output, cont
2973
2313
  ...output,
2974
2314
  body: await parseBody(output.body, context),
2975
2315
  };
2976
- let response;
2977
2316
  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2978
2317
  switch (errorCode) {
2979
2318
  case "BadRequestException":
@@ -2996,33 +2335,29 @@ const deserializeAws_restJson1ListVirtualNodesCommandError = async (output, cont
2996
2335
  throw await deserializeAws_restJson1TooManyRequestsExceptionResponse(parsedOutput, context);
2997
2336
  default:
2998
2337
  const parsedBody = parsedOutput.body;
2999
- const $metadata = deserializeMetadata(output);
3000
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
3001
- response = new AppMeshServiceException_1.AppMeshServiceException({
3002
- name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
3003
- $fault: "client",
3004
- $metadata,
2338
+ (0, smithy_client_1.throwDefaultError)({
2339
+ output,
2340
+ parsedBody,
2341
+ exceptionCtor: AppMeshServiceException_1.AppMeshServiceException,
2342
+ errorCode,
3005
2343
  });
3006
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
3007
2344
  }
3008
2345
  };
3009
2346
  const deserializeAws_restJson1ListVirtualRoutersCommand = async (output, context) => {
3010
2347
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3011
2348
  return deserializeAws_restJson1ListVirtualRoutersCommandError(output, context);
3012
2349
  }
3013
- const contents = {
2350
+ const contents = map({
3014
2351
  $metadata: deserializeMetadata(output),
3015
- nextToken: undefined,
3016
- virtualRouters: undefined,
3017
- };
2352
+ });
3018
2353
  const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
3019
- if (data.nextToken !== undefined && data.nextToken !== null) {
2354
+ if (data.nextToken != null) {
3020
2355
  contents.nextToken = (0, smithy_client_1.expectString)(data.nextToken);
3021
2356
  }
3022
- if (data.virtualRouters !== undefined && data.virtualRouters !== null) {
2357
+ if (data.virtualRouters != null) {
3023
2358
  contents.virtualRouters = deserializeAws_restJson1VirtualRouterList(data.virtualRouters, context);
3024
2359
  }
3025
- return Promise.resolve(contents);
2360
+ return contents;
3026
2361
  };
3027
2362
  exports.deserializeAws_restJson1ListVirtualRoutersCommand = deserializeAws_restJson1ListVirtualRoutersCommand;
3028
2363
  const deserializeAws_restJson1ListVirtualRoutersCommandError = async (output, context) => {
@@ -3030,7 +2365,6 @@ const deserializeAws_restJson1ListVirtualRoutersCommandError = async (output, co
3030
2365
  ...output,
3031
2366
  body: await parseBody(output.body, context),
3032
2367
  };
3033
- let response;
3034
2368
  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3035
2369
  switch (errorCode) {
3036
2370
  case "BadRequestException":
@@ -3053,33 +2387,29 @@ const deserializeAws_restJson1ListVirtualRoutersCommandError = async (output, co
3053
2387
  throw await deserializeAws_restJson1TooManyRequestsExceptionResponse(parsedOutput, context);
3054
2388
  default:
3055
2389
  const parsedBody = parsedOutput.body;
3056
- const $metadata = deserializeMetadata(output);
3057
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
3058
- response = new AppMeshServiceException_1.AppMeshServiceException({
3059
- name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
3060
- $fault: "client",
3061
- $metadata,
2390
+ (0, smithy_client_1.throwDefaultError)({
2391
+ output,
2392
+ parsedBody,
2393
+ exceptionCtor: AppMeshServiceException_1.AppMeshServiceException,
2394
+ errorCode,
3062
2395
  });
3063
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
3064
2396
  }
3065
2397
  };
3066
2398
  const deserializeAws_restJson1ListVirtualServicesCommand = async (output, context) => {
3067
2399
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3068
2400
  return deserializeAws_restJson1ListVirtualServicesCommandError(output, context);
3069
2401
  }
3070
- const contents = {
2402
+ const contents = map({
3071
2403
  $metadata: deserializeMetadata(output),
3072
- nextToken: undefined,
3073
- virtualServices: undefined,
3074
- };
2404
+ });
3075
2405
  const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
3076
- if (data.nextToken !== undefined && data.nextToken !== null) {
2406
+ if (data.nextToken != null) {
3077
2407
  contents.nextToken = (0, smithy_client_1.expectString)(data.nextToken);
3078
2408
  }
3079
- if (data.virtualServices !== undefined && data.virtualServices !== null) {
2409
+ if (data.virtualServices != null) {
3080
2410
  contents.virtualServices = deserializeAws_restJson1VirtualServiceList(data.virtualServices, context);
3081
2411
  }
3082
- return Promise.resolve(contents);
2412
+ return contents;
3083
2413
  };
3084
2414
  exports.deserializeAws_restJson1ListVirtualServicesCommand = deserializeAws_restJson1ListVirtualServicesCommand;
3085
2415
  const deserializeAws_restJson1ListVirtualServicesCommandError = async (output, context) => {
@@ -3087,7 +2417,6 @@ const deserializeAws_restJson1ListVirtualServicesCommandError = async (output, c
3087
2417
  ...output,
3088
2418
  body: await parseBody(output.body, context),
3089
2419
  };
3090
- let response;
3091
2420
  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3092
2421
  switch (errorCode) {
3093
2422
  case "BadRequestException":
@@ -3110,25 +2439,23 @@ const deserializeAws_restJson1ListVirtualServicesCommandError = async (output, c
3110
2439
  throw await deserializeAws_restJson1TooManyRequestsExceptionResponse(parsedOutput, context);
3111
2440
  default:
3112
2441
  const parsedBody = parsedOutput.body;
3113
- const $metadata = deserializeMetadata(output);
3114
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
3115
- response = new AppMeshServiceException_1.AppMeshServiceException({
3116
- name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
3117
- $fault: "client",
3118
- $metadata,
2442
+ (0, smithy_client_1.throwDefaultError)({
2443
+ output,
2444
+ parsedBody,
2445
+ exceptionCtor: AppMeshServiceException_1.AppMeshServiceException,
2446
+ errorCode,
3119
2447
  });
3120
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
3121
2448
  }
3122
2449
  };
3123
2450
  const deserializeAws_restJson1TagResourceCommand = async (output, context) => {
3124
2451
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3125
2452
  return deserializeAws_restJson1TagResourceCommandError(output, context);
3126
2453
  }
3127
- const contents = {
2454
+ const contents = map({
3128
2455
  $metadata: deserializeMetadata(output),
3129
- };
2456
+ });
3130
2457
  await collectBody(output.body, context);
3131
- return Promise.resolve(contents);
2458
+ return contents;
3132
2459
  };
3133
2460
  exports.deserializeAws_restJson1TagResourceCommand = deserializeAws_restJson1TagResourceCommand;
3134
2461
  const deserializeAws_restJson1TagResourceCommandError = async (output, context) => {
@@ -3136,7 +2463,6 @@ const deserializeAws_restJson1TagResourceCommandError = async (output, context)
3136
2463
  ...output,
3137
2464
  body: await parseBody(output.body, context),
3138
2465
  };
3139
- let response;
3140
2466
  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3141
2467
  switch (errorCode) {
3142
2468
  case "BadRequestException":
@@ -3162,25 +2488,23 @@ const deserializeAws_restJson1TagResourceCommandError = async (output, context)
3162
2488
  throw await deserializeAws_restJson1TooManyTagsExceptionResponse(parsedOutput, context);
3163
2489
  default:
3164
2490
  const parsedBody = parsedOutput.body;
3165
- const $metadata = deserializeMetadata(output);
3166
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
3167
- response = new AppMeshServiceException_1.AppMeshServiceException({
3168
- name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
3169
- $fault: "client",
3170
- $metadata,
2491
+ (0, smithy_client_1.throwDefaultError)({
2492
+ output,
2493
+ parsedBody,
2494
+ exceptionCtor: AppMeshServiceException_1.AppMeshServiceException,
2495
+ errorCode,
3171
2496
  });
3172
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
3173
2497
  }
3174
2498
  };
3175
2499
  const deserializeAws_restJson1UntagResourceCommand = async (output, context) => {
3176
2500
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3177
2501
  return deserializeAws_restJson1UntagResourceCommandError(output, context);
3178
2502
  }
3179
- const contents = {
2503
+ const contents = map({
3180
2504
  $metadata: deserializeMetadata(output),
3181
- };
2505
+ });
3182
2506
  await collectBody(output.body, context);
3183
- return Promise.resolve(contents);
2507
+ return contents;
3184
2508
  };
3185
2509
  exports.deserializeAws_restJson1UntagResourceCommand = deserializeAws_restJson1UntagResourceCommand;
3186
2510
  const deserializeAws_restJson1UntagResourceCommandError = async (output, context) => {
@@ -3188,7 +2512,6 @@ const deserializeAws_restJson1UntagResourceCommandError = async (output, context
3188
2512
  ...output,
3189
2513
  body: await parseBody(output.body, context),
3190
2514
  };
3191
- let response;
3192
2515
  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3193
2516
  switch (errorCode) {
3194
2517
  case "BadRequestException":
@@ -3211,27 +2534,24 @@ const deserializeAws_restJson1UntagResourceCommandError = async (output, context
3211
2534
  throw await deserializeAws_restJson1TooManyRequestsExceptionResponse(parsedOutput, context);
3212
2535
  default:
3213
2536
  const parsedBody = parsedOutput.body;
3214
- const $metadata = deserializeMetadata(output);
3215
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
3216
- response = new AppMeshServiceException_1.AppMeshServiceException({
3217
- name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
3218
- $fault: "client",
3219
- $metadata,
2537
+ (0, smithy_client_1.throwDefaultError)({
2538
+ output,
2539
+ parsedBody,
2540
+ exceptionCtor: AppMeshServiceException_1.AppMeshServiceException,
2541
+ errorCode,
3220
2542
  });
3221
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
3222
2543
  }
3223
2544
  };
3224
2545
  const deserializeAws_restJson1UpdateGatewayRouteCommand = async (output, context) => {
3225
2546
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3226
2547
  return deserializeAws_restJson1UpdateGatewayRouteCommandError(output, context);
3227
2548
  }
3228
- const contents = {
2549
+ const contents = map({
3229
2550
  $metadata: deserializeMetadata(output),
3230
- gatewayRoute: undefined,
3231
- };
2551
+ });
3232
2552
  const data = (0, smithy_client_1.expectObject)(await parseBody(output.body, context));
3233
2553
  contents.gatewayRoute = deserializeAws_restJson1GatewayRouteData(data, context);
3234
- return Promise.resolve(contents);
2554
+ return contents;
3235
2555
  };
3236
2556
  exports.deserializeAws_restJson1UpdateGatewayRouteCommand = deserializeAws_restJson1UpdateGatewayRouteCommand;
3237
2557
  const deserializeAws_restJson1UpdateGatewayRouteCommandError = async (output, context) => {
@@ -3239,7 +2559,6 @@ const deserializeAws_restJson1UpdateGatewayRouteCommandError = async (output, co
3239
2559
  ...output,
3240
2560
  body: await parseBody(output.body, context),
3241
2561
  };
3242
- let response;
3243
2562
  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3244
2563
  switch (errorCode) {
3245
2564
  case "BadRequestException":
@@ -3268,27 +2587,24 @@ const deserializeAws_restJson1UpdateGatewayRouteCommandError = async (output, co
3268
2587
  throw await deserializeAws_restJson1TooManyRequestsExceptionResponse(parsedOutput, context);
3269
2588
  default:
3270
2589
  const parsedBody = parsedOutput.body;
3271
- const $metadata = deserializeMetadata(output);
3272
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
3273
- response = new AppMeshServiceException_1.AppMeshServiceException({
3274
- name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
3275
- $fault: "client",
3276
- $metadata,
2590
+ (0, smithy_client_1.throwDefaultError)({
2591
+ output,
2592
+ parsedBody,
2593
+ exceptionCtor: AppMeshServiceException_1.AppMeshServiceException,
2594
+ errorCode,
3277
2595
  });
3278
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
3279
2596
  }
3280
2597
  };
3281
2598
  const deserializeAws_restJson1UpdateMeshCommand = async (output, context) => {
3282
2599
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3283
2600
  return deserializeAws_restJson1UpdateMeshCommandError(output, context);
3284
2601
  }
3285
- const contents = {
2602
+ const contents = map({
3286
2603
  $metadata: deserializeMetadata(output),
3287
- mesh: undefined,
3288
- };
2604
+ });
3289
2605
  const data = (0, smithy_client_1.expectObject)(await parseBody(output.body, context));
3290
2606
  contents.mesh = deserializeAws_restJson1MeshData(data, context);
3291
- return Promise.resolve(contents);
2607
+ return contents;
3292
2608
  };
3293
2609
  exports.deserializeAws_restJson1UpdateMeshCommand = deserializeAws_restJson1UpdateMeshCommand;
3294
2610
  const deserializeAws_restJson1UpdateMeshCommandError = async (output, context) => {
@@ -3296,7 +2612,6 @@ const deserializeAws_restJson1UpdateMeshCommandError = async (output, context) =
3296
2612
  ...output,
3297
2613
  body: await parseBody(output.body, context),
3298
2614
  };
3299
- let response;
3300
2615
  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3301
2616
  switch (errorCode) {
3302
2617
  case "BadRequestException":
@@ -3322,27 +2637,24 @@ const deserializeAws_restJson1UpdateMeshCommandError = async (output, context) =
3322
2637
  throw await deserializeAws_restJson1TooManyRequestsExceptionResponse(parsedOutput, context);
3323
2638
  default:
3324
2639
  const parsedBody = parsedOutput.body;
3325
- const $metadata = deserializeMetadata(output);
3326
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
3327
- response = new AppMeshServiceException_1.AppMeshServiceException({
3328
- name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
3329
- $fault: "client",
3330
- $metadata,
2640
+ (0, smithy_client_1.throwDefaultError)({
2641
+ output,
2642
+ parsedBody,
2643
+ exceptionCtor: AppMeshServiceException_1.AppMeshServiceException,
2644
+ errorCode,
3331
2645
  });
3332
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
3333
2646
  }
3334
2647
  };
3335
2648
  const deserializeAws_restJson1UpdateRouteCommand = async (output, context) => {
3336
2649
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3337
2650
  return deserializeAws_restJson1UpdateRouteCommandError(output, context);
3338
2651
  }
3339
- const contents = {
2652
+ const contents = map({
3340
2653
  $metadata: deserializeMetadata(output),
3341
- route: undefined,
3342
- };
2654
+ });
3343
2655
  const data = (0, smithy_client_1.expectObject)(await parseBody(output.body, context));
3344
2656
  contents.route = deserializeAws_restJson1RouteData(data, context);
3345
- return Promise.resolve(contents);
2657
+ return contents;
3346
2658
  };
3347
2659
  exports.deserializeAws_restJson1UpdateRouteCommand = deserializeAws_restJson1UpdateRouteCommand;
3348
2660
  const deserializeAws_restJson1UpdateRouteCommandError = async (output, context) => {
@@ -3350,7 +2662,6 @@ const deserializeAws_restJson1UpdateRouteCommandError = async (output, context)
3350
2662
  ...output,
3351
2663
  body: await parseBody(output.body, context),
3352
2664
  };
3353
- let response;
3354
2665
  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3355
2666
  switch (errorCode) {
3356
2667
  case "BadRequestException":
@@ -3379,27 +2690,24 @@ const deserializeAws_restJson1UpdateRouteCommandError = async (output, context)
3379
2690
  throw await deserializeAws_restJson1TooManyRequestsExceptionResponse(parsedOutput, context);
3380
2691
  default:
3381
2692
  const parsedBody = parsedOutput.body;
3382
- const $metadata = deserializeMetadata(output);
3383
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
3384
- response = new AppMeshServiceException_1.AppMeshServiceException({
3385
- name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
3386
- $fault: "client",
3387
- $metadata,
2693
+ (0, smithy_client_1.throwDefaultError)({
2694
+ output,
2695
+ parsedBody,
2696
+ exceptionCtor: AppMeshServiceException_1.AppMeshServiceException,
2697
+ errorCode,
3388
2698
  });
3389
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
3390
2699
  }
3391
2700
  };
3392
2701
  const deserializeAws_restJson1UpdateVirtualGatewayCommand = async (output, context) => {
3393
2702
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3394
2703
  return deserializeAws_restJson1UpdateVirtualGatewayCommandError(output, context);
3395
2704
  }
3396
- const contents = {
2705
+ const contents = map({
3397
2706
  $metadata: deserializeMetadata(output),
3398
- virtualGateway: undefined,
3399
- };
2707
+ });
3400
2708
  const data = (0, smithy_client_1.expectObject)(await parseBody(output.body, context));
3401
2709
  contents.virtualGateway = deserializeAws_restJson1VirtualGatewayData(data, context);
3402
- return Promise.resolve(contents);
2710
+ return contents;
3403
2711
  };
3404
2712
  exports.deserializeAws_restJson1UpdateVirtualGatewayCommand = deserializeAws_restJson1UpdateVirtualGatewayCommand;
3405
2713
  const deserializeAws_restJson1UpdateVirtualGatewayCommandError = async (output, context) => {
@@ -3407,7 +2715,6 @@ const deserializeAws_restJson1UpdateVirtualGatewayCommandError = async (output,
3407
2715
  ...output,
3408
2716
  body: await parseBody(output.body, context),
3409
2717
  };
3410
- let response;
3411
2718
  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3412
2719
  switch (errorCode) {
3413
2720
  case "BadRequestException":
@@ -3436,27 +2743,24 @@ const deserializeAws_restJson1UpdateVirtualGatewayCommandError = async (output,
3436
2743
  throw await deserializeAws_restJson1TooManyRequestsExceptionResponse(parsedOutput, context);
3437
2744
  default:
3438
2745
  const parsedBody = parsedOutput.body;
3439
- const $metadata = deserializeMetadata(output);
3440
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
3441
- response = new AppMeshServiceException_1.AppMeshServiceException({
3442
- name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
3443
- $fault: "client",
3444
- $metadata,
2746
+ (0, smithy_client_1.throwDefaultError)({
2747
+ output,
2748
+ parsedBody,
2749
+ exceptionCtor: AppMeshServiceException_1.AppMeshServiceException,
2750
+ errorCode,
3445
2751
  });
3446
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
3447
2752
  }
3448
2753
  };
3449
2754
  const deserializeAws_restJson1UpdateVirtualNodeCommand = async (output, context) => {
3450
2755
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3451
2756
  return deserializeAws_restJson1UpdateVirtualNodeCommandError(output, context);
3452
2757
  }
3453
- const contents = {
2758
+ const contents = map({
3454
2759
  $metadata: deserializeMetadata(output),
3455
- virtualNode: undefined,
3456
- };
2760
+ });
3457
2761
  const data = (0, smithy_client_1.expectObject)(await parseBody(output.body, context));
3458
2762
  contents.virtualNode = deserializeAws_restJson1VirtualNodeData(data, context);
3459
- return Promise.resolve(contents);
2763
+ return contents;
3460
2764
  };
3461
2765
  exports.deserializeAws_restJson1UpdateVirtualNodeCommand = deserializeAws_restJson1UpdateVirtualNodeCommand;
3462
2766
  const deserializeAws_restJson1UpdateVirtualNodeCommandError = async (output, context) => {
@@ -3464,7 +2768,6 @@ const deserializeAws_restJson1UpdateVirtualNodeCommandError = async (output, con
3464
2768
  ...output,
3465
2769
  body: await parseBody(output.body, context),
3466
2770
  };
3467
- let response;
3468
2771
  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3469
2772
  switch (errorCode) {
3470
2773
  case "BadRequestException":
@@ -3493,27 +2796,24 @@ const deserializeAws_restJson1UpdateVirtualNodeCommandError = async (output, con
3493
2796
  throw await deserializeAws_restJson1TooManyRequestsExceptionResponse(parsedOutput, context);
3494
2797
  default:
3495
2798
  const parsedBody = parsedOutput.body;
3496
- const $metadata = deserializeMetadata(output);
3497
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
3498
- response = new AppMeshServiceException_1.AppMeshServiceException({
3499
- name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
3500
- $fault: "client",
3501
- $metadata,
2799
+ (0, smithy_client_1.throwDefaultError)({
2800
+ output,
2801
+ parsedBody,
2802
+ exceptionCtor: AppMeshServiceException_1.AppMeshServiceException,
2803
+ errorCode,
3502
2804
  });
3503
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
3504
2805
  }
3505
2806
  };
3506
2807
  const deserializeAws_restJson1UpdateVirtualRouterCommand = async (output, context) => {
3507
2808
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3508
2809
  return deserializeAws_restJson1UpdateVirtualRouterCommandError(output, context);
3509
2810
  }
3510
- const contents = {
2811
+ const contents = map({
3511
2812
  $metadata: deserializeMetadata(output),
3512
- virtualRouter: undefined,
3513
- };
2813
+ });
3514
2814
  const data = (0, smithy_client_1.expectObject)(await parseBody(output.body, context));
3515
2815
  contents.virtualRouter = deserializeAws_restJson1VirtualRouterData(data, context);
3516
- return Promise.resolve(contents);
2816
+ return contents;
3517
2817
  };
3518
2818
  exports.deserializeAws_restJson1UpdateVirtualRouterCommand = deserializeAws_restJson1UpdateVirtualRouterCommand;
3519
2819
  const deserializeAws_restJson1UpdateVirtualRouterCommandError = async (output, context) => {
@@ -3521,7 +2821,6 @@ const deserializeAws_restJson1UpdateVirtualRouterCommandError = async (output, c
3521
2821
  ...output,
3522
2822
  body: await parseBody(output.body, context),
3523
2823
  };
3524
- let response;
3525
2824
  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3526
2825
  switch (errorCode) {
3527
2826
  case "BadRequestException":
@@ -3550,27 +2849,24 @@ const deserializeAws_restJson1UpdateVirtualRouterCommandError = async (output, c
3550
2849
  throw await deserializeAws_restJson1TooManyRequestsExceptionResponse(parsedOutput, context);
3551
2850
  default:
3552
2851
  const parsedBody = parsedOutput.body;
3553
- const $metadata = deserializeMetadata(output);
3554
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
3555
- response = new AppMeshServiceException_1.AppMeshServiceException({
3556
- name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
3557
- $fault: "client",
3558
- $metadata,
2852
+ (0, smithy_client_1.throwDefaultError)({
2853
+ output,
2854
+ parsedBody,
2855
+ exceptionCtor: AppMeshServiceException_1.AppMeshServiceException,
2856
+ errorCode,
3559
2857
  });
3560
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
3561
2858
  }
3562
2859
  };
3563
2860
  const deserializeAws_restJson1UpdateVirtualServiceCommand = async (output, context) => {
3564
2861
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3565
2862
  return deserializeAws_restJson1UpdateVirtualServiceCommandError(output, context);
3566
2863
  }
3567
- const contents = {
2864
+ const contents = map({
3568
2865
  $metadata: deserializeMetadata(output),
3569
- virtualService: undefined,
3570
- };
2866
+ });
3571
2867
  const data = (0, smithy_client_1.expectObject)(await parseBody(output.body, context));
3572
2868
  contents.virtualService = deserializeAws_restJson1VirtualServiceData(data, context);
3573
- return Promise.resolve(contents);
2869
+ return contents;
3574
2870
  };
3575
2871
  exports.deserializeAws_restJson1UpdateVirtualServiceCommand = deserializeAws_restJson1UpdateVirtualServiceCommand;
3576
2872
  const deserializeAws_restJson1UpdateVirtualServiceCommandError = async (output, context) => {
@@ -3578,7 +2874,6 @@ const deserializeAws_restJson1UpdateVirtualServiceCommandError = async (output,
3578
2874
  ...output,
3579
2875
  body: await parseBody(output.body, context),
3580
2876
  };
3581
- let response;
3582
2877
  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3583
2878
  switch (errorCode) {
3584
2879
  case "BadRequestException":
@@ -3607,20 +2902,19 @@ const deserializeAws_restJson1UpdateVirtualServiceCommandError = async (output,
3607
2902
  throw await deserializeAws_restJson1TooManyRequestsExceptionResponse(parsedOutput, context);
3608
2903
  default:
3609
2904
  const parsedBody = parsedOutput.body;
3610
- const $metadata = deserializeMetadata(output);
3611
- const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
3612
- response = new AppMeshServiceException_1.AppMeshServiceException({
3613
- name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
3614
- $fault: "client",
3615
- $metadata,
2905
+ (0, smithy_client_1.throwDefaultError)({
2906
+ output,
2907
+ parsedBody,
2908
+ exceptionCtor: AppMeshServiceException_1.AppMeshServiceException,
2909
+ errorCode,
3616
2910
  });
3617
- throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
3618
2911
  }
3619
2912
  };
2913
+ const map = smithy_client_1.map;
3620
2914
  const deserializeAws_restJson1BadRequestExceptionResponse = async (parsedOutput, context) => {
3621
- const contents = {};
2915
+ const contents = map({});
3622
2916
  const data = parsedOutput.body;
3623
- if (data.message !== undefined && data.message !== null) {
2917
+ if (data.message != null) {
3624
2918
  contents.message = (0, smithy_client_1.expectString)(data.message);
3625
2919
  }
3626
2920
  const exception = new models_0_1.BadRequestException({
@@ -3630,9 +2924,9 @@ const deserializeAws_restJson1BadRequestExceptionResponse = async (parsedOutput,
3630
2924
  return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
3631
2925
  };
3632
2926
  const deserializeAws_restJson1ConflictExceptionResponse = async (parsedOutput, context) => {
3633
- const contents = {};
2927
+ const contents = map({});
3634
2928
  const data = parsedOutput.body;
3635
- if (data.message !== undefined && data.message !== null) {
2929
+ if (data.message != null) {
3636
2930
  contents.message = (0, smithy_client_1.expectString)(data.message);
3637
2931
  }
3638
2932
  const exception = new models_0_1.ConflictException({
@@ -3642,9 +2936,9 @@ const deserializeAws_restJson1ConflictExceptionResponse = async (parsedOutput, c
3642
2936
  return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
3643
2937
  };
3644
2938
  const deserializeAws_restJson1ForbiddenExceptionResponse = async (parsedOutput, context) => {
3645
- const contents = {};
2939
+ const contents = map({});
3646
2940
  const data = parsedOutput.body;
3647
- if (data.message !== undefined && data.message !== null) {
2941
+ if (data.message != null) {
3648
2942
  contents.message = (0, smithy_client_1.expectString)(data.message);
3649
2943
  }
3650
2944
  const exception = new models_0_1.ForbiddenException({
@@ -3654,9 +2948,9 @@ const deserializeAws_restJson1ForbiddenExceptionResponse = async (parsedOutput,
3654
2948
  return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
3655
2949
  };
3656
2950
  const deserializeAws_restJson1InternalServerErrorExceptionResponse = async (parsedOutput, context) => {
3657
- const contents = {};
2951
+ const contents = map({});
3658
2952
  const data = parsedOutput.body;
3659
- if (data.message !== undefined && data.message !== null) {
2953
+ if (data.message != null) {
3660
2954
  contents.message = (0, smithy_client_1.expectString)(data.message);
3661
2955
  }
3662
2956
  const exception = new models_0_1.InternalServerErrorException({
@@ -3666,9 +2960,9 @@ const deserializeAws_restJson1InternalServerErrorExceptionResponse = async (pars
3666
2960
  return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
3667
2961
  };
3668
2962
  const deserializeAws_restJson1LimitExceededExceptionResponse = async (parsedOutput, context) => {
3669
- const contents = {};
2963
+ const contents = map({});
3670
2964
  const data = parsedOutput.body;
3671
- if (data.message !== undefined && data.message !== null) {
2965
+ if (data.message != null) {
3672
2966
  contents.message = (0, smithy_client_1.expectString)(data.message);
3673
2967
  }
3674
2968
  const exception = new models_0_1.LimitExceededException({
@@ -3678,9 +2972,9 @@ const deserializeAws_restJson1LimitExceededExceptionResponse = async (parsedOutp
3678
2972
  return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
3679
2973
  };
3680
2974
  const deserializeAws_restJson1NotFoundExceptionResponse = async (parsedOutput, context) => {
3681
- const contents = {};
2975
+ const contents = map({});
3682
2976
  const data = parsedOutput.body;
3683
- if (data.message !== undefined && data.message !== null) {
2977
+ if (data.message != null) {
3684
2978
  contents.message = (0, smithy_client_1.expectString)(data.message);
3685
2979
  }
3686
2980
  const exception = new models_0_1.NotFoundException({
@@ -3690,9 +2984,9 @@ const deserializeAws_restJson1NotFoundExceptionResponse = async (parsedOutput, c
3690
2984
  return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
3691
2985
  };
3692
2986
  const deserializeAws_restJson1ResourceInUseExceptionResponse = async (parsedOutput, context) => {
3693
- const contents = {};
2987
+ const contents = map({});
3694
2988
  const data = parsedOutput.body;
3695
- if (data.message !== undefined && data.message !== null) {
2989
+ if (data.message != null) {
3696
2990
  contents.message = (0, smithy_client_1.expectString)(data.message);
3697
2991
  }
3698
2992
  const exception = new models_0_1.ResourceInUseException({
@@ -3702,9 +2996,9 @@ const deserializeAws_restJson1ResourceInUseExceptionResponse = async (parsedOutp
3702
2996
  return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
3703
2997
  };
3704
2998
  const deserializeAws_restJson1ServiceUnavailableExceptionResponse = async (parsedOutput, context) => {
3705
- const contents = {};
2999
+ const contents = map({});
3706
3000
  const data = parsedOutput.body;
3707
- if (data.message !== undefined && data.message !== null) {
3001
+ if (data.message != null) {
3708
3002
  contents.message = (0, smithy_client_1.expectString)(data.message);
3709
3003
  }
3710
3004
  const exception = new models_0_1.ServiceUnavailableException({
@@ -3714,9 +3008,9 @@ const deserializeAws_restJson1ServiceUnavailableExceptionResponse = async (parse
3714
3008
  return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
3715
3009
  };
3716
3010
  const deserializeAws_restJson1TooManyRequestsExceptionResponse = async (parsedOutput, context) => {
3717
- const contents = {};
3011
+ const contents = map({});
3718
3012
  const data = parsedOutput.body;
3719
- if (data.message !== undefined && data.message !== null) {
3013
+ if (data.message != null) {
3720
3014
  contents.message = (0, smithy_client_1.expectString)(data.message);
3721
3015
  }
3722
3016
  const exception = new models_0_1.TooManyRequestsException({
@@ -3726,9 +3020,9 @@ const deserializeAws_restJson1TooManyRequestsExceptionResponse = async (parsedOu
3726
3020
  return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
3727
3021
  };
3728
3022
  const deserializeAws_restJson1TooManyTagsExceptionResponse = async (parsedOutput, context) => {
3729
- const contents = {};
3023
+ const contents = map({});
3730
3024
  const data = parsedOutput.body;
3731
- if (data.message !== undefined && data.message !== null) {
3025
+ if (data.message != null) {
3732
3026
  contents.message = (0, smithy_client_1.expectString)(data.message);
3733
3027
  }
3734
3028
  const exception = new models_0_1.TooManyTagsException({
@@ -3753,9 +3047,6 @@ const serializeAws_restJson1AwsCloudMapInstanceAttributes = (input, context) =>
3753
3047
  return input
3754
3048
  .filter((e) => e != null)
3755
3049
  .map((entry) => {
3756
- if (entry === null) {
3757
- return null;
3758
- }
3759
3050
  return serializeAws_restJson1AwsCloudMapInstanceAttribute(entry, context);
3760
3051
  });
3761
3052
  };
@@ -3786,9 +3077,6 @@ const serializeAws_restJson1Backends = (input, context) => {
3786
3077
  return input
3787
3078
  .filter((e) => e != null)
3788
3079
  .map((entry) => {
3789
- if (entry === null) {
3790
- return null;
3791
- }
3792
3080
  return serializeAws_restJson1Backend(entry, context);
3793
3081
  });
3794
3082
  };
@@ -3796,9 +3084,6 @@ const serializeAws_restJson1CertificateAuthorityArns = (input, context) => {
3796
3084
  return input
3797
3085
  .filter((e) => e != null)
3798
3086
  .map((entry) => {
3799
- if (entry === null) {
3800
- return null;
3801
- }
3802
3087
  return entry;
3803
3088
  });
3804
3089
  };
@@ -3914,9 +3199,6 @@ const serializeAws_restJson1GrpcGatewayRouteMetadataList = (input, context) => {
3914
3199
  return input
3915
3200
  .filter((e) => e != null)
3916
3201
  .map((entry) => {
3917
- if (entry === null) {
3918
- return null;
3919
- }
3920
3202
  return serializeAws_restJson1GrpcGatewayRouteMetadata(entry, context);
3921
3203
  });
3922
3204
  };
@@ -3958,9 +3240,6 @@ const serializeAws_restJson1GrpcRetryPolicyEvents = (input, context) => {
3958
3240
  return input
3959
3241
  .filter((e) => e != null)
3960
3242
  .map((entry) => {
3961
- if (entry === null) {
3962
- return null;
3963
- }
3964
3243
  return entry;
3965
3244
  });
3966
3245
  };
@@ -3999,9 +3278,6 @@ const serializeAws_restJson1GrpcRouteMetadataList = (input, context) => {
3999
3278
  return input
4000
3279
  .filter((e) => e != null)
4001
3280
  .map((entry) => {
4002
- if (entry === null) {
4003
- return null;
4004
- }
4005
3281
  return serializeAws_restJson1GrpcRouteMetadata(entry, context);
4006
3282
  });
4007
3283
  };
@@ -4065,9 +3341,6 @@ const serializeAws_restJson1HttpGatewayRouteHeaders = (input, context) => {
4065
3341
  return input
4066
3342
  .filter((e) => e != null)
4067
3343
  .map((entry) => {
4068
- if (entry === null) {
4069
- return null;
4070
- }
4071
3344
  return serializeAws_restJson1HttpGatewayRouteHeader(entry, context);
4072
3345
  });
4073
3346
  };
@@ -4121,9 +3394,6 @@ const serializeAws_restJson1HttpQueryParameters = (input, context) => {
4121
3394
  return input
4122
3395
  .filter((e) => e != null)
4123
3396
  .map((entry) => {
4124
- if (entry === null) {
4125
- return null;
4126
- }
4127
3397
  return serializeAws_restJson1HttpQueryParameter(entry, context);
4128
3398
  });
4129
3399
  };
@@ -4145,9 +3415,6 @@ const serializeAws_restJson1HttpRetryPolicyEvents = (input, context) => {
4145
3415
  return input
4146
3416
  .filter((e) => e != null)
4147
3417
  .map((entry) => {
4148
- if (entry === null) {
4149
- return null;
4150
- }
4151
3418
  return entry;
4152
3419
  });
4153
3420
  };
@@ -4179,9 +3446,6 @@ const serializeAws_restJson1HttpRouteHeaders = (input, context) => {
4179
3446
  return input
4180
3447
  .filter((e) => e != null)
4181
3448
  .map((entry) => {
4182
- if (entry === null) {
4183
- return null;
4184
- }
4185
3449
  return serializeAws_restJson1HttpRouteHeader(entry, context);
4186
3450
  });
4187
3451
  };
@@ -4223,9 +3487,6 @@ const serializeAws_restJson1Listeners = (input, context) => {
4223
3487
  return input
4224
3488
  .filter((e) => e != null)
4225
3489
  .map((entry) => {
4226
- if (entry === null) {
4227
- return null;
4228
- }
4229
3490
  return serializeAws_restJson1Listener(entry, context);
4230
3491
  });
4231
3492
  };
@@ -4336,9 +3597,6 @@ const serializeAws_restJson1PortSet = (input, context) => {
4336
3597
  return input
4337
3598
  .filter((e) => e != null)
4338
3599
  .map((entry) => {
4339
- if (entry === null) {
4340
- return null;
4341
- }
4342
3600
  return entry;
4343
3601
  });
4344
3602
  };
@@ -4367,9 +3625,6 @@ const serializeAws_restJson1SubjectAlternativeNameList = (input, context) => {
4367
3625
  return input
4368
3626
  .filter((e) => e != null)
4369
3627
  .map((entry) => {
4370
- if (entry === null) {
4371
- return null;
4372
- }
4373
3628
  return entry;
4374
3629
  });
4375
3630
  };
@@ -4387,9 +3642,6 @@ const serializeAws_restJson1TagKeyList = (input, context) => {
4387
3642
  return input
4388
3643
  .filter((e) => e != null)
4389
3644
  .map((entry) => {
4390
- if (entry === null) {
4391
- return null;
4392
- }
4393
3645
  return entry;
4394
3646
  });
4395
3647
  };
@@ -4397,9 +3649,6 @@ const serializeAws_restJson1TagList = (input, context) => {
4397
3649
  return input
4398
3650
  .filter((e) => e != null)
4399
3651
  .map((entry) => {
4400
- if (entry === null) {
4401
- return null;
4402
- }
4403
3652
  return serializeAws_restJson1TagRef(entry, context);
4404
3653
  });
4405
3654
  };
@@ -4413,9 +3662,6 @@ const serializeAws_restJson1TcpRetryPolicyEvents = (input, context) => {
4413
3662
  return input
4414
3663
  .filter((e) => e != null)
4415
3664
  .map((entry) => {
4416
- if (entry === null) {
4417
- return null;
4418
- }
4419
3665
  return entry;
4420
3666
  });
4421
3667
  };
@@ -4487,9 +3733,6 @@ const serializeAws_restJson1VirtualGatewayCertificateAuthorityArns = (input, con
4487
3733
  return input
4488
3734
  .filter((e) => e != null)
4489
3735
  .map((entry) => {
4490
- if (entry === null) {
4491
- return null;
4492
- }
4493
3736
  return entry;
4494
3737
  });
4495
3738
  };
@@ -4575,9 +3818,6 @@ const serializeAws_restJson1VirtualGatewayListeners = (input, context) => {
4575
3818
  return input
4576
3819
  .filter((e) => e != null)
4577
3820
  .map((entry) => {
4578
- if (entry === null) {
4579
- return null;
4580
- }
4581
3821
  return serializeAws_restJson1VirtualGatewayListener(entry, context);
4582
3822
  });
4583
3823
  };
@@ -4749,9 +3989,6 @@ const serializeAws_restJson1VirtualRouterListeners = (input, context) => {
4749
3989
  return input
4750
3990
  .filter((e) => e != null)
4751
3991
  .map((entry) => {
4752
- if (entry === null) {
4753
- return null;
4754
- }
4755
3992
  return serializeAws_restJson1VirtualRouterListener(entry, context);
4756
3993
  });
4757
3994
  };
@@ -4797,14 +4034,11 @@ const serializeAws_restJson1WeightedTargets = (input, context) => {
4797
4034
  return input
4798
4035
  .filter((e) => e != null)
4799
4036
  .map((entry) => {
4800
- if (entry === null) {
4801
- return null;
4802
- }
4803
4037
  return serializeAws_restJson1WeightedTarget(entry, context);
4804
4038
  });
4805
4039
  };
4806
4040
  const deserializeAws_restJson1AccessLog = (output, context) => {
4807
- if (output.file !== undefined && output.file !== null) {
4041
+ if (output.file != null) {
4808
4042
  return {
4809
4043
  file: deserializeAws_restJson1FileAccessLog(output.file, context),
4810
4044
  };
@@ -4839,7 +4073,7 @@ const deserializeAws_restJson1AwsCloudMapServiceDiscovery = (output, context) =>
4839
4073
  };
4840
4074
  };
4841
4075
  const deserializeAws_restJson1Backend = (output, context) => {
4842
- if (output.virtualService !== undefined && output.virtualService !== null) {
4076
+ if (output.virtualService != null) {
4843
4077
  return {
4844
4078
  virtualService: deserializeAws_restJson1VirtualServiceBackend(output.virtualService, context),
4845
4079
  };
@@ -4889,12 +4123,12 @@ const deserializeAws_restJson1ClientPolicyTls = (output, context) => {
4889
4123
  };
4890
4124
  };
4891
4125
  const deserializeAws_restJson1ClientTlsCertificate = (output, context) => {
4892
- if (output.file !== undefined && output.file !== null) {
4126
+ if (output.file != null) {
4893
4127
  return {
4894
4128
  file: deserializeAws_restJson1ListenerTlsFileCertificate(output.file, context),
4895
4129
  };
4896
4130
  }
4897
- if (output.sds !== undefined && output.sds !== null) {
4131
+ if (output.sds != null) {
4898
4132
  return {
4899
4133
  sds: deserializeAws_restJson1ListenerTlsSdsCertificate(output.sds, context),
4900
4134
  };
@@ -5051,7 +4285,7 @@ const deserializeAws_restJson1GrpcMetadataMatchMethod = (output, context) => {
5051
4285
  if ((0, smithy_client_1.expectString)(output.prefix) !== undefined) {
5052
4286
  return { prefix: (0, smithy_client_1.expectString)(output.prefix) };
5053
4287
  }
5054
- if (output.range !== undefined && output.range !== null) {
4288
+ if (output.range != null) {
5055
4289
  return {
5056
4290
  range: deserializeAws_restJson1MatchRange(output.range, context),
5057
4291
  };
@@ -5139,7 +4373,7 @@ const deserializeAws_restJson1GrpcRouteMetadataMatchMethod = (output, context) =
5139
4373
  if ((0, smithy_client_1.expectString)(output.prefix) !== undefined) {
5140
4374
  return { prefix: (0, smithy_client_1.expectString)(output.prefix) };
5141
4375
  }
5142
- if (output.range !== undefined && output.range !== null) {
4376
+ if (output.range != null) {
5143
4377
  return {
5144
4378
  range: deserializeAws_restJson1MatchRange(output.range, context),
5145
4379
  };
@@ -5165,7 +4399,7 @@ const deserializeAws_restJson1HeaderMatchMethod = (output, context) => {
5165
4399
  if ((0, smithy_client_1.expectString)(output.prefix) !== undefined) {
5166
4400
  return { prefix: (0, smithy_client_1.expectString)(output.prefix) };
5167
4401
  }
5168
- if (output.range !== undefined && output.range !== null) {
4402
+ if (output.range != null) {
5169
4403
  return {
5170
4404
  range: deserializeAws_restJson1MatchRange(output.range, context),
5171
4405
  };
@@ -5380,22 +4614,22 @@ const deserializeAws_restJson1Listeners = (output, context) => {
5380
4614
  return retVal;
5381
4615
  };
5382
4616
  const deserializeAws_restJson1ListenerTimeout = (output, context) => {
5383
- if (output.grpc !== undefined && output.grpc !== null) {
4617
+ if (output.grpc != null) {
5384
4618
  return {
5385
4619
  grpc: deserializeAws_restJson1GrpcTimeout(output.grpc, context),
5386
4620
  };
5387
4621
  }
5388
- if (output.http !== undefined && output.http !== null) {
4622
+ if (output.http != null) {
5389
4623
  return {
5390
4624
  http: deserializeAws_restJson1HttpTimeout(output.http, context),
5391
4625
  };
5392
4626
  }
5393
- if (output.http2 !== undefined && output.http2 !== null) {
4627
+ if (output.http2 != null) {
5394
4628
  return {
5395
4629
  http2: deserializeAws_restJson1HttpTimeout(output.http2, context),
5396
4630
  };
5397
4631
  }
5398
- if (output.tcp !== undefined && output.tcp !== null) {
4632
+ if (output.tcp != null) {
5399
4633
  return {
5400
4634
  tcp: deserializeAws_restJson1TcpTimeout(output.tcp, context),
5401
4635
  };
@@ -5419,17 +4653,17 @@ const deserializeAws_restJson1ListenerTlsAcmCertificate = (output, context) => {
5419
4653
  };
5420
4654
  };
5421
4655
  const deserializeAws_restJson1ListenerTlsCertificate = (output, context) => {
5422
- if (output.acm !== undefined && output.acm !== null) {
4656
+ if (output.acm != null) {
5423
4657
  return {
5424
4658
  acm: deserializeAws_restJson1ListenerTlsAcmCertificate(output.acm, context),
5425
4659
  };
5426
4660
  }
5427
- if (output.file !== undefined && output.file !== null) {
4661
+ if (output.file != null) {
5428
4662
  return {
5429
4663
  file: deserializeAws_restJson1ListenerTlsFileCertificate(output.file, context),
5430
4664
  };
5431
4665
  }
5432
- if (output.sds !== undefined && output.sds !== null) {
4666
+ if (output.sds != null) {
5433
4667
  return {
5434
4668
  sds: deserializeAws_restJson1ListenerTlsSdsCertificate(output.sds, context),
5435
4669
  };
@@ -5458,12 +4692,12 @@ const deserializeAws_restJson1ListenerTlsValidationContext = (output, context) =
5458
4692
  };
5459
4693
  };
5460
4694
  const deserializeAws_restJson1ListenerTlsValidationContextTrust = (output, context) => {
5461
- if (output.file !== undefined && output.file !== null) {
4695
+ if (output.file != null) {
5462
4696
  return {
5463
4697
  file: deserializeAws_restJson1TlsValidationContextFileTrust(output.file, context),
5464
4698
  };
5465
4699
  }
5466
- if (output.sds !== undefined && output.sds !== null) {
4700
+ if (output.sds != null) {
5467
4701
  return {
5468
4702
  sds: deserializeAws_restJson1TlsValidationContextSdsTrust(output.sds, context),
5469
4703
  };
@@ -5629,12 +4863,12 @@ const deserializeAws_restJson1RouteStatus = (output, context) => {
5629
4863
  };
5630
4864
  };
5631
4865
  const deserializeAws_restJson1ServiceDiscovery = (output, context) => {
5632
- if (output.awsCloudMap !== undefined && output.awsCloudMap !== null) {
4866
+ if (output.awsCloudMap != null) {
5633
4867
  return {
5634
4868
  awsCloudMap: deserializeAws_restJson1AwsCloudMapServiceDiscovery(output.awsCloudMap, context),
5635
4869
  };
5636
4870
  }
5637
- if (output.dns !== undefined && output.dns !== null) {
4871
+ if (output.dns != null) {
5638
4872
  return {
5639
4873
  dns: deserializeAws_restJson1DnsServiceDiscovery(output.dns, context),
5640
4874
  };
@@ -5736,17 +4970,17 @@ const deserializeAws_restJson1TlsValidationContextSdsTrust = (output, context) =
5736
4970
  };
5737
4971
  };
5738
4972
  const deserializeAws_restJson1TlsValidationContextTrust = (output, context) => {
5739
- if (output.acm !== undefined && output.acm !== null) {
4973
+ if (output.acm != null) {
5740
4974
  return {
5741
4975
  acm: deserializeAws_restJson1TlsValidationContextAcmTrust(output.acm, context),
5742
4976
  };
5743
4977
  }
5744
- if (output.file !== undefined && output.file !== null) {
4978
+ if (output.file != null) {
5745
4979
  return {
5746
4980
  file: deserializeAws_restJson1TlsValidationContextFileTrust(output.file, context),
5747
4981
  };
5748
4982
  }
5749
- if (output.sds !== undefined && output.sds !== null) {
4983
+ if (output.sds != null) {
5750
4984
  return {
5751
4985
  sds: deserializeAws_restJson1TlsValidationContextSdsTrust(output.sds, context),
5752
4986
  };
@@ -5754,7 +4988,7 @@ const deserializeAws_restJson1TlsValidationContextTrust = (output, context) => {
5754
4988
  return { $unknown: Object.entries(output)[0] };
5755
4989
  };
5756
4990
  const deserializeAws_restJson1VirtualGatewayAccessLog = (output, context) => {
5757
- if (output.file !== undefined && output.file !== null) {
4991
+ if (output.file != null) {
5758
4992
  return {
5759
4993
  file: deserializeAws_restJson1VirtualGatewayFileAccessLog(output.file, context),
5760
4994
  };
@@ -5797,12 +5031,12 @@ const deserializeAws_restJson1VirtualGatewayClientPolicyTls = (output, context)
5797
5031
  };
5798
5032
  };
5799
5033
  const deserializeAws_restJson1VirtualGatewayClientTlsCertificate = (output, context) => {
5800
- if (output.file !== undefined && output.file !== null) {
5034
+ if (output.file != null) {
5801
5035
  return {
5802
5036
  file: deserializeAws_restJson1VirtualGatewayListenerTlsFileCertificate(output.file, context),
5803
5037
  };
5804
5038
  }
5805
- if (output.sds !== undefined && output.sds !== null) {
5039
+ if (output.sds != null) {
5806
5040
  return {
5807
5041
  sds: deserializeAws_restJson1VirtualGatewayListenerTlsSdsCertificate(output.sds, context),
5808
5042
  };
@@ -5810,17 +5044,17 @@ const deserializeAws_restJson1VirtualGatewayClientTlsCertificate = (output, cont
5810
5044
  return { $unknown: Object.entries(output)[0] };
5811
5045
  };
5812
5046
  const deserializeAws_restJson1VirtualGatewayConnectionPool = (output, context) => {
5813
- if (output.grpc !== undefined && output.grpc !== null) {
5047
+ if (output.grpc != null) {
5814
5048
  return {
5815
5049
  grpc: deserializeAws_restJson1VirtualGatewayGrpcConnectionPool(output.grpc, context),
5816
5050
  };
5817
5051
  }
5818
- if (output.http !== undefined && output.http !== null) {
5052
+ if (output.http != null) {
5819
5053
  return {
5820
5054
  http: deserializeAws_restJson1VirtualGatewayHttpConnectionPool(output.http, context),
5821
5055
  };
5822
5056
  }
5823
- if (output.http2 !== undefined && output.http2 !== null) {
5057
+ if (output.http2 != null) {
5824
5058
  return {
5825
5059
  http2: deserializeAws_restJson1VirtualGatewayHttp2ConnectionPool(output.http2, context),
5826
5060
  };
@@ -5921,17 +5155,17 @@ const deserializeAws_restJson1VirtualGatewayListenerTlsAcmCertificate = (output,
5921
5155
  };
5922
5156
  };
5923
5157
  const deserializeAws_restJson1VirtualGatewayListenerTlsCertificate = (output, context) => {
5924
- if (output.acm !== undefined && output.acm !== null) {
5158
+ if (output.acm != null) {
5925
5159
  return {
5926
5160
  acm: deserializeAws_restJson1VirtualGatewayListenerTlsAcmCertificate(output.acm, context),
5927
5161
  };
5928
5162
  }
5929
- if (output.file !== undefined && output.file !== null) {
5163
+ if (output.file != null) {
5930
5164
  return {
5931
5165
  file: deserializeAws_restJson1VirtualGatewayListenerTlsFileCertificate(output.file, context),
5932
5166
  };
5933
5167
  }
5934
- if (output.sds !== undefined && output.sds !== null) {
5168
+ if (output.sds != null) {
5935
5169
  return {
5936
5170
  sds: deserializeAws_restJson1VirtualGatewayListenerTlsSdsCertificate(output.sds, context),
5937
5171
  };
@@ -5960,12 +5194,12 @@ const deserializeAws_restJson1VirtualGatewayListenerTlsValidationContext = (outp
5960
5194
  };
5961
5195
  };
5962
5196
  const deserializeAws_restJson1VirtualGatewayListenerTlsValidationContextTrust = (output, context) => {
5963
- if (output.file !== undefined && output.file !== null) {
5197
+ if (output.file != null) {
5964
5198
  return {
5965
5199
  file: deserializeAws_restJson1VirtualGatewayTlsValidationContextFileTrust(output.file, context),
5966
5200
  };
5967
5201
  }
5968
- if (output.sds !== undefined && output.sds !== null) {
5202
+ if (output.sds != null) {
5969
5203
  return {
5970
5204
  sds: deserializeAws_restJson1VirtualGatewayTlsValidationContextSdsTrust(output.sds, context),
5971
5205
  };
@@ -6041,17 +5275,17 @@ const deserializeAws_restJson1VirtualGatewayTlsValidationContextSdsTrust = (outp
6041
5275
  };
6042
5276
  };
6043
5277
  const deserializeAws_restJson1VirtualGatewayTlsValidationContextTrust = (output, context) => {
6044
- if (output.acm !== undefined && output.acm !== null) {
5278
+ if (output.acm != null) {
6045
5279
  return {
6046
5280
  acm: deserializeAws_restJson1VirtualGatewayTlsValidationContextAcmTrust(output.acm, context),
6047
5281
  };
6048
5282
  }
6049
- if (output.file !== undefined && output.file !== null) {
5283
+ if (output.file != null) {
6050
5284
  return {
6051
5285
  file: deserializeAws_restJson1VirtualGatewayTlsValidationContextFileTrust(output.file, context),
6052
5286
  };
6053
5287
  }
6054
- if (output.sds !== undefined && output.sds !== null) {
5288
+ if (output.sds != null) {
6055
5289
  return {
6056
5290
  sds: deserializeAws_restJson1VirtualGatewayTlsValidationContextSdsTrust(output.sds, context),
6057
5291
  };
@@ -6059,22 +5293,22 @@ const deserializeAws_restJson1VirtualGatewayTlsValidationContextTrust = (output,
6059
5293
  return { $unknown: Object.entries(output)[0] };
6060
5294
  };
6061
5295
  const deserializeAws_restJson1VirtualNodeConnectionPool = (output, context) => {
6062
- if (output.grpc !== undefined && output.grpc !== null) {
5296
+ if (output.grpc != null) {
6063
5297
  return {
6064
5298
  grpc: deserializeAws_restJson1VirtualNodeGrpcConnectionPool(output.grpc, context),
6065
5299
  };
6066
5300
  }
6067
- if (output.http !== undefined && output.http !== null) {
5301
+ if (output.http != null) {
6068
5302
  return {
6069
5303
  http: deserializeAws_restJson1VirtualNodeHttpConnectionPool(output.http, context),
6070
5304
  };
6071
5305
  }
6072
- if (output.http2 !== undefined && output.http2 !== null) {
5306
+ if (output.http2 != null) {
6073
5307
  return {
6074
5308
  http2: deserializeAws_restJson1VirtualNodeHttp2ConnectionPool(output.http2, context),
6075
5309
  };
6076
5310
  }
6077
- if (output.tcp !== undefined && output.tcp !== null) {
5311
+ if (output.tcp != null) {
6078
5312
  return {
6079
5313
  tcp: deserializeAws_restJson1VirtualNodeTcpConnectionPool(output.tcp, context),
6080
5314
  };
@@ -6251,12 +5485,12 @@ const deserializeAws_restJson1VirtualServiceList = (output, context) => {
6251
5485
  return retVal;
6252
5486
  };
6253
5487
  const deserializeAws_restJson1VirtualServiceProvider = (output, context) => {
6254
- if (output.virtualNode !== undefined && output.virtualNode !== null) {
5488
+ if (output.virtualNode != null) {
6255
5489
  return {
6256
5490
  virtualNode: deserializeAws_restJson1VirtualNodeServiceProvider(output.virtualNode, context),
6257
5491
  };
6258
5492
  }
6259
- if (output.virtualRouter !== undefined && output.virtualRouter !== null) {
5493
+ if (output.virtualRouter != null) {
6260
5494
  return {
6261
5495
  virtualRouter: deserializeAws_restJson1VirtualRouterServiceProvider(output.virtualRouter, context),
6262
5496
  };