@aws-sdk/client-app-mesh 3.928.0 → 3.929.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 (59) hide show
  1. package/dist-cjs/index.js +2611 -1742
  2. package/dist-cjs/runtimeConfig.shared.js +2 -0
  3. package/dist-es/AppMeshClient.js +2 -0
  4. package/dist-es/commands/CreateGatewayRouteCommand.js +3 -9
  5. package/dist-es/commands/CreateMeshCommand.js +3 -9
  6. package/dist-es/commands/CreateRouteCommand.js +3 -9
  7. package/dist-es/commands/CreateVirtualGatewayCommand.js +3 -9
  8. package/dist-es/commands/CreateVirtualNodeCommand.js +3 -9
  9. package/dist-es/commands/CreateVirtualRouterCommand.js +3 -9
  10. package/dist-es/commands/CreateVirtualServiceCommand.js +3 -9
  11. package/dist-es/commands/DeleteGatewayRouteCommand.js +3 -9
  12. package/dist-es/commands/DeleteMeshCommand.js +3 -9
  13. package/dist-es/commands/DeleteRouteCommand.js +3 -9
  14. package/dist-es/commands/DeleteVirtualGatewayCommand.js +3 -9
  15. package/dist-es/commands/DeleteVirtualNodeCommand.js +3 -9
  16. package/dist-es/commands/DeleteVirtualRouterCommand.js +3 -9
  17. package/dist-es/commands/DeleteVirtualServiceCommand.js +3 -9
  18. package/dist-es/commands/DescribeGatewayRouteCommand.js +3 -9
  19. package/dist-es/commands/DescribeMeshCommand.js +3 -9
  20. package/dist-es/commands/DescribeRouteCommand.js +3 -9
  21. package/dist-es/commands/DescribeVirtualGatewayCommand.js +3 -9
  22. package/dist-es/commands/DescribeVirtualNodeCommand.js +3 -9
  23. package/dist-es/commands/DescribeVirtualRouterCommand.js +3 -9
  24. package/dist-es/commands/DescribeVirtualServiceCommand.js +3 -9
  25. package/dist-es/commands/ListGatewayRoutesCommand.js +3 -9
  26. package/dist-es/commands/ListMeshesCommand.js +3 -9
  27. package/dist-es/commands/ListRoutesCommand.js +3 -9
  28. package/dist-es/commands/ListTagsForResourceCommand.js +3 -9
  29. package/dist-es/commands/ListVirtualGatewaysCommand.js +3 -9
  30. package/dist-es/commands/ListVirtualNodesCommand.js +3 -9
  31. package/dist-es/commands/ListVirtualRoutersCommand.js +3 -9
  32. package/dist-es/commands/ListVirtualServicesCommand.js +3 -9
  33. package/dist-es/commands/TagResourceCommand.js +3 -9
  34. package/dist-es/commands/UntagResourceCommand.js +3 -9
  35. package/dist-es/commands/UpdateGatewayRouteCommand.js +3 -9
  36. package/dist-es/commands/UpdateMeshCommand.js +3 -9
  37. package/dist-es/commands/UpdateRouteCommand.js +3 -9
  38. package/dist-es/commands/UpdateVirtualGatewayCommand.js +3 -9
  39. package/dist-es/commands/UpdateVirtualNodeCommand.js +3 -9
  40. package/dist-es/commands/UpdateVirtualRouterCommand.js +3 -9
  41. package/dist-es/commands/UpdateVirtualServiceCommand.js +3 -9
  42. package/dist-es/runtimeConfig.shared.js +2 -0
  43. package/dist-es/schemas/schemas_0.js +2515 -0
  44. package/dist-types/AppMeshClient.d.ts +10 -1
  45. package/dist-types/runtimeConfig.browser.d.ts +1 -0
  46. package/dist-types/runtimeConfig.d.ts +1 -0
  47. package/dist-types/runtimeConfig.native.d.ts +1 -0
  48. package/dist-types/runtimeConfig.shared.d.ts +1 -0
  49. package/dist-types/schemas/schemas_0.d.ts +296 -0
  50. package/dist-types/ts3.4/AppMeshClient.d.ts +4 -0
  51. package/dist-types/ts3.4/runtimeConfig.browser.d.ts +4 -0
  52. package/dist-types/ts3.4/runtimeConfig.d.ts +4 -0
  53. package/dist-types/ts3.4/runtimeConfig.native.d.ts +4 -0
  54. package/dist-types/ts3.4/runtimeConfig.shared.d.ts +4 -0
  55. package/dist-types/ts3.4/schemas/schemas_0.d.ts +301 -0
  56. package/package.json +2 -3
  57. package/dist-es/protocols/Aws_restJson1.js +0 -1451
  58. package/dist-types/protocols/Aws_restJson1.d.ts +0 -344
  59. package/dist-types/ts3.4/protocols/Aws_restJson1.d.ts +0 -461
@@ -1,1451 +0,0 @@
1
- import { loadRestJsonErrorCode, parseJsonBody as parseBody, parseJsonErrorBody as parseErrorBody } from "@aws-sdk/core";
2
- import { requestBuilder as rb } from "@smithy/core";
3
- import { _json, collectBody, decorateServiceException as __decorateServiceException, expectLong as __expectLong, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectObject as __expectObject, expectString as __expectString, map, parseEpochTimestamp as __parseEpochTimestamp, take, withBaseException, } from "@smithy/smithy-client";
4
- import { v4 as generateIdempotencyToken } from "@smithy/uuid";
5
- import { AppMeshServiceException as __BaseException } from "../models/AppMeshServiceException";
6
- import { BadRequestException, ConflictException, ForbiddenException, InternalServerErrorException, LimitExceededException, NotFoundException, ResourceInUseException, ServiceUnavailableException, TooManyRequestsException, TooManyTagsException, } from "../models/models_0";
7
- export const se_CreateGatewayRouteCommand = async (input, context) => {
8
- const b = rb(input, context);
9
- const headers = {
10
- "content-type": "application/json",
11
- };
12
- b.bp("/v20190125/meshes/{meshName}/virtualGateway/{virtualGatewayName}/gatewayRoutes");
13
- b.p("meshName", () => input.meshName, "{meshName}", false);
14
- b.p("virtualGatewayName", () => input.virtualGatewayName, "{virtualGatewayName}", false);
15
- const query = map({
16
- [_mO]: [, input[_mO]],
17
- });
18
- let body;
19
- body = JSON.stringify(take(input, {
20
- clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
21
- gatewayRouteName: [],
22
- spec: (_) => _json(_),
23
- tags: (_) => _json(_),
24
- }));
25
- b.m("PUT").h(headers).q(query).b(body);
26
- return b.build();
27
- };
28
- export const se_CreateMeshCommand = async (input, context) => {
29
- const b = rb(input, context);
30
- const headers = {
31
- "content-type": "application/json",
32
- };
33
- b.bp("/v20190125/meshes");
34
- let body;
35
- body = JSON.stringify(take(input, {
36
- clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
37
- meshName: [],
38
- spec: (_) => _json(_),
39
- tags: (_) => _json(_),
40
- }));
41
- b.m("PUT").h(headers).b(body);
42
- return b.build();
43
- };
44
- export const se_CreateRouteCommand = async (input, context) => {
45
- const b = rb(input, context);
46
- const headers = {
47
- "content-type": "application/json",
48
- };
49
- b.bp("/v20190125/meshes/{meshName}/virtualRouter/{virtualRouterName}/routes");
50
- b.p("meshName", () => input.meshName, "{meshName}", false);
51
- b.p("virtualRouterName", () => input.virtualRouterName, "{virtualRouterName}", false);
52
- const query = map({
53
- [_mO]: [, input[_mO]],
54
- });
55
- let body;
56
- body = JSON.stringify(take(input, {
57
- clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
58
- routeName: [],
59
- spec: (_) => _json(_),
60
- tags: (_) => _json(_),
61
- }));
62
- b.m("PUT").h(headers).q(query).b(body);
63
- return b.build();
64
- };
65
- export const se_CreateVirtualGatewayCommand = async (input, context) => {
66
- const b = rb(input, context);
67
- const headers = {
68
- "content-type": "application/json",
69
- };
70
- b.bp("/v20190125/meshes/{meshName}/virtualGateways");
71
- b.p("meshName", () => input.meshName, "{meshName}", false);
72
- const query = map({
73
- [_mO]: [, input[_mO]],
74
- });
75
- let body;
76
- body = JSON.stringify(take(input, {
77
- clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
78
- spec: (_) => _json(_),
79
- tags: (_) => _json(_),
80
- virtualGatewayName: [],
81
- }));
82
- b.m("PUT").h(headers).q(query).b(body);
83
- return b.build();
84
- };
85
- export const se_CreateVirtualNodeCommand = async (input, context) => {
86
- const b = rb(input, context);
87
- const headers = {
88
- "content-type": "application/json",
89
- };
90
- b.bp("/v20190125/meshes/{meshName}/virtualNodes");
91
- b.p("meshName", () => input.meshName, "{meshName}", false);
92
- const query = map({
93
- [_mO]: [, input[_mO]],
94
- });
95
- let body;
96
- body = JSON.stringify(take(input, {
97
- clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
98
- spec: (_) => _json(_),
99
- tags: (_) => _json(_),
100
- virtualNodeName: [],
101
- }));
102
- b.m("PUT").h(headers).q(query).b(body);
103
- return b.build();
104
- };
105
- export const se_CreateVirtualRouterCommand = async (input, context) => {
106
- const b = rb(input, context);
107
- const headers = {
108
- "content-type": "application/json",
109
- };
110
- b.bp("/v20190125/meshes/{meshName}/virtualRouters");
111
- b.p("meshName", () => input.meshName, "{meshName}", false);
112
- const query = map({
113
- [_mO]: [, input[_mO]],
114
- });
115
- let body;
116
- body = JSON.stringify(take(input, {
117
- clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
118
- spec: (_) => _json(_),
119
- tags: (_) => _json(_),
120
- virtualRouterName: [],
121
- }));
122
- b.m("PUT").h(headers).q(query).b(body);
123
- return b.build();
124
- };
125
- export const se_CreateVirtualServiceCommand = async (input, context) => {
126
- const b = rb(input, context);
127
- const headers = {
128
- "content-type": "application/json",
129
- };
130
- b.bp("/v20190125/meshes/{meshName}/virtualServices");
131
- b.p("meshName", () => input.meshName, "{meshName}", false);
132
- const query = map({
133
- [_mO]: [, input[_mO]],
134
- });
135
- let body;
136
- body = JSON.stringify(take(input, {
137
- clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
138
- spec: (_) => _json(_),
139
- tags: (_) => _json(_),
140
- virtualServiceName: [],
141
- }));
142
- b.m("PUT").h(headers).q(query).b(body);
143
- return b.build();
144
- };
145
- export const se_DeleteGatewayRouteCommand = async (input, context) => {
146
- const b = rb(input, context);
147
- const headers = {};
148
- b.bp("/v20190125/meshes/{meshName}/virtualGateway/{virtualGatewayName}/gatewayRoutes/{gatewayRouteName}");
149
- b.p("gatewayRouteName", () => input.gatewayRouteName, "{gatewayRouteName}", false);
150
- b.p("meshName", () => input.meshName, "{meshName}", false);
151
- b.p("virtualGatewayName", () => input.virtualGatewayName, "{virtualGatewayName}", false);
152
- const query = map({
153
- [_mO]: [, input[_mO]],
154
- });
155
- let body;
156
- b.m("DELETE").h(headers).q(query).b(body);
157
- return b.build();
158
- };
159
- export const se_DeleteMeshCommand = async (input, context) => {
160
- const b = rb(input, context);
161
- const headers = {};
162
- b.bp("/v20190125/meshes/{meshName}");
163
- b.p("meshName", () => input.meshName, "{meshName}", false);
164
- let body;
165
- b.m("DELETE").h(headers).b(body);
166
- return b.build();
167
- };
168
- export const se_DeleteRouteCommand = async (input, context) => {
169
- const b = rb(input, context);
170
- const headers = {};
171
- b.bp("/v20190125/meshes/{meshName}/virtualRouter/{virtualRouterName}/routes/{routeName}");
172
- b.p("routeName", () => input.routeName, "{routeName}", false);
173
- b.p("meshName", () => input.meshName, "{meshName}", false);
174
- b.p("virtualRouterName", () => input.virtualRouterName, "{virtualRouterName}", false);
175
- const query = map({
176
- [_mO]: [, input[_mO]],
177
- });
178
- let body;
179
- b.m("DELETE").h(headers).q(query).b(body);
180
- return b.build();
181
- };
182
- export const se_DeleteVirtualGatewayCommand = async (input, context) => {
183
- const b = rb(input, context);
184
- const headers = {};
185
- b.bp("/v20190125/meshes/{meshName}/virtualGateways/{virtualGatewayName}");
186
- b.p("virtualGatewayName", () => input.virtualGatewayName, "{virtualGatewayName}", false);
187
- b.p("meshName", () => input.meshName, "{meshName}", false);
188
- const query = map({
189
- [_mO]: [, input[_mO]],
190
- });
191
- let body;
192
- b.m("DELETE").h(headers).q(query).b(body);
193
- return b.build();
194
- };
195
- export const se_DeleteVirtualNodeCommand = async (input, context) => {
196
- const b = rb(input, context);
197
- const headers = {};
198
- b.bp("/v20190125/meshes/{meshName}/virtualNodes/{virtualNodeName}");
199
- b.p("virtualNodeName", () => input.virtualNodeName, "{virtualNodeName}", false);
200
- b.p("meshName", () => input.meshName, "{meshName}", false);
201
- const query = map({
202
- [_mO]: [, input[_mO]],
203
- });
204
- let body;
205
- b.m("DELETE").h(headers).q(query).b(body);
206
- return b.build();
207
- };
208
- export const se_DeleteVirtualRouterCommand = async (input, context) => {
209
- const b = rb(input, context);
210
- const headers = {};
211
- b.bp("/v20190125/meshes/{meshName}/virtualRouters/{virtualRouterName}");
212
- b.p("virtualRouterName", () => input.virtualRouterName, "{virtualRouterName}", false);
213
- b.p("meshName", () => input.meshName, "{meshName}", false);
214
- const query = map({
215
- [_mO]: [, input[_mO]],
216
- });
217
- let body;
218
- b.m("DELETE").h(headers).q(query).b(body);
219
- return b.build();
220
- };
221
- export const se_DeleteVirtualServiceCommand = async (input, context) => {
222
- const b = rb(input, context);
223
- const headers = {};
224
- b.bp("/v20190125/meshes/{meshName}/virtualServices/{virtualServiceName}");
225
- b.p("virtualServiceName", () => input.virtualServiceName, "{virtualServiceName}", false);
226
- b.p("meshName", () => input.meshName, "{meshName}", false);
227
- const query = map({
228
- [_mO]: [, input[_mO]],
229
- });
230
- let body;
231
- b.m("DELETE").h(headers).q(query).b(body);
232
- return b.build();
233
- };
234
- export const se_DescribeGatewayRouteCommand = async (input, context) => {
235
- const b = rb(input, context);
236
- const headers = {};
237
- b.bp("/v20190125/meshes/{meshName}/virtualGateway/{virtualGatewayName}/gatewayRoutes/{gatewayRouteName}");
238
- b.p("gatewayRouteName", () => input.gatewayRouteName, "{gatewayRouteName}", false);
239
- b.p("meshName", () => input.meshName, "{meshName}", false);
240
- b.p("virtualGatewayName", () => input.virtualGatewayName, "{virtualGatewayName}", false);
241
- const query = map({
242
- [_mO]: [, input[_mO]],
243
- });
244
- let body;
245
- b.m("GET").h(headers).q(query).b(body);
246
- return b.build();
247
- };
248
- export const se_DescribeMeshCommand = async (input, context) => {
249
- const b = rb(input, context);
250
- const headers = {};
251
- b.bp("/v20190125/meshes/{meshName}");
252
- b.p("meshName", () => input.meshName, "{meshName}", false);
253
- const query = map({
254
- [_mO]: [, input[_mO]],
255
- });
256
- let body;
257
- b.m("GET").h(headers).q(query).b(body);
258
- return b.build();
259
- };
260
- export const se_DescribeRouteCommand = async (input, context) => {
261
- const b = rb(input, context);
262
- const headers = {};
263
- b.bp("/v20190125/meshes/{meshName}/virtualRouter/{virtualRouterName}/routes/{routeName}");
264
- b.p("routeName", () => input.routeName, "{routeName}", false);
265
- b.p("meshName", () => input.meshName, "{meshName}", false);
266
- b.p("virtualRouterName", () => input.virtualRouterName, "{virtualRouterName}", false);
267
- const query = map({
268
- [_mO]: [, input[_mO]],
269
- });
270
- let body;
271
- b.m("GET").h(headers).q(query).b(body);
272
- return b.build();
273
- };
274
- export const se_DescribeVirtualGatewayCommand = async (input, context) => {
275
- const b = rb(input, context);
276
- const headers = {};
277
- b.bp("/v20190125/meshes/{meshName}/virtualGateways/{virtualGatewayName}");
278
- b.p("virtualGatewayName", () => input.virtualGatewayName, "{virtualGatewayName}", false);
279
- b.p("meshName", () => input.meshName, "{meshName}", false);
280
- const query = map({
281
- [_mO]: [, input[_mO]],
282
- });
283
- let body;
284
- b.m("GET").h(headers).q(query).b(body);
285
- return b.build();
286
- };
287
- export const se_DescribeVirtualNodeCommand = async (input, context) => {
288
- const b = rb(input, context);
289
- const headers = {};
290
- b.bp("/v20190125/meshes/{meshName}/virtualNodes/{virtualNodeName}");
291
- b.p("virtualNodeName", () => input.virtualNodeName, "{virtualNodeName}", false);
292
- b.p("meshName", () => input.meshName, "{meshName}", false);
293
- const query = map({
294
- [_mO]: [, input[_mO]],
295
- });
296
- let body;
297
- b.m("GET").h(headers).q(query).b(body);
298
- return b.build();
299
- };
300
- export const se_DescribeVirtualRouterCommand = async (input, context) => {
301
- const b = rb(input, context);
302
- const headers = {};
303
- b.bp("/v20190125/meshes/{meshName}/virtualRouters/{virtualRouterName}");
304
- b.p("virtualRouterName", () => input.virtualRouterName, "{virtualRouterName}", false);
305
- b.p("meshName", () => input.meshName, "{meshName}", false);
306
- const query = map({
307
- [_mO]: [, input[_mO]],
308
- });
309
- let body;
310
- b.m("GET").h(headers).q(query).b(body);
311
- return b.build();
312
- };
313
- export const se_DescribeVirtualServiceCommand = async (input, context) => {
314
- const b = rb(input, context);
315
- const headers = {};
316
- b.bp("/v20190125/meshes/{meshName}/virtualServices/{virtualServiceName}");
317
- b.p("virtualServiceName", () => input.virtualServiceName, "{virtualServiceName}", false);
318
- b.p("meshName", () => input.meshName, "{meshName}", false);
319
- const query = map({
320
- [_mO]: [, input[_mO]],
321
- });
322
- let body;
323
- b.m("GET").h(headers).q(query).b(body);
324
- return b.build();
325
- };
326
- export const se_ListGatewayRoutesCommand = async (input, context) => {
327
- const b = rb(input, context);
328
- const headers = {};
329
- b.bp("/v20190125/meshes/{meshName}/virtualGateway/{virtualGatewayName}/gatewayRoutes");
330
- b.p("meshName", () => input.meshName, "{meshName}", false);
331
- b.p("virtualGatewayName", () => input.virtualGatewayName, "{virtualGatewayName}", false);
332
- const query = map({
333
- [_nT]: [, input[_nT]],
334
- [_l]: [() => input.limit !== void 0, () => input[_l].toString()],
335
- [_mO]: [, input[_mO]],
336
- });
337
- let body;
338
- b.m("GET").h(headers).q(query).b(body);
339
- return b.build();
340
- };
341
- export const se_ListMeshesCommand = async (input, context) => {
342
- const b = rb(input, context);
343
- const headers = {};
344
- b.bp("/v20190125/meshes");
345
- const query = map({
346
- [_nT]: [, input[_nT]],
347
- [_l]: [() => input.limit !== void 0, () => input[_l].toString()],
348
- });
349
- let body;
350
- b.m("GET").h(headers).q(query).b(body);
351
- return b.build();
352
- };
353
- export const se_ListRoutesCommand = async (input, context) => {
354
- const b = rb(input, context);
355
- const headers = {};
356
- b.bp("/v20190125/meshes/{meshName}/virtualRouter/{virtualRouterName}/routes");
357
- b.p("meshName", () => input.meshName, "{meshName}", false);
358
- b.p("virtualRouterName", () => input.virtualRouterName, "{virtualRouterName}", false);
359
- const query = map({
360
- [_nT]: [, input[_nT]],
361
- [_l]: [() => input.limit !== void 0, () => input[_l].toString()],
362
- [_mO]: [, input[_mO]],
363
- });
364
- let body;
365
- b.m("GET").h(headers).q(query).b(body);
366
- return b.build();
367
- };
368
- export const se_ListTagsForResourceCommand = async (input, context) => {
369
- const b = rb(input, context);
370
- const headers = {};
371
- b.bp("/v20190125/tags");
372
- const query = map({
373
- [_rA]: [, __expectNonNull(input[_rA], `resourceArn`)],
374
- [_nT]: [, input[_nT]],
375
- [_l]: [() => input.limit !== void 0, () => input[_l].toString()],
376
- });
377
- let body;
378
- b.m("GET").h(headers).q(query).b(body);
379
- return b.build();
380
- };
381
- export const se_ListVirtualGatewaysCommand = async (input, context) => {
382
- const b = rb(input, context);
383
- const headers = {};
384
- b.bp("/v20190125/meshes/{meshName}/virtualGateways");
385
- b.p("meshName", () => input.meshName, "{meshName}", false);
386
- const query = map({
387
- [_nT]: [, input[_nT]],
388
- [_l]: [() => input.limit !== void 0, () => input[_l].toString()],
389
- [_mO]: [, input[_mO]],
390
- });
391
- let body;
392
- b.m("GET").h(headers).q(query).b(body);
393
- return b.build();
394
- };
395
- export const se_ListVirtualNodesCommand = async (input, context) => {
396
- const b = rb(input, context);
397
- const headers = {};
398
- b.bp("/v20190125/meshes/{meshName}/virtualNodes");
399
- b.p("meshName", () => input.meshName, "{meshName}", false);
400
- const query = map({
401
- [_nT]: [, input[_nT]],
402
- [_l]: [() => input.limit !== void 0, () => input[_l].toString()],
403
- [_mO]: [, input[_mO]],
404
- });
405
- let body;
406
- b.m("GET").h(headers).q(query).b(body);
407
- return b.build();
408
- };
409
- export const se_ListVirtualRoutersCommand = async (input, context) => {
410
- const b = rb(input, context);
411
- const headers = {};
412
- b.bp("/v20190125/meshes/{meshName}/virtualRouters");
413
- b.p("meshName", () => input.meshName, "{meshName}", false);
414
- const query = map({
415
- [_nT]: [, input[_nT]],
416
- [_l]: [() => input.limit !== void 0, () => input[_l].toString()],
417
- [_mO]: [, input[_mO]],
418
- });
419
- let body;
420
- b.m("GET").h(headers).q(query).b(body);
421
- return b.build();
422
- };
423
- export const se_ListVirtualServicesCommand = async (input, context) => {
424
- const b = rb(input, context);
425
- const headers = {};
426
- b.bp("/v20190125/meshes/{meshName}/virtualServices");
427
- b.p("meshName", () => input.meshName, "{meshName}", false);
428
- const query = map({
429
- [_nT]: [, input[_nT]],
430
- [_l]: [() => input.limit !== void 0, () => input[_l].toString()],
431
- [_mO]: [, input[_mO]],
432
- });
433
- let body;
434
- b.m("GET").h(headers).q(query).b(body);
435
- return b.build();
436
- };
437
- export const se_TagResourceCommand = async (input, context) => {
438
- const b = rb(input, context);
439
- const headers = {
440
- "content-type": "application/json",
441
- };
442
- b.bp("/v20190125/tag");
443
- const query = map({
444
- [_rA]: [, __expectNonNull(input[_rA], `resourceArn`)],
445
- });
446
- let body;
447
- body = JSON.stringify(take(input, {
448
- tags: (_) => _json(_),
449
- }));
450
- b.m("PUT").h(headers).q(query).b(body);
451
- return b.build();
452
- };
453
- export const se_UntagResourceCommand = async (input, context) => {
454
- const b = rb(input, context);
455
- const headers = {
456
- "content-type": "application/json",
457
- };
458
- b.bp("/v20190125/untag");
459
- const query = map({
460
- [_rA]: [, __expectNonNull(input[_rA], `resourceArn`)],
461
- });
462
- let body;
463
- body = JSON.stringify(take(input, {
464
- tagKeys: (_) => _json(_),
465
- }));
466
- b.m("PUT").h(headers).q(query).b(body);
467
- return b.build();
468
- };
469
- export const se_UpdateGatewayRouteCommand = async (input, context) => {
470
- const b = rb(input, context);
471
- const headers = {
472
- "content-type": "application/json",
473
- };
474
- b.bp("/v20190125/meshes/{meshName}/virtualGateway/{virtualGatewayName}/gatewayRoutes/{gatewayRouteName}");
475
- b.p("gatewayRouteName", () => input.gatewayRouteName, "{gatewayRouteName}", false);
476
- b.p("meshName", () => input.meshName, "{meshName}", false);
477
- b.p("virtualGatewayName", () => input.virtualGatewayName, "{virtualGatewayName}", false);
478
- const query = map({
479
- [_mO]: [, input[_mO]],
480
- });
481
- let body;
482
- body = JSON.stringify(take(input, {
483
- clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
484
- spec: (_) => _json(_),
485
- }));
486
- b.m("PUT").h(headers).q(query).b(body);
487
- return b.build();
488
- };
489
- export const se_UpdateMeshCommand = async (input, context) => {
490
- const b = rb(input, context);
491
- const headers = {
492
- "content-type": "application/json",
493
- };
494
- b.bp("/v20190125/meshes/{meshName}");
495
- b.p("meshName", () => input.meshName, "{meshName}", false);
496
- let body;
497
- body = JSON.stringify(take(input, {
498
- clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
499
- spec: (_) => _json(_),
500
- }));
501
- b.m("PUT").h(headers).b(body);
502
- return b.build();
503
- };
504
- export const se_UpdateRouteCommand = async (input, context) => {
505
- const b = rb(input, context);
506
- const headers = {
507
- "content-type": "application/json",
508
- };
509
- b.bp("/v20190125/meshes/{meshName}/virtualRouter/{virtualRouterName}/routes/{routeName}");
510
- b.p("routeName", () => input.routeName, "{routeName}", false);
511
- b.p("meshName", () => input.meshName, "{meshName}", false);
512
- b.p("virtualRouterName", () => input.virtualRouterName, "{virtualRouterName}", false);
513
- const query = map({
514
- [_mO]: [, input[_mO]],
515
- });
516
- let body;
517
- body = JSON.stringify(take(input, {
518
- clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
519
- spec: (_) => _json(_),
520
- }));
521
- b.m("PUT").h(headers).q(query).b(body);
522
- return b.build();
523
- };
524
- export const se_UpdateVirtualGatewayCommand = async (input, context) => {
525
- const b = rb(input, context);
526
- const headers = {
527
- "content-type": "application/json",
528
- };
529
- b.bp("/v20190125/meshes/{meshName}/virtualGateways/{virtualGatewayName}");
530
- b.p("virtualGatewayName", () => input.virtualGatewayName, "{virtualGatewayName}", false);
531
- b.p("meshName", () => input.meshName, "{meshName}", false);
532
- const query = map({
533
- [_mO]: [, input[_mO]],
534
- });
535
- let body;
536
- body = JSON.stringify(take(input, {
537
- clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
538
- spec: (_) => _json(_),
539
- }));
540
- b.m("PUT").h(headers).q(query).b(body);
541
- return b.build();
542
- };
543
- export const se_UpdateVirtualNodeCommand = async (input, context) => {
544
- const b = rb(input, context);
545
- const headers = {
546
- "content-type": "application/json",
547
- };
548
- b.bp("/v20190125/meshes/{meshName}/virtualNodes/{virtualNodeName}");
549
- b.p("virtualNodeName", () => input.virtualNodeName, "{virtualNodeName}", false);
550
- b.p("meshName", () => input.meshName, "{meshName}", false);
551
- const query = map({
552
- [_mO]: [, input[_mO]],
553
- });
554
- let body;
555
- body = JSON.stringify(take(input, {
556
- clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
557
- spec: (_) => _json(_),
558
- }));
559
- b.m("PUT").h(headers).q(query).b(body);
560
- return b.build();
561
- };
562
- export const se_UpdateVirtualRouterCommand = async (input, context) => {
563
- const b = rb(input, context);
564
- const headers = {
565
- "content-type": "application/json",
566
- };
567
- b.bp("/v20190125/meshes/{meshName}/virtualRouters/{virtualRouterName}");
568
- b.p("virtualRouterName", () => input.virtualRouterName, "{virtualRouterName}", false);
569
- b.p("meshName", () => input.meshName, "{meshName}", false);
570
- const query = map({
571
- [_mO]: [, input[_mO]],
572
- });
573
- let body;
574
- body = JSON.stringify(take(input, {
575
- clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
576
- spec: (_) => _json(_),
577
- }));
578
- b.m("PUT").h(headers).q(query).b(body);
579
- return b.build();
580
- };
581
- export const se_UpdateVirtualServiceCommand = async (input, context) => {
582
- const b = rb(input, context);
583
- const headers = {
584
- "content-type": "application/json",
585
- };
586
- b.bp("/v20190125/meshes/{meshName}/virtualServices/{virtualServiceName}");
587
- b.p("virtualServiceName", () => input.virtualServiceName, "{virtualServiceName}", false);
588
- b.p("meshName", () => input.meshName, "{meshName}", false);
589
- const query = map({
590
- [_mO]: [, input[_mO]],
591
- });
592
- let body;
593
- body = JSON.stringify(take(input, {
594
- clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
595
- spec: (_) => _json(_),
596
- }));
597
- b.m("PUT").h(headers).q(query).b(body);
598
- return b.build();
599
- };
600
- export const de_CreateGatewayRouteCommand = async (output, context) => {
601
- if (output.statusCode !== 200 && output.statusCode >= 300) {
602
- return de_CommandError(output, context);
603
- }
604
- const contents = map({
605
- $metadata: deserializeMetadata(output),
606
- });
607
- const data = __expectObject(await parseBody(output.body, context));
608
- contents.gatewayRoute = de_GatewayRouteData(data, context);
609
- return contents;
610
- };
611
- export const de_CreateMeshCommand = async (output, context) => {
612
- if (output.statusCode !== 200 && output.statusCode >= 300) {
613
- return de_CommandError(output, context);
614
- }
615
- const contents = map({
616
- $metadata: deserializeMetadata(output),
617
- });
618
- const data = __expectObject(await parseBody(output.body, context));
619
- contents.mesh = de_MeshData(data, context);
620
- return contents;
621
- };
622
- export const de_CreateRouteCommand = async (output, context) => {
623
- if (output.statusCode !== 200 && output.statusCode >= 300) {
624
- return de_CommandError(output, context);
625
- }
626
- const contents = map({
627
- $metadata: deserializeMetadata(output),
628
- });
629
- const data = __expectObject(await parseBody(output.body, context));
630
- contents.route = de_RouteData(data, context);
631
- return contents;
632
- };
633
- export const de_CreateVirtualGatewayCommand = async (output, context) => {
634
- if (output.statusCode !== 200 && output.statusCode >= 300) {
635
- return de_CommandError(output, context);
636
- }
637
- const contents = map({
638
- $metadata: deserializeMetadata(output),
639
- });
640
- const data = __expectObject(await parseBody(output.body, context));
641
- contents.virtualGateway = de_VirtualGatewayData(data, context);
642
- return contents;
643
- };
644
- export const de_CreateVirtualNodeCommand = async (output, context) => {
645
- if (output.statusCode !== 200 && output.statusCode >= 300) {
646
- return de_CommandError(output, context);
647
- }
648
- const contents = map({
649
- $metadata: deserializeMetadata(output),
650
- });
651
- const data = __expectObject(await parseBody(output.body, context));
652
- contents.virtualNode = de_VirtualNodeData(data, context);
653
- return contents;
654
- };
655
- export const de_CreateVirtualRouterCommand = async (output, context) => {
656
- if (output.statusCode !== 200 && output.statusCode >= 300) {
657
- return de_CommandError(output, context);
658
- }
659
- const contents = map({
660
- $metadata: deserializeMetadata(output),
661
- });
662
- const data = __expectObject(await parseBody(output.body, context));
663
- contents.virtualRouter = de_VirtualRouterData(data, context);
664
- return contents;
665
- };
666
- export const de_CreateVirtualServiceCommand = async (output, context) => {
667
- if (output.statusCode !== 200 && output.statusCode >= 300) {
668
- return de_CommandError(output, context);
669
- }
670
- const contents = map({
671
- $metadata: deserializeMetadata(output),
672
- });
673
- const data = __expectObject(await parseBody(output.body, context));
674
- contents.virtualService = de_VirtualServiceData(data, context);
675
- return contents;
676
- };
677
- export const de_DeleteGatewayRouteCommand = async (output, context) => {
678
- if (output.statusCode !== 200 && output.statusCode >= 300) {
679
- return de_CommandError(output, context);
680
- }
681
- const contents = map({
682
- $metadata: deserializeMetadata(output),
683
- });
684
- const data = __expectObject(await parseBody(output.body, context));
685
- contents.gatewayRoute = de_GatewayRouteData(data, context);
686
- return contents;
687
- };
688
- export const de_DeleteMeshCommand = async (output, context) => {
689
- if (output.statusCode !== 200 && output.statusCode >= 300) {
690
- return de_CommandError(output, context);
691
- }
692
- const contents = map({
693
- $metadata: deserializeMetadata(output),
694
- });
695
- const data = __expectObject(await parseBody(output.body, context));
696
- contents.mesh = de_MeshData(data, context);
697
- return contents;
698
- };
699
- export const de_DeleteRouteCommand = async (output, context) => {
700
- if (output.statusCode !== 200 && output.statusCode >= 300) {
701
- return de_CommandError(output, context);
702
- }
703
- const contents = map({
704
- $metadata: deserializeMetadata(output),
705
- });
706
- const data = __expectObject(await parseBody(output.body, context));
707
- contents.route = de_RouteData(data, context);
708
- return contents;
709
- };
710
- export const de_DeleteVirtualGatewayCommand = async (output, context) => {
711
- if (output.statusCode !== 200 && output.statusCode >= 300) {
712
- return de_CommandError(output, context);
713
- }
714
- const contents = map({
715
- $metadata: deserializeMetadata(output),
716
- });
717
- const data = __expectObject(await parseBody(output.body, context));
718
- contents.virtualGateway = de_VirtualGatewayData(data, context);
719
- return contents;
720
- };
721
- export const de_DeleteVirtualNodeCommand = async (output, context) => {
722
- if (output.statusCode !== 200 && output.statusCode >= 300) {
723
- return de_CommandError(output, context);
724
- }
725
- const contents = map({
726
- $metadata: deserializeMetadata(output),
727
- });
728
- const data = __expectObject(await parseBody(output.body, context));
729
- contents.virtualNode = de_VirtualNodeData(data, context);
730
- return contents;
731
- };
732
- export const de_DeleteVirtualRouterCommand = async (output, context) => {
733
- if (output.statusCode !== 200 && output.statusCode >= 300) {
734
- return de_CommandError(output, context);
735
- }
736
- const contents = map({
737
- $metadata: deserializeMetadata(output),
738
- });
739
- const data = __expectObject(await parseBody(output.body, context));
740
- contents.virtualRouter = de_VirtualRouterData(data, context);
741
- return contents;
742
- };
743
- export const de_DeleteVirtualServiceCommand = async (output, context) => {
744
- if (output.statusCode !== 200 && output.statusCode >= 300) {
745
- return de_CommandError(output, context);
746
- }
747
- const contents = map({
748
- $metadata: deserializeMetadata(output),
749
- });
750
- const data = __expectObject(await parseBody(output.body, context));
751
- contents.virtualService = de_VirtualServiceData(data, context);
752
- return contents;
753
- };
754
- export const de_DescribeGatewayRouteCommand = async (output, context) => {
755
- if (output.statusCode !== 200 && output.statusCode >= 300) {
756
- return de_CommandError(output, context);
757
- }
758
- const contents = map({
759
- $metadata: deserializeMetadata(output),
760
- });
761
- const data = __expectObject(await parseBody(output.body, context));
762
- contents.gatewayRoute = de_GatewayRouteData(data, context);
763
- return contents;
764
- };
765
- export const de_DescribeMeshCommand = async (output, context) => {
766
- if (output.statusCode !== 200 && output.statusCode >= 300) {
767
- return de_CommandError(output, context);
768
- }
769
- const contents = map({
770
- $metadata: deserializeMetadata(output),
771
- });
772
- const data = __expectObject(await parseBody(output.body, context));
773
- contents.mesh = de_MeshData(data, context);
774
- return contents;
775
- };
776
- export const de_DescribeRouteCommand = async (output, context) => {
777
- if (output.statusCode !== 200 && output.statusCode >= 300) {
778
- return de_CommandError(output, context);
779
- }
780
- const contents = map({
781
- $metadata: deserializeMetadata(output),
782
- });
783
- const data = __expectObject(await parseBody(output.body, context));
784
- contents.route = de_RouteData(data, context);
785
- return contents;
786
- };
787
- export const de_DescribeVirtualGatewayCommand = async (output, context) => {
788
- if (output.statusCode !== 200 && output.statusCode >= 300) {
789
- return de_CommandError(output, context);
790
- }
791
- const contents = map({
792
- $metadata: deserializeMetadata(output),
793
- });
794
- const data = __expectObject(await parseBody(output.body, context));
795
- contents.virtualGateway = de_VirtualGatewayData(data, context);
796
- return contents;
797
- };
798
- export const de_DescribeVirtualNodeCommand = async (output, context) => {
799
- if (output.statusCode !== 200 && output.statusCode >= 300) {
800
- return de_CommandError(output, context);
801
- }
802
- const contents = map({
803
- $metadata: deserializeMetadata(output),
804
- });
805
- const data = __expectObject(await parseBody(output.body, context));
806
- contents.virtualNode = de_VirtualNodeData(data, context);
807
- return contents;
808
- };
809
- export const de_DescribeVirtualRouterCommand = async (output, context) => {
810
- if (output.statusCode !== 200 && output.statusCode >= 300) {
811
- return de_CommandError(output, context);
812
- }
813
- const contents = map({
814
- $metadata: deserializeMetadata(output),
815
- });
816
- const data = __expectObject(await parseBody(output.body, context));
817
- contents.virtualRouter = de_VirtualRouterData(data, context);
818
- return contents;
819
- };
820
- export const de_DescribeVirtualServiceCommand = async (output, context) => {
821
- if (output.statusCode !== 200 && output.statusCode >= 300) {
822
- return de_CommandError(output, context);
823
- }
824
- const contents = map({
825
- $metadata: deserializeMetadata(output),
826
- });
827
- const data = __expectObject(await parseBody(output.body, context));
828
- contents.virtualService = de_VirtualServiceData(data, context);
829
- return contents;
830
- };
831
- export const de_ListGatewayRoutesCommand = async (output, context) => {
832
- if (output.statusCode !== 200 && output.statusCode >= 300) {
833
- return de_CommandError(output, context);
834
- }
835
- const contents = map({
836
- $metadata: deserializeMetadata(output),
837
- });
838
- const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
839
- const doc = take(data, {
840
- gatewayRoutes: (_) => de_GatewayRouteList(_, context),
841
- nextToken: __expectString,
842
- });
843
- Object.assign(contents, doc);
844
- return contents;
845
- };
846
- export const de_ListMeshesCommand = async (output, context) => {
847
- if (output.statusCode !== 200 && output.statusCode >= 300) {
848
- return de_CommandError(output, context);
849
- }
850
- const contents = map({
851
- $metadata: deserializeMetadata(output),
852
- });
853
- const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
854
- const doc = take(data, {
855
- meshes: (_) => de_MeshList(_, context),
856
- nextToken: __expectString,
857
- });
858
- Object.assign(contents, doc);
859
- return contents;
860
- };
861
- export const de_ListRoutesCommand = async (output, context) => {
862
- if (output.statusCode !== 200 && output.statusCode >= 300) {
863
- return de_CommandError(output, context);
864
- }
865
- const contents = map({
866
- $metadata: deserializeMetadata(output),
867
- });
868
- const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
869
- const doc = take(data, {
870
- nextToken: __expectString,
871
- routes: (_) => de_RouteList(_, context),
872
- });
873
- Object.assign(contents, doc);
874
- return contents;
875
- };
876
- export const de_ListTagsForResourceCommand = async (output, context) => {
877
- if (output.statusCode !== 200 && output.statusCode >= 300) {
878
- return de_CommandError(output, context);
879
- }
880
- const contents = map({
881
- $metadata: deserializeMetadata(output),
882
- });
883
- const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
884
- const doc = take(data, {
885
- nextToken: __expectString,
886
- tags: _json,
887
- });
888
- Object.assign(contents, doc);
889
- return contents;
890
- };
891
- export const de_ListVirtualGatewaysCommand = async (output, context) => {
892
- if (output.statusCode !== 200 && output.statusCode >= 300) {
893
- return de_CommandError(output, context);
894
- }
895
- const contents = map({
896
- $metadata: deserializeMetadata(output),
897
- });
898
- const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
899
- const doc = take(data, {
900
- nextToken: __expectString,
901
- virtualGateways: (_) => de_VirtualGatewayList(_, context),
902
- });
903
- Object.assign(contents, doc);
904
- return contents;
905
- };
906
- export const de_ListVirtualNodesCommand = async (output, context) => {
907
- if (output.statusCode !== 200 && output.statusCode >= 300) {
908
- return de_CommandError(output, context);
909
- }
910
- const contents = map({
911
- $metadata: deserializeMetadata(output),
912
- });
913
- const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
914
- const doc = take(data, {
915
- nextToken: __expectString,
916
- virtualNodes: (_) => de_VirtualNodeList(_, context),
917
- });
918
- Object.assign(contents, doc);
919
- return contents;
920
- };
921
- export const de_ListVirtualRoutersCommand = async (output, context) => {
922
- if (output.statusCode !== 200 && output.statusCode >= 300) {
923
- return de_CommandError(output, context);
924
- }
925
- const contents = map({
926
- $metadata: deserializeMetadata(output),
927
- });
928
- const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
929
- const doc = take(data, {
930
- nextToken: __expectString,
931
- virtualRouters: (_) => de_VirtualRouterList(_, context),
932
- });
933
- Object.assign(contents, doc);
934
- return contents;
935
- };
936
- export const de_ListVirtualServicesCommand = async (output, context) => {
937
- if (output.statusCode !== 200 && output.statusCode >= 300) {
938
- return de_CommandError(output, context);
939
- }
940
- const contents = map({
941
- $metadata: deserializeMetadata(output),
942
- });
943
- const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
944
- const doc = take(data, {
945
- nextToken: __expectString,
946
- virtualServices: (_) => de_VirtualServiceList(_, context),
947
- });
948
- Object.assign(contents, doc);
949
- return contents;
950
- };
951
- export const de_TagResourceCommand = async (output, context) => {
952
- if (output.statusCode !== 200 && output.statusCode >= 300) {
953
- return de_CommandError(output, context);
954
- }
955
- const contents = map({
956
- $metadata: deserializeMetadata(output),
957
- });
958
- await collectBody(output.body, context);
959
- return contents;
960
- };
961
- export const de_UntagResourceCommand = async (output, context) => {
962
- if (output.statusCode !== 200 && output.statusCode >= 300) {
963
- return de_CommandError(output, context);
964
- }
965
- const contents = map({
966
- $metadata: deserializeMetadata(output),
967
- });
968
- await collectBody(output.body, context);
969
- return contents;
970
- };
971
- export const de_UpdateGatewayRouteCommand = async (output, context) => {
972
- if (output.statusCode !== 200 && output.statusCode >= 300) {
973
- return de_CommandError(output, context);
974
- }
975
- const contents = map({
976
- $metadata: deserializeMetadata(output),
977
- });
978
- const data = __expectObject(await parseBody(output.body, context));
979
- contents.gatewayRoute = de_GatewayRouteData(data, context);
980
- return contents;
981
- };
982
- export const de_UpdateMeshCommand = async (output, context) => {
983
- if (output.statusCode !== 200 && output.statusCode >= 300) {
984
- return de_CommandError(output, context);
985
- }
986
- const contents = map({
987
- $metadata: deserializeMetadata(output),
988
- });
989
- const data = __expectObject(await parseBody(output.body, context));
990
- contents.mesh = de_MeshData(data, context);
991
- return contents;
992
- };
993
- export const de_UpdateRouteCommand = async (output, context) => {
994
- if (output.statusCode !== 200 && output.statusCode >= 300) {
995
- return de_CommandError(output, context);
996
- }
997
- const contents = map({
998
- $metadata: deserializeMetadata(output),
999
- });
1000
- const data = __expectObject(await parseBody(output.body, context));
1001
- contents.route = de_RouteData(data, context);
1002
- return contents;
1003
- };
1004
- export const de_UpdateVirtualGatewayCommand = async (output, context) => {
1005
- if (output.statusCode !== 200 && output.statusCode >= 300) {
1006
- return de_CommandError(output, context);
1007
- }
1008
- const contents = map({
1009
- $metadata: deserializeMetadata(output),
1010
- });
1011
- const data = __expectObject(await parseBody(output.body, context));
1012
- contents.virtualGateway = de_VirtualGatewayData(data, context);
1013
- return contents;
1014
- };
1015
- export const de_UpdateVirtualNodeCommand = async (output, context) => {
1016
- if (output.statusCode !== 200 && output.statusCode >= 300) {
1017
- return de_CommandError(output, context);
1018
- }
1019
- const contents = map({
1020
- $metadata: deserializeMetadata(output),
1021
- });
1022
- const data = __expectObject(await parseBody(output.body, context));
1023
- contents.virtualNode = de_VirtualNodeData(data, context);
1024
- return contents;
1025
- };
1026
- export const de_UpdateVirtualRouterCommand = async (output, context) => {
1027
- if (output.statusCode !== 200 && output.statusCode >= 300) {
1028
- return de_CommandError(output, context);
1029
- }
1030
- const contents = map({
1031
- $metadata: deserializeMetadata(output),
1032
- });
1033
- const data = __expectObject(await parseBody(output.body, context));
1034
- contents.virtualRouter = de_VirtualRouterData(data, context);
1035
- return contents;
1036
- };
1037
- export const de_UpdateVirtualServiceCommand = async (output, context) => {
1038
- if (output.statusCode !== 200 && output.statusCode >= 300) {
1039
- return de_CommandError(output, context);
1040
- }
1041
- const contents = map({
1042
- $metadata: deserializeMetadata(output),
1043
- });
1044
- const data = __expectObject(await parseBody(output.body, context));
1045
- contents.virtualService = de_VirtualServiceData(data, context);
1046
- return contents;
1047
- };
1048
- const de_CommandError = async (output, context) => {
1049
- const parsedOutput = {
1050
- ...output,
1051
- body: await parseErrorBody(output.body, context),
1052
- };
1053
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1054
- switch (errorCode) {
1055
- case "BadRequestException":
1056
- case "com.amazonaws.appmesh#BadRequestException":
1057
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1058
- case "ConflictException":
1059
- case "com.amazonaws.appmesh#ConflictException":
1060
- throw await de_ConflictExceptionRes(parsedOutput, context);
1061
- case "ForbiddenException":
1062
- case "com.amazonaws.appmesh#ForbiddenException":
1063
- throw await de_ForbiddenExceptionRes(parsedOutput, context);
1064
- case "InternalServerErrorException":
1065
- case "com.amazonaws.appmesh#InternalServerErrorException":
1066
- throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
1067
- case "LimitExceededException":
1068
- case "com.amazonaws.appmesh#LimitExceededException":
1069
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1070
- case "NotFoundException":
1071
- case "com.amazonaws.appmesh#NotFoundException":
1072
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1073
- case "ServiceUnavailableException":
1074
- case "com.amazonaws.appmesh#ServiceUnavailableException":
1075
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
1076
- case "TooManyRequestsException":
1077
- case "com.amazonaws.appmesh#TooManyRequestsException":
1078
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1079
- case "ResourceInUseException":
1080
- case "com.amazonaws.appmesh#ResourceInUseException":
1081
- throw await de_ResourceInUseExceptionRes(parsedOutput, context);
1082
- case "TooManyTagsException":
1083
- case "com.amazonaws.appmesh#TooManyTagsException":
1084
- throw await de_TooManyTagsExceptionRes(parsedOutput, context);
1085
- default:
1086
- const parsedBody = parsedOutput.body;
1087
- return throwDefaultError({
1088
- output,
1089
- parsedBody,
1090
- errorCode,
1091
- });
1092
- }
1093
- };
1094
- const throwDefaultError = withBaseException(__BaseException);
1095
- const de_BadRequestExceptionRes = async (parsedOutput, context) => {
1096
- const contents = map({});
1097
- const data = parsedOutput.body;
1098
- const doc = take(data, {
1099
- message: __expectString,
1100
- });
1101
- Object.assign(contents, doc);
1102
- const exception = new BadRequestException({
1103
- $metadata: deserializeMetadata(parsedOutput),
1104
- ...contents,
1105
- });
1106
- return __decorateServiceException(exception, parsedOutput.body);
1107
- };
1108
- const de_ConflictExceptionRes = async (parsedOutput, context) => {
1109
- const contents = map({});
1110
- const data = parsedOutput.body;
1111
- const doc = take(data, {
1112
- message: __expectString,
1113
- });
1114
- Object.assign(contents, doc);
1115
- const exception = new ConflictException({
1116
- $metadata: deserializeMetadata(parsedOutput),
1117
- ...contents,
1118
- });
1119
- return __decorateServiceException(exception, parsedOutput.body);
1120
- };
1121
- const de_ForbiddenExceptionRes = async (parsedOutput, context) => {
1122
- const contents = map({});
1123
- const data = parsedOutput.body;
1124
- const doc = take(data, {
1125
- message: __expectString,
1126
- });
1127
- Object.assign(contents, doc);
1128
- const exception = new ForbiddenException({
1129
- $metadata: deserializeMetadata(parsedOutput),
1130
- ...contents,
1131
- });
1132
- return __decorateServiceException(exception, parsedOutput.body);
1133
- };
1134
- const de_InternalServerErrorExceptionRes = async (parsedOutput, context) => {
1135
- const contents = map({});
1136
- const data = parsedOutput.body;
1137
- const doc = take(data, {
1138
- message: __expectString,
1139
- });
1140
- Object.assign(contents, doc);
1141
- const exception = new InternalServerErrorException({
1142
- $metadata: deserializeMetadata(parsedOutput),
1143
- ...contents,
1144
- });
1145
- return __decorateServiceException(exception, parsedOutput.body);
1146
- };
1147
- const de_LimitExceededExceptionRes = async (parsedOutput, context) => {
1148
- const contents = map({});
1149
- const data = parsedOutput.body;
1150
- const doc = take(data, {
1151
- message: __expectString,
1152
- });
1153
- Object.assign(contents, doc);
1154
- const exception = new LimitExceededException({
1155
- $metadata: deserializeMetadata(parsedOutput),
1156
- ...contents,
1157
- });
1158
- return __decorateServiceException(exception, parsedOutput.body);
1159
- };
1160
- const de_NotFoundExceptionRes = async (parsedOutput, context) => {
1161
- const contents = map({});
1162
- const data = parsedOutput.body;
1163
- const doc = take(data, {
1164
- message: __expectString,
1165
- });
1166
- Object.assign(contents, doc);
1167
- const exception = new NotFoundException({
1168
- $metadata: deserializeMetadata(parsedOutput),
1169
- ...contents,
1170
- });
1171
- return __decorateServiceException(exception, parsedOutput.body);
1172
- };
1173
- const de_ResourceInUseExceptionRes = async (parsedOutput, context) => {
1174
- const contents = map({});
1175
- const data = parsedOutput.body;
1176
- const doc = take(data, {
1177
- message: __expectString,
1178
- });
1179
- Object.assign(contents, doc);
1180
- const exception = new ResourceInUseException({
1181
- $metadata: deserializeMetadata(parsedOutput),
1182
- ...contents,
1183
- });
1184
- return __decorateServiceException(exception, parsedOutput.body);
1185
- };
1186
- const de_ServiceUnavailableExceptionRes = async (parsedOutput, context) => {
1187
- const contents = map({});
1188
- const data = parsedOutput.body;
1189
- const doc = take(data, {
1190
- message: __expectString,
1191
- });
1192
- Object.assign(contents, doc);
1193
- const exception = new ServiceUnavailableException({
1194
- $metadata: deserializeMetadata(parsedOutput),
1195
- ...contents,
1196
- });
1197
- return __decorateServiceException(exception, parsedOutput.body);
1198
- };
1199
- const de_TooManyRequestsExceptionRes = async (parsedOutput, context) => {
1200
- const contents = map({});
1201
- const data = parsedOutput.body;
1202
- const doc = take(data, {
1203
- message: __expectString,
1204
- });
1205
- Object.assign(contents, doc);
1206
- const exception = new TooManyRequestsException({
1207
- $metadata: deserializeMetadata(parsedOutput),
1208
- ...contents,
1209
- });
1210
- return __decorateServiceException(exception, parsedOutput.body);
1211
- };
1212
- const de_TooManyTagsExceptionRes = async (parsedOutput, context) => {
1213
- const contents = map({});
1214
- const data = parsedOutput.body;
1215
- const doc = take(data, {
1216
- message: __expectString,
1217
- });
1218
- Object.assign(contents, doc);
1219
- const exception = new TooManyTagsException({
1220
- $metadata: deserializeMetadata(parsedOutput),
1221
- ...contents,
1222
- });
1223
- return __decorateServiceException(exception, parsedOutput.body);
1224
- };
1225
- const de_GatewayRouteData = (output, context) => {
1226
- return take(output, {
1227
- gatewayRouteName: __expectString,
1228
- meshName: __expectString,
1229
- metadata: (_) => de_ResourceMetadata(_, context),
1230
- spec: _json,
1231
- status: _json,
1232
- virtualGatewayName: __expectString,
1233
- });
1234
- };
1235
- const de_GatewayRouteList = (output, context) => {
1236
- const retVal = (output || [])
1237
- .filter((e) => e != null)
1238
- .map((entry) => {
1239
- return de_GatewayRouteRef(entry, context);
1240
- });
1241
- return retVal;
1242
- };
1243
- const de_GatewayRouteRef = (output, context) => {
1244
- return take(output, {
1245
- arn: __expectString,
1246
- createdAt: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
1247
- gatewayRouteName: __expectString,
1248
- lastUpdatedAt: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
1249
- meshName: __expectString,
1250
- meshOwner: __expectString,
1251
- resourceOwner: __expectString,
1252
- version: __expectLong,
1253
- virtualGatewayName: __expectString,
1254
- });
1255
- };
1256
- const de_MeshData = (output, context) => {
1257
- return take(output, {
1258
- meshName: __expectString,
1259
- metadata: (_) => de_ResourceMetadata(_, context),
1260
- spec: _json,
1261
- status: _json,
1262
- });
1263
- };
1264
- const de_MeshList = (output, context) => {
1265
- const retVal = (output || [])
1266
- .filter((e) => e != null)
1267
- .map((entry) => {
1268
- return de_MeshRef(entry, context);
1269
- });
1270
- return retVal;
1271
- };
1272
- const de_MeshRef = (output, context) => {
1273
- return take(output, {
1274
- arn: __expectString,
1275
- createdAt: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
1276
- lastUpdatedAt: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
1277
- meshName: __expectString,
1278
- meshOwner: __expectString,
1279
- resourceOwner: __expectString,
1280
- version: __expectLong,
1281
- });
1282
- };
1283
- const de_ResourceMetadata = (output, context) => {
1284
- return take(output, {
1285
- arn: __expectString,
1286
- createdAt: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
1287
- lastUpdatedAt: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
1288
- meshOwner: __expectString,
1289
- resourceOwner: __expectString,
1290
- uid: __expectString,
1291
- version: __expectLong,
1292
- });
1293
- };
1294
- const de_RouteData = (output, context) => {
1295
- return take(output, {
1296
- meshName: __expectString,
1297
- metadata: (_) => de_ResourceMetadata(_, context),
1298
- routeName: __expectString,
1299
- spec: _json,
1300
- status: _json,
1301
- virtualRouterName: __expectString,
1302
- });
1303
- };
1304
- const de_RouteList = (output, context) => {
1305
- const retVal = (output || [])
1306
- .filter((e) => e != null)
1307
- .map((entry) => {
1308
- return de_RouteRef(entry, context);
1309
- });
1310
- return retVal;
1311
- };
1312
- const de_RouteRef = (output, context) => {
1313
- return take(output, {
1314
- arn: __expectString,
1315
- createdAt: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
1316
- lastUpdatedAt: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
1317
- meshName: __expectString,
1318
- meshOwner: __expectString,
1319
- resourceOwner: __expectString,
1320
- routeName: __expectString,
1321
- version: __expectLong,
1322
- virtualRouterName: __expectString,
1323
- });
1324
- };
1325
- const de_VirtualGatewayData = (output, context) => {
1326
- return take(output, {
1327
- meshName: __expectString,
1328
- metadata: (_) => de_ResourceMetadata(_, context),
1329
- spec: _json,
1330
- status: _json,
1331
- virtualGatewayName: __expectString,
1332
- });
1333
- };
1334
- const de_VirtualGatewayList = (output, context) => {
1335
- const retVal = (output || [])
1336
- .filter((e) => e != null)
1337
- .map((entry) => {
1338
- return de_VirtualGatewayRef(entry, context);
1339
- });
1340
- return retVal;
1341
- };
1342
- const de_VirtualGatewayRef = (output, context) => {
1343
- return take(output, {
1344
- arn: __expectString,
1345
- createdAt: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
1346
- lastUpdatedAt: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
1347
- meshName: __expectString,
1348
- meshOwner: __expectString,
1349
- resourceOwner: __expectString,
1350
- version: __expectLong,
1351
- virtualGatewayName: __expectString,
1352
- });
1353
- };
1354
- const de_VirtualNodeData = (output, context) => {
1355
- return take(output, {
1356
- meshName: __expectString,
1357
- metadata: (_) => de_ResourceMetadata(_, context),
1358
- spec: _json,
1359
- status: _json,
1360
- virtualNodeName: __expectString,
1361
- });
1362
- };
1363
- const de_VirtualNodeList = (output, context) => {
1364
- const retVal = (output || [])
1365
- .filter((e) => e != null)
1366
- .map((entry) => {
1367
- return de_VirtualNodeRef(entry, context);
1368
- });
1369
- return retVal;
1370
- };
1371
- const de_VirtualNodeRef = (output, context) => {
1372
- return take(output, {
1373
- arn: __expectString,
1374
- createdAt: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
1375
- lastUpdatedAt: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
1376
- meshName: __expectString,
1377
- meshOwner: __expectString,
1378
- resourceOwner: __expectString,
1379
- version: __expectLong,
1380
- virtualNodeName: __expectString,
1381
- });
1382
- };
1383
- const de_VirtualRouterData = (output, context) => {
1384
- return take(output, {
1385
- meshName: __expectString,
1386
- metadata: (_) => de_ResourceMetadata(_, context),
1387
- spec: _json,
1388
- status: _json,
1389
- virtualRouterName: __expectString,
1390
- });
1391
- };
1392
- const de_VirtualRouterList = (output, context) => {
1393
- const retVal = (output || [])
1394
- .filter((e) => e != null)
1395
- .map((entry) => {
1396
- return de_VirtualRouterRef(entry, context);
1397
- });
1398
- return retVal;
1399
- };
1400
- const de_VirtualRouterRef = (output, context) => {
1401
- return take(output, {
1402
- arn: __expectString,
1403
- createdAt: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
1404
- lastUpdatedAt: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
1405
- meshName: __expectString,
1406
- meshOwner: __expectString,
1407
- resourceOwner: __expectString,
1408
- version: __expectLong,
1409
- virtualRouterName: __expectString,
1410
- });
1411
- };
1412
- const de_VirtualServiceData = (output, context) => {
1413
- return take(output, {
1414
- meshName: __expectString,
1415
- metadata: (_) => de_ResourceMetadata(_, context),
1416
- spec: _json,
1417
- status: _json,
1418
- virtualServiceName: __expectString,
1419
- });
1420
- };
1421
- const de_VirtualServiceList = (output, context) => {
1422
- const retVal = (output || [])
1423
- .filter((e) => e != null)
1424
- .map((entry) => {
1425
- return de_VirtualServiceRef(entry, context);
1426
- });
1427
- return retVal;
1428
- };
1429
- const de_VirtualServiceRef = (output, context) => {
1430
- return take(output, {
1431
- arn: __expectString,
1432
- createdAt: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
1433
- lastUpdatedAt: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
1434
- meshName: __expectString,
1435
- meshOwner: __expectString,
1436
- resourceOwner: __expectString,
1437
- version: __expectLong,
1438
- virtualServiceName: __expectString,
1439
- });
1440
- };
1441
- const deserializeMetadata = (output) => ({
1442
- httpStatusCode: output.statusCode,
1443
- requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
1444
- extendedRequestId: output.headers["x-amz-id-2"],
1445
- cfId: output.headers["x-amz-cf-id"],
1446
- });
1447
- const collectBodyString = (streamBody, context) => collectBody(streamBody, context).then((body) => context.utf8Encoder(body));
1448
- const _l = "limit";
1449
- const _mO = "meshOwner";
1450
- const _nT = "nextToken";
1451
- const _rA = "resourceArn";