@aws-sdk/client-networkmanager 3.474.0 → 3.477.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (3) hide show
  1. package/dist-cjs/protocols/Aws_restJson1.js +590 -1214
  2. package/dist-es/protocols/Aws_restJson1.js +591 -1215
  3. package/package.json +5 -4
package/dist-es/protocols/Aws_restJson1.js CHANGED
@@ -1,125 +1,86 @@
1
- import { HttpRequest as __HttpRequest } from "@smithy/protocol-http";
2
- import { _json, collectBody, decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectInt32 as __expectInt32, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectObject as __expectObject, expectString as __expectString, LazyJsonString as __LazyJsonString, map, parseEpochTimestamp as __parseEpochTimestamp, resolvedPath as __resolvedPath, strictParseInt32 as __strictParseInt32, take, withBaseException, } from "@smithy/smithy-client";
1
+ import { requestBuilder as rb } from "@smithy/core";
2
+ import { _json, collectBody, decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectInt32 as __expectInt32, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectObject as __expectObject, expectString as __expectString, LazyJsonString as __LazyJsonString, map, parseEpochTimestamp as __parseEpochTimestamp, strictParseInt32 as __strictParseInt32, take, withBaseException, } from "@smithy/smithy-client";
3
3
  import { v4 as generateIdempotencyToken } from "uuid";
4
4
  import { AccessDeniedException, ConflictException, CoreNetworkPolicyException, InternalServerException, ResourceNotFoundException, ServiceQuotaExceededException, ThrottlingException, ValidationException, } from "../models/models_0";
5
5
  import { NetworkManagerServiceException as __BaseException } from "../models/NetworkManagerServiceException";
6
6
  export const se_AcceptAttachmentCommand = async (input, context) => {
7
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
7
+ const b = rb(input, context);
8
8
  const headers = {};
9
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/attachments/{AttachmentId}/accept";
10
- resolvedPath = __resolvedPath(resolvedPath, input, "AttachmentId", () => input.AttachmentId, "{AttachmentId}", false);
9
+ b.bp("/attachments/{AttachmentId}/accept");
10
+ b.p("AttachmentId", () => input.AttachmentId, "{AttachmentId}", false);
11
11
  let body;
12
- return new __HttpRequest({
13
- protocol,
14
- hostname,
15
- port,
16
- method: "POST",
17
- headers,
18
- path: resolvedPath,
19
- body,
20
- });
12
+ b.m("POST").h(headers).b(body);
13
+ return b.build();
21
14
  };
22
15
  export const se_AssociateConnectPeerCommand = async (input, context) => {
23
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
16
+ const b = rb(input, context);
24
17
  const headers = {
25
18
  "content-type": "application/json",
26
19
  };
27
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
28
- "/global-networks/{GlobalNetworkId}/connect-peer-associations";
29
- resolvedPath = __resolvedPath(resolvedPath, input, "GlobalNetworkId", () => input.GlobalNetworkId, "{GlobalNetworkId}", false);
20
+ b.bp("/global-networks/{GlobalNetworkId}/connect-peer-associations");
21
+ b.p("GlobalNetworkId", () => input.GlobalNetworkId, "{GlobalNetworkId}", false);
30
22
  let body;
31
23
  body = JSON.stringify(take(input, {
32
24
  ConnectPeerId: [],
33
25
  DeviceId: [],
34
26
  LinkId: [],
35
27
  }));
36
- return new __HttpRequest({
37
- protocol,
38
- hostname,
39
- port,
40
- method: "POST",
41
- headers,
42
- path: resolvedPath,
43
- body,
44
- });
28
+ b.m("POST").h(headers).b(body);
29
+ return b.build();
45
30
  };
46
31
  export const se_AssociateCustomerGatewayCommand = async (input, context) => {
47
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
32
+ const b = rb(input, context);
48
33
  const headers = {
49
34
  "content-type": "application/json",
50
35
  };
51
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
52
- "/global-networks/{GlobalNetworkId}/customer-gateway-associations";
53
- resolvedPath = __resolvedPath(resolvedPath, input, "GlobalNetworkId", () => input.GlobalNetworkId, "{GlobalNetworkId}", false);
36
+ b.bp("/global-networks/{GlobalNetworkId}/customer-gateway-associations");
37
+ b.p("GlobalNetworkId", () => input.GlobalNetworkId, "{GlobalNetworkId}", false);
54
38
  let body;
55
39
  body = JSON.stringify(take(input, {
56
40
  CustomerGatewayArn: [],
57
41
  DeviceId: [],
58
42
  LinkId: [],
59
43
  }));
60
- return new __HttpRequest({
61
- protocol,
62
- hostname,
63
- port,
64
- method: "POST",
65
- headers,
66
- path: resolvedPath,
67
- body,
68
- });
44
+ b.m("POST").h(headers).b(body);
45
+ return b.build();
69
46
  };
70
47
  export const se_AssociateLinkCommand = async (input, context) => {
71
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
48
+ const b = rb(input, context);
72
49
  const headers = {
73
50
  "content-type": "application/json",
74
51
  };
75
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
76
- "/global-networks/{GlobalNetworkId}/link-associations";
77
- resolvedPath = __resolvedPath(resolvedPath, input, "GlobalNetworkId", () => input.GlobalNetworkId, "{GlobalNetworkId}", false);
52
+ b.bp("/global-networks/{GlobalNetworkId}/link-associations");
53
+ b.p("GlobalNetworkId", () => input.GlobalNetworkId, "{GlobalNetworkId}", false);
78
54
  let body;
79
55
  body = JSON.stringify(take(input, {
80
56
  DeviceId: [],
81
57
  LinkId: [],
82
58
  }));
83
- return new __HttpRequest({
84
- protocol,
85
- hostname,
86
- port,
87
- method: "POST",
88
- headers,
89
- path: resolvedPath,
90
- body,
91
- });
59
+ b.m("POST").h(headers).b(body);
60
+ return b.build();
92
61
  };
93
62
  export const se_AssociateTransitGatewayConnectPeerCommand = async (input, context) => {
94
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
63
+ const b = rb(input, context);
95
64
  const headers = {
96
65
  "content-type": "application/json",
97
66
  };
98
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
99
- "/global-networks/{GlobalNetworkId}/transit-gateway-connect-peer-associations";
100
- resolvedPath = __resolvedPath(resolvedPath, input, "GlobalNetworkId", () => input.GlobalNetworkId, "{GlobalNetworkId}", false);
67
+ b.bp("/global-networks/{GlobalNetworkId}/transit-gateway-connect-peer-associations");
68
+ b.p("GlobalNetworkId", () => input.GlobalNetworkId, "{GlobalNetworkId}", false);
101
69
  let body;
102
70
  body = JSON.stringify(take(input, {
103
71
  DeviceId: [],
104
72
  LinkId: [],
105
73
  TransitGatewayConnectPeerArn: [],
106
74
  }));
107
- return new __HttpRequest({
108
- protocol,
109
- hostname,
110
- port,
111
- method: "POST",
112
- headers,
113
- path: resolvedPath,
114
- body,
115
- });
75
+ b.m("POST").h(headers).b(body);
76
+ return b.build();
116
77
  };
117
78
  export const se_CreateConnectAttachmentCommand = async (input, context) => {
118
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
79
+ const b = rb(input, context);
119
80
  const headers = {
120
81
  "content-type": "application/json",
121
82
  };
122
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/connect-attachments";
83
+ b.bp("/connect-attachments");
123
84
  let body;
124
85
  body = JSON.stringify(take(input, {
125
86
  ClientToken: [true, (_) => _ ?? generateIdempotencyToken()],
@@ -129,24 +90,16 @@ export const se_CreateConnectAttachmentCommand = async (input, context) => {
129
90
  Tags: (_) => _json(_),
130
91
  TransportAttachmentId: [],
131
92
  }));
132
- return new __HttpRequest({
133
- protocol,
134
- hostname,
135
- port,
136
- method: "POST",
137
- headers,
138
- path: resolvedPath,
139
- body,
140
- });
93
+ b.m("POST").h(headers).b(body);
94
+ return b.build();
141
95
  };
142
96
  export const se_CreateConnectionCommand = async (input, context) => {
143
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
97
+ const b = rb(input, context);
144
98
  const headers = {
145
99
  "content-type": "application/json",
146
100
  };
147
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
148
- "/global-networks/{GlobalNetworkId}/connections";
149
- resolvedPath = __resolvedPath(resolvedPath, input, "GlobalNetworkId", () => input.GlobalNetworkId, "{GlobalNetworkId}", false);
101
+ b.bp("/global-networks/{GlobalNetworkId}/connections");
102
+ b.p("GlobalNetworkId", () => input.GlobalNetworkId, "{GlobalNetworkId}", false);
150
103
  let body;
151
104
  body = JSON.stringify(take(input, {
152
105
  ConnectedDeviceId: [],
@@ -156,22 +109,15 @@ export const se_CreateConnectionCommand = async (input, context) => {
156
109
  LinkId: [],
157
110
  Tags: (_) => _json(_),
158
111
  }));
159
- return new __HttpRequest({
160
- protocol,
161
- hostname,
162
- port,
163
- method: "POST",
164
- headers,
165
- path: resolvedPath,
166
- body,
167
- });
112
+ b.m("POST").h(headers).b(body);
113
+ return b.build();
168
114
  };
169
115
  export const se_CreateConnectPeerCommand = async (input, context) => {
170
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
116
+ const b = rb(input, context);
171
117
  const headers = {
172
118
  "content-type": "application/json",
173
119
  };
174
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/connect-peers";
120
+ b.bp("/connect-peers");
175
121
  let body;
176
122
  body = JSON.stringify(take(input, {
177
123
  BgpOptions: (_) => _json(_),
@@ -183,22 +129,15 @@ export const se_CreateConnectPeerCommand = async (input, context) => {
183
129
  SubnetArn: [],
184
130
  Tags: (_) => _json(_),
185
131
  }));
186
- return new __HttpRequest({
187
- protocol,
188
- hostname,
189
- port,
190
- method: "POST",
191
- headers,
192
- path: resolvedPath,
193
- body,
194
- });
132
+ b.m("POST").h(headers).b(body);
133
+ return b.build();
195
134
  };
196
135
  export const se_CreateCoreNetworkCommand = async (input, context) => {
197
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
136
+ const b = rb(input, context);
198
137
  const headers = {
199
138
  "content-type": "application/json",
200
139
  };
201
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/core-networks";
140
+ b.bp("/core-networks");
202
141
  let body;
203
142
  body = JSON.stringify(take(input, {
204
143
  ClientToken: [true, (_) => _ ?? generateIdempotencyToken()],
@@ -207,24 +146,16 @@ export const se_CreateCoreNetworkCommand = async (input, context) => {
207
146
  PolicyDocument: [],
208
147
  Tags: (_) => _json(_),
209
148
  }));
210
- return new __HttpRequest({
211
- protocol,
212
- hostname,
213
- port,
214
- method: "POST",
215
- headers,
216
- path: resolvedPath,
217
- body,
218
- });
149
+ b.m("POST").h(headers).b(body);
150
+ return b.build();
219
151
  };
220
152
  export const se_CreateDeviceCommand = async (input, context) => {
221
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
153
+ const b = rb(input, context);
222
154
  const headers = {
223
155
  "content-type": "application/json",
224
156
  };
225
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
226
- "/global-networks/{GlobalNetworkId}/devices";
227
- resolvedPath = __resolvedPath(resolvedPath, input, "GlobalNetworkId", () => input.GlobalNetworkId, "{GlobalNetworkId}", false);
157
+ b.bp("/global-networks/{GlobalNetworkId}/devices");
158
+ b.p("GlobalNetworkId", () => input.GlobalNetworkId, "{GlobalNetworkId}", false);
228
159
  let body;
229
160
  body = JSON.stringify(take(input, {
230
161
  AWSLocation: (_) => _json(_),
@@ -237,44 +168,30 @@ export const se_CreateDeviceCommand = async (input, context) => {
237
168
  Type: [],
238
169
  Vendor: [],
239
170
  }));
240
- return new __HttpRequest({
241
- protocol,
242
- hostname,
243
- port,
244
- method: "POST",
245
- headers,
246
- path: resolvedPath,
247
- body,
248
- });
171
+ b.m("POST").h(headers).b(body);
172
+ return b.build();
249
173
  };
250
174
  export const se_CreateGlobalNetworkCommand = async (input, context) => {
251
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
175
+ const b = rb(input, context);
252
176
  const headers = {
253
177
  "content-type": "application/json",
254
178
  };
255
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/global-networks";
179
+ b.bp("/global-networks");
256
180
  let body;
257
181
  body = JSON.stringify(take(input, {
258
182
  Description: [],
259
183
  Tags: (_) => _json(_),
260
184
  }));
261
- return new __HttpRequest({
262
- protocol,
263
- hostname,
264
- port,
265
- method: "POST",
266
- headers,
267
- path: resolvedPath,
268
- body,
269
- });
185
+ b.m("POST").h(headers).b(body);
186
+ return b.build();
270
187
  };
271
188
  export const se_CreateLinkCommand = async (input, context) => {
272
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
189
+ const b = rb(input, context);
273
190
  const headers = {
274
191
  "content-type": "application/json",
275
192
  };
276
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/global-networks/{GlobalNetworkId}/links";
277
- resolvedPath = __resolvedPath(resolvedPath, input, "GlobalNetworkId", () => input.GlobalNetworkId, "{GlobalNetworkId}", false);
193
+ b.bp("/global-networks/{GlobalNetworkId}/links");
194
+ b.p("GlobalNetworkId", () => input.GlobalNetworkId, "{GlobalNetworkId}", false);
278
195
  let body;
279
196
  body = JSON.stringify(take(input, {
280
197
  Bandwidth: (_) => _json(_),
@@ -284,45 +201,31 @@ export const se_CreateLinkCommand = async (input, context) => {
284
201
  Tags: (_) => _json(_),
285
202
  Type: [],
286
203
  }));
287
- return new __HttpRequest({
288
- protocol,
289
- hostname,
290
- port,
291
- method: "POST",
292
- headers,
293
- path: resolvedPath,
294
- body,
295
- });
204
+ b.m("POST").h(headers).b(body);
205
+ return b.build();
296
206
  };
297
207
  export const se_CreateSiteCommand = async (input, context) => {
298
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
208
+ const b = rb(input, context);
299
209
  const headers = {
300
210
  "content-type": "application/json",
301
211
  };
302
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/global-networks/{GlobalNetworkId}/sites";
303
- resolvedPath = __resolvedPath(resolvedPath, input, "GlobalNetworkId", () => input.GlobalNetworkId, "{GlobalNetworkId}", false);
212
+ b.bp("/global-networks/{GlobalNetworkId}/sites");
213
+ b.p("GlobalNetworkId", () => input.GlobalNetworkId, "{GlobalNetworkId}", false);
304
214
  let body;
305
215
  body = JSON.stringify(take(input, {
306
216
  Description: [],
307
217
  Location: (_) => _json(_),
308
218
  Tags: (_) => _json(_),
309
219
  }));
310
- return new __HttpRequest({
311
- protocol,
312
- hostname,
313
- port,
314
- method: "POST",
315
- headers,
316
- path: resolvedPath,
317
- body,
318
- });
220
+ b.m("POST").h(headers).b(body);
221
+ return b.build();
319
222
  };
320
223
  export const se_CreateSiteToSiteVpnAttachmentCommand = async (input, context) => {
321
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
224
+ const b = rb(input, context);
322
225
  const headers = {
323
226
  "content-type": "application/json",
324
227
  };
325
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/site-to-site-vpn-attachments";
228
+ b.bp("/site-to-site-vpn-attachments");
326
229
  let body;
327
230
  body = JSON.stringify(take(input, {
328
231
  ClientToken: [true, (_) => _ ?? generateIdempotencyToken()],
@@ -330,22 +233,15 @@ export const se_CreateSiteToSiteVpnAttachmentCommand = async (input, context) =>
330
233
  Tags: (_) => _json(_),
331
234
  VpnConnectionArn: [],
332
235
  }));
333
- return new __HttpRequest({
334
- protocol,
335
- hostname,
336
- port,
337
- method: "POST",
338
- headers,
339
- path: resolvedPath,
340
- body,
341
- });
236
+ b.m("POST").h(headers).b(body);
237
+ return b.build();
342
238
  };
343
239
  export const se_CreateTransitGatewayPeeringCommand = async (input, context) => {
344
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
240
+ const b = rb(input, context);
345
241
  const headers = {
346
242
  "content-type": "application/json",
347
243
  };
348
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/transit-gateway-peerings";
244
+ b.bp("/transit-gateway-peerings");
349
245
  let body;
350
246
  body = JSON.stringify(take(input, {
351
247
  ClientToken: [true, (_) => _ ?? generateIdempotencyToken()],
@@ -353,22 +249,15 @@ export const se_CreateTransitGatewayPeeringCommand = async (input, context) => {
353
249
  Tags: (_) => _json(_),
354
250
  TransitGatewayArn: [],
355
251
  }));
356
- return new __HttpRequest({
357
- protocol,
358
- hostname,
359
- port,
360
- method: "POST",
361
- headers,
362
- path: resolvedPath,
363
- body,
364
- });
252
+ b.m("POST").h(headers).b(body);
253
+ return b.build();
365
254
  };
366
255
  export const se_CreateTransitGatewayRouteTableAttachmentCommand = async (input, context) => {
367
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
256
+ const b = rb(input, context);
368
257
  const headers = {
369
258
  "content-type": "application/json",
370
259
  };
371
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/transit-gateway-route-table-attachments";
260
+ b.bp("/transit-gateway-route-table-attachments");
372
261
  let body;
373
262
  body = JSON.stringify(take(input, {
374
263
  ClientToken: [true, (_) => _ ?? generateIdempotencyToken()],
@@ -376,22 +265,15 @@ export const se_CreateTransitGatewayRouteTableAttachmentCommand = async (input,
376
265
  Tags: (_) => _json(_),
377
266
  TransitGatewayRouteTableArn: [],
378
267
  }));
379
- return new __HttpRequest({
380
- protocol,
381
- hostname,
382
- port,
383
- method: "POST",
384
- headers,
385
- path: resolvedPath,
386
- body,
387
- });
268
+ b.m("POST").h(headers).b(body);
269
+ return b.build();
388
270
  };
389
271
  export const se_CreateVpcAttachmentCommand = async (input, context) => {
390
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
272
+ const b = rb(input, context);
391
273
  const headers = {
392
274
  "content-type": "application/json",
393
275
  };
394
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/vpc-attachments";
276
+ b.bp("/vpc-attachments");
395
277
  let body;
396
278
  body = JSON.stringify(take(input, {
397
279
  ClientToken: [true, (_) => _ ?? generateIdempotencyToken()],
@@ -401,693 +283,406 @@ export const se_CreateVpcAttachmentCommand = async (input, context) => {
401
283
  Tags: (_) => _json(_),
402
284
  VpcArn: [],
403
285
  }));
404
- return new __HttpRequest({
405
- protocol,
406
- hostname,
407
- port,
408
- method: "POST",
409
- headers,
410
- path: resolvedPath,
411
- body,
412
- });
286
+ b.m("POST").h(headers).b(body);
287
+ return b.build();
413
288
  };
414
289
  export const se_DeleteAttachmentCommand = async (input, context) => {
415
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
290
+ const b = rb(input, context);
416
291
  const headers = {};
417
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/attachments/{AttachmentId}";
418
- resolvedPath = __resolvedPath(resolvedPath, input, "AttachmentId", () => input.AttachmentId, "{AttachmentId}", false);
292
+ b.bp("/attachments/{AttachmentId}");
293
+ b.p("AttachmentId", () => input.AttachmentId, "{AttachmentId}", false);
419
294
  let body;
420
- return new __HttpRequest({
421
- protocol,
422
- hostname,
423
- port,
424
- method: "DELETE",
425
- headers,
426
- path: resolvedPath,
427
- body,
428
- });
295
+ b.m("DELETE").h(headers).b(body);
296
+ return b.build();
429
297
  };
430
298
  export const se_DeleteConnectionCommand = async (input, context) => {
431
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
299
+ const b = rb(input, context);
432
300
  const headers = {};
433
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
434
- "/global-networks/{GlobalNetworkId}/connections/{ConnectionId}";
435
- resolvedPath = __resolvedPath(resolvedPath, input, "GlobalNetworkId", () => input.GlobalNetworkId, "{GlobalNetworkId}", false);
436
- resolvedPath = __resolvedPath(resolvedPath, input, "ConnectionId", () => input.ConnectionId, "{ConnectionId}", false);
301
+ b.bp("/global-networks/{GlobalNetworkId}/connections/{ConnectionId}");
302
+ b.p("GlobalNetworkId", () => input.GlobalNetworkId, "{GlobalNetworkId}", false);
303
+ b.p("ConnectionId", () => input.ConnectionId, "{ConnectionId}", false);
437
304
  let body;
438
- return new __HttpRequest({
439
- protocol,
440
- hostname,
441
- port,
442
- method: "DELETE",
443
- headers,
444
- path: resolvedPath,
445
- body,
446
- });
305
+ b.m("DELETE").h(headers).b(body);
306
+ return b.build();
447
307
  };
448
308
  export const se_DeleteConnectPeerCommand = async (input, context) => {
449
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
309
+ const b = rb(input, context);
450
310
  const headers = {};
451
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/connect-peers/{ConnectPeerId}";
452
- resolvedPath = __resolvedPath(resolvedPath, input, "ConnectPeerId", () => input.ConnectPeerId, "{ConnectPeerId}", false);
311
+ b.bp("/connect-peers/{ConnectPeerId}");
312
+ b.p("ConnectPeerId", () => input.ConnectPeerId, "{ConnectPeerId}", false);
453
313
  let body;
454
- return new __HttpRequest({
455
- protocol,
456
- hostname,
457
- port,
458
- method: "DELETE",
459
- headers,
460
- path: resolvedPath,
461
- body,
462
- });
314
+ b.m("DELETE").h(headers).b(body);
315
+ return b.build();
463
316
  };
464
317
  export const se_DeleteCoreNetworkCommand = async (input, context) => {
465
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
318
+ const b = rb(input, context);
466
319
  const headers = {};
467
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/core-networks/{CoreNetworkId}";
468
- resolvedPath = __resolvedPath(resolvedPath, input, "CoreNetworkId", () => input.CoreNetworkId, "{CoreNetworkId}", false);
320
+ b.bp("/core-networks/{CoreNetworkId}");
321
+ b.p("CoreNetworkId", () => input.CoreNetworkId, "{CoreNetworkId}", false);
469
322
  let body;
470
- return new __HttpRequest({
471
- protocol,
472
- hostname,
473
- port,
474
- method: "DELETE",
475
- headers,
476
- path: resolvedPath,
477
- body,
478
- });
323
+ b.m("DELETE").h(headers).b(body);
324
+ return b.build();
479
325
  };
480
326
  export const se_DeleteCoreNetworkPolicyVersionCommand = async (input, context) => {
481
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
327
+ const b = rb(input, context);
482
328
  const headers = {};
483
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
484
- "/core-networks/{CoreNetworkId}/core-network-policy-versions/{PolicyVersionId}";
485
- resolvedPath = __resolvedPath(resolvedPath, input, "CoreNetworkId", () => input.CoreNetworkId, "{CoreNetworkId}", false);
486
- resolvedPath = __resolvedPath(resolvedPath, input, "PolicyVersionId", () => input.PolicyVersionId.toString(), "{PolicyVersionId}", false);
329
+ b.bp("/core-networks/{CoreNetworkId}/core-network-policy-versions/{PolicyVersionId}");
330
+ b.p("CoreNetworkId", () => input.CoreNetworkId, "{CoreNetworkId}", false);
331
+ b.p("PolicyVersionId", () => input.PolicyVersionId.toString(), "{PolicyVersionId}", false);
487
332
  let body;
488
- return new __HttpRequest({
489
- protocol,
490
- hostname,
491
- port,
492
- method: "DELETE",
493
- headers,
494
- path: resolvedPath,
495
- body,
496
- });
333
+ b.m("DELETE").h(headers).b(body);
334
+ return b.build();
497
335
  };
498
336
  export const se_DeleteDeviceCommand = async (input, context) => {
499
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
337
+ const b = rb(input, context);
500
338
  const headers = {};
501
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
502
- "/global-networks/{GlobalNetworkId}/devices/{DeviceId}";
503
- resolvedPath = __resolvedPath(resolvedPath, input, "GlobalNetworkId", () => input.GlobalNetworkId, "{GlobalNetworkId}", false);
504
- resolvedPath = __resolvedPath(resolvedPath, input, "DeviceId", () => input.DeviceId, "{DeviceId}", false);
339
+ b.bp("/global-networks/{GlobalNetworkId}/devices/{DeviceId}");
340
+ b.p("GlobalNetworkId", () => input.GlobalNetworkId, "{GlobalNetworkId}", false);
341
+ b.p("DeviceId", () => input.DeviceId, "{DeviceId}", false);
505
342
  let body;
506
- return new __HttpRequest({
507
- protocol,
508
- hostname,
509
- port,
510
- method: "DELETE",
511
- headers,
512
- path: resolvedPath,
513
- body,
514
- });
343
+ b.m("DELETE").h(headers).b(body);
344
+ return b.build();
515
345
  };
516
346
  export const se_DeleteGlobalNetworkCommand = async (input, context) => {
517
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
347
+ const b = rb(input, context);
518
348
  const headers = {};
519
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/global-networks/{GlobalNetworkId}";
520
- resolvedPath = __resolvedPath(resolvedPath, input, "GlobalNetworkId", () => input.GlobalNetworkId, "{GlobalNetworkId}", false);
349
+ b.bp("/global-networks/{GlobalNetworkId}");
350
+ b.p("GlobalNetworkId", () => input.GlobalNetworkId, "{GlobalNetworkId}", false);
521
351
  let body;
522
- return new __HttpRequest({
523
- protocol,
524
- hostname,
525
- port,
526
- method: "DELETE",
527
- headers,
528
- path: resolvedPath,
529
- body,
530
- });
352
+ b.m("DELETE").h(headers).b(body);
353
+ return b.build();
531
354
  };
532
355
  export const se_DeleteLinkCommand = async (input, context) => {
533
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
356
+ const b = rb(input, context);
534
357
  const headers = {};
535
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
536
- "/global-networks/{GlobalNetworkId}/links/{LinkId}";
537
- resolvedPath = __resolvedPath(resolvedPath, input, "GlobalNetworkId", () => input.GlobalNetworkId, "{GlobalNetworkId}", false);
538
- resolvedPath = __resolvedPath(resolvedPath, input, "LinkId", () => input.LinkId, "{LinkId}", false);
358
+ b.bp("/global-networks/{GlobalNetworkId}/links/{LinkId}");
359
+ b.p("GlobalNetworkId", () => input.GlobalNetworkId, "{GlobalNetworkId}", false);
360
+ b.p("LinkId", () => input.LinkId, "{LinkId}", false);
539
361
  let body;
540
- return new __HttpRequest({
541
- protocol,
542
- hostname,
543
- port,
544
- method: "DELETE",
545
- headers,
546
- path: resolvedPath,
547
- body,
548
- });
362
+ b.m("DELETE").h(headers).b(body);
363
+ return b.build();
549
364
  };
550
365
  export const se_DeletePeeringCommand = async (input, context) => {
551
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
366
+ const b = rb(input, context);
552
367
  const headers = {};
553
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/peerings/{PeeringId}";
554
- resolvedPath = __resolvedPath(resolvedPath, input, "PeeringId", () => input.PeeringId, "{PeeringId}", false);
368
+ b.bp("/peerings/{PeeringId}");
369
+ b.p("PeeringId", () => input.PeeringId, "{PeeringId}", false);
555
370
  let body;
556
- return new __HttpRequest({
557
- protocol,
558
- hostname,
559
- port,
560
- method: "DELETE",
561
- headers,
562
- path: resolvedPath,
563
- body,
564
- });
371
+ b.m("DELETE").h(headers).b(body);
372
+ return b.build();
565
373
  };
566
374
  export const se_DeleteResourcePolicyCommand = async (input, context) => {
567
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
375
+ const b = rb(input, context);
568
376
  const headers = {};
569
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/resource-policy/{ResourceArn}";
570
- resolvedPath = __resolvedPath(resolvedPath, input, "ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
377
+ b.bp("/resource-policy/{ResourceArn}");
378
+ b.p("ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
571
379
  let body;
572
- return new __HttpRequest({
573
- protocol,
574
- hostname,
575
- port,
576
- method: "DELETE",
577
- headers,
578
- path: resolvedPath,
579
- body,
580
- });
380
+ b.m("DELETE").h(headers).b(body);
381
+ return b.build();
581
382
  };
582
383
  export const se_DeleteSiteCommand = async (input, context) => {
583
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
384
+ const b = rb(input, context);
584
385
  const headers = {};
585
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
586
- "/global-networks/{GlobalNetworkId}/sites/{SiteId}";
587
- resolvedPath = __resolvedPath(resolvedPath, input, "GlobalNetworkId", () => input.GlobalNetworkId, "{GlobalNetworkId}", false);
588
- resolvedPath = __resolvedPath(resolvedPath, input, "SiteId", () => input.SiteId, "{SiteId}", false);
386
+ b.bp("/global-networks/{GlobalNetworkId}/sites/{SiteId}");
387
+ b.p("GlobalNetworkId", () => input.GlobalNetworkId, "{GlobalNetworkId}", false);
388
+ b.p("SiteId", () => input.SiteId, "{SiteId}", false);
589
389
  let body;
590
- return new __HttpRequest({
591
- protocol,
592
- hostname,
593
- port,
594
- method: "DELETE",
595
- headers,
596
- path: resolvedPath,
597
- body,
598
- });
390
+ b.m("DELETE").h(headers).b(body);
391
+ return b.build();
599
392
  };
600
393
  export const se_DeregisterTransitGatewayCommand = async (input, context) => {
601
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
394
+ const b = rb(input, context);
602
395
  const headers = {};
603
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
604
- "/global-networks/{GlobalNetworkId}/transit-gateway-registrations/{TransitGatewayArn}";
605
- resolvedPath = __resolvedPath(resolvedPath, input, "GlobalNetworkId", () => input.GlobalNetworkId, "{GlobalNetworkId}", false);
606
- resolvedPath = __resolvedPath(resolvedPath, input, "TransitGatewayArn", () => input.TransitGatewayArn, "{TransitGatewayArn}", false);
396
+ b.bp("/global-networks/{GlobalNetworkId}/transit-gateway-registrations/{TransitGatewayArn}");
397
+ b.p("GlobalNetworkId", () => input.GlobalNetworkId, "{GlobalNetworkId}", false);
398
+ b.p("TransitGatewayArn", () => input.TransitGatewayArn, "{TransitGatewayArn}", false);
607
399
  let body;
608
- return new __HttpRequest({
609
- protocol,
610
- hostname,
611
- port,
612
- method: "DELETE",
613
- headers,
614
- path: resolvedPath,
615
- body,
616
- });
400
+ b.m("DELETE").h(headers).b(body);
401
+ return b.build();
617
402
  };
618
403
  export const se_DescribeGlobalNetworksCommand = async (input, context) => {
619
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
404
+ const b = rb(input, context);
620
405
  const headers = {};
621
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/global-networks";
406
+ b.bp("/global-networks");
622
407
  const query = map({
623
- globalNetworkIds: [
624
- () => input.GlobalNetworkIds !== void 0,
625
- () => (input.GlobalNetworkIds || []).map((_entry) => _entry),
626
- ],
627
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
628
- nextToken: [, input.NextToken],
408
+ [_gNI]: [() => input.GlobalNetworkIds !== void 0, () => (input[_GNI] || []).map((_entry) => _entry)],
409
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
410
+ [_nT]: [, input[_NT]],
629
411
  });
630
412
  let body;
631
- return new __HttpRequest({
632
- protocol,
633
- hostname,
634
- port,
635
- method: "GET",
636
- headers,
637
- path: resolvedPath,
638
- query,
639
- body,
640
- });
413
+ b.m("GET").h(headers).q(query).b(body);
414
+ return b.build();
641
415
  };
642
416
  export const se_DisassociateConnectPeerCommand = async (input, context) => {
643
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
417
+ const b = rb(input, context);
644
418
  const headers = {};
645
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
646
- "/global-networks/{GlobalNetworkId}/connect-peer-associations/{ConnectPeerId}";
647
- resolvedPath = __resolvedPath(resolvedPath, input, "GlobalNetworkId", () => input.GlobalNetworkId, "{GlobalNetworkId}", false);
648
- resolvedPath = __resolvedPath(resolvedPath, input, "ConnectPeerId", () => input.ConnectPeerId, "{ConnectPeerId}", false);
419
+ b.bp("/global-networks/{GlobalNetworkId}/connect-peer-associations/{ConnectPeerId}");
420
+ b.p("GlobalNetworkId", () => input.GlobalNetworkId, "{GlobalNetworkId}", false);
421
+ b.p("ConnectPeerId", () => input.ConnectPeerId, "{ConnectPeerId}", false);
649
422
  let body;
650
- return new __HttpRequest({
651
- protocol,
652
- hostname,
653
- port,
654
- method: "DELETE",
655
- headers,
656
- path: resolvedPath,
657
- body,
658
- });
423
+ b.m("DELETE").h(headers).b(body);
424
+ return b.build();
659
425
  };
660
426
  export const se_DisassociateCustomerGatewayCommand = async (input, context) => {
661
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
427
+ const b = rb(input, context);
662
428
  const headers = {};
663
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
664
- "/global-networks/{GlobalNetworkId}/customer-gateway-associations/{CustomerGatewayArn}";
665
- resolvedPath = __resolvedPath(resolvedPath, input, "GlobalNetworkId", () => input.GlobalNetworkId, "{GlobalNetworkId}", false);
666
- resolvedPath = __resolvedPath(resolvedPath, input, "CustomerGatewayArn", () => input.CustomerGatewayArn, "{CustomerGatewayArn}", false);
429
+ b.bp("/global-networks/{GlobalNetworkId}/customer-gateway-associations/{CustomerGatewayArn}");
430
+ b.p("GlobalNetworkId", () => input.GlobalNetworkId, "{GlobalNetworkId}", false);
431
+ b.p("CustomerGatewayArn", () => input.CustomerGatewayArn, "{CustomerGatewayArn}", false);
667
432
  let body;
668
- return new __HttpRequest({
669
- protocol,
670
- hostname,
671
- port,
672
- method: "DELETE",
673
- headers,
674
- path: resolvedPath,
675
- body,
676
- });
433
+ b.m("DELETE").h(headers).b(body);
434
+ return b.build();
677
435
  };
678
436
  export const se_DisassociateLinkCommand = async (input, context) => {
679
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
437
+ const b = rb(input, context);
680
438
  const headers = {};
681
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
682
- "/global-networks/{GlobalNetworkId}/link-associations";
683
- resolvedPath = __resolvedPath(resolvedPath, input, "GlobalNetworkId", () => input.GlobalNetworkId, "{GlobalNetworkId}", false);
439
+ b.bp("/global-networks/{GlobalNetworkId}/link-associations");
440
+ b.p("GlobalNetworkId", () => input.GlobalNetworkId, "{GlobalNetworkId}", false);
684
441
  const query = map({
685
- deviceId: [, __expectNonNull(input.DeviceId, `DeviceId`)],
686
- linkId: [, __expectNonNull(input.LinkId, `LinkId`)],
442
+ [_dI]: [, __expectNonNull(input[_DI], `DeviceId`)],
443
+ [_lI]: [, __expectNonNull(input[_LI], `LinkId`)],
687
444
  });
688
445
  let body;
689
- return new __HttpRequest({
690
- protocol,
691
- hostname,
692
- port,
693
- method: "DELETE",
694
- headers,
695
- path: resolvedPath,
696
- query,
697
- body,
698
- });
446
+ b.m("DELETE").h(headers).q(query).b(body);
447
+ return b.build();
699
448
  };
700
449
  export const se_DisassociateTransitGatewayConnectPeerCommand = async (input, context) => {
701
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
450
+ const b = rb(input, context);
702
451
  const headers = {};
703
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
704
- "/global-networks/{GlobalNetworkId}/transit-gateway-connect-peer-associations/{TransitGatewayConnectPeerArn}";
705
- resolvedPath = __resolvedPath(resolvedPath, input, "GlobalNetworkId", () => input.GlobalNetworkId, "{GlobalNetworkId}", false);
706
- resolvedPath = __resolvedPath(resolvedPath, input, "TransitGatewayConnectPeerArn", () => input.TransitGatewayConnectPeerArn, "{TransitGatewayConnectPeerArn}", false);
452
+ b.bp("/global-networks/{GlobalNetworkId}/transit-gateway-connect-peer-associations/{TransitGatewayConnectPeerArn}");
453
+ b.p("GlobalNetworkId", () => input.GlobalNetworkId, "{GlobalNetworkId}", false);
454
+ b.p("TransitGatewayConnectPeerArn", () => input.TransitGatewayConnectPeerArn, "{TransitGatewayConnectPeerArn}", false);
707
455
  let body;
708
- return new __HttpRequest({
709
- protocol,
710
- hostname,
711
- port,
712
- method: "DELETE",
713
- headers,
714
- path: resolvedPath,
715
- body,
716
- });
456
+ b.m("DELETE").h(headers).b(body);
457
+ return b.build();
717
458
  };
718
459
  export const se_ExecuteCoreNetworkChangeSetCommand = async (input, context) => {
719
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
460
+ const b = rb(input, context);
720
461
  const headers = {};
721
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
722
- "/core-networks/{CoreNetworkId}/core-network-change-sets/{PolicyVersionId}/execute";
723
- resolvedPath = __resolvedPath(resolvedPath, input, "CoreNetworkId", () => input.CoreNetworkId, "{CoreNetworkId}", false);
724
- resolvedPath = __resolvedPath(resolvedPath, input, "PolicyVersionId", () => input.PolicyVersionId.toString(), "{PolicyVersionId}", false);
462
+ b.bp("/core-networks/{CoreNetworkId}/core-network-change-sets/{PolicyVersionId}/execute");
463
+ b.p("CoreNetworkId", () => input.CoreNetworkId, "{CoreNetworkId}", false);
464
+ b.p("PolicyVersionId", () => input.PolicyVersionId.toString(), "{PolicyVersionId}", false);
725
465
  let body;
726
- return new __HttpRequest({
727
- protocol,
728
- hostname,
729
- port,
730
- method: "POST",
731
- headers,
732
- path: resolvedPath,
733
- body,
734
- });
466
+ b.m("POST").h(headers).b(body);
467
+ return b.build();
735
468
  };
736
469
  export const se_GetConnectAttachmentCommand = async (input, context) => {
737
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
470
+ const b = rb(input, context);
738
471
  const headers = {};
739
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/connect-attachments/{AttachmentId}";
740
- resolvedPath = __resolvedPath(resolvedPath, input, "AttachmentId", () => input.AttachmentId, "{AttachmentId}", false);
472
+ b.bp("/connect-attachments/{AttachmentId}");
473
+ b.p("AttachmentId", () => input.AttachmentId, "{AttachmentId}", false);
741
474
  let body;
742
- return new __HttpRequest({
743
- protocol,
744
- hostname,
745
- port,
746
- method: "GET",
747
- headers,
748
- path: resolvedPath,
749
- body,
750
- });
475
+ b.m("GET").h(headers).b(body);
476
+ return b.build();
751
477
  };
752
478
  export const se_GetConnectionsCommand = async (input, context) => {
753
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
479
+ const b = rb(input, context);
754
480
  const headers = {};
755
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
756
- "/global-networks/{GlobalNetworkId}/connections";
757
- resolvedPath = __resolvedPath(resolvedPath, input, "GlobalNetworkId", () => input.GlobalNetworkId, "{GlobalNetworkId}", false);
481
+ b.bp("/global-networks/{GlobalNetworkId}/connections");
482
+ b.p("GlobalNetworkId", () => input.GlobalNetworkId, "{GlobalNetworkId}", false);
758
483
  const query = map({
759
- connectionIds: [
760
- () => input.ConnectionIds !== void 0,
761
- () => (input.ConnectionIds || []).map((_entry) => _entry),
762
- ],
763
- deviceId: [, input.DeviceId],
764
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
765
- nextToken: [, input.NextToken],
484
+ [_cI]: [() => input.ConnectionIds !== void 0, () => (input[_CI] || []).map((_entry) => _entry)],
485
+ [_dI]: [, input[_DI]],
486
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
487
+ [_nT]: [, input[_NT]],
766
488
  });
767
489
  let body;
768
- return new __HttpRequest({
769
- protocol,
770
- hostname,
771
- port,
772
- method: "GET",
773
- headers,
774
- path: resolvedPath,
775
- query,
776
- body,
777
- });
490
+ b.m("GET").h(headers).q(query).b(body);
491
+ return b.build();
778
492
  };
779
493
  export const se_GetConnectPeerCommand = async (input, context) => {
780
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
494
+ const b = rb(input, context);
781
495
  const headers = {};
782
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/connect-peers/{ConnectPeerId}";
783
- resolvedPath = __resolvedPath(resolvedPath, input, "ConnectPeerId", () => input.ConnectPeerId, "{ConnectPeerId}", false);
496
+ b.bp("/connect-peers/{ConnectPeerId}");
497
+ b.p("ConnectPeerId", () => input.ConnectPeerId, "{ConnectPeerId}", false);
784
498
  let body;
785
- return new __HttpRequest({
786
- protocol,
787
- hostname,
788
- port,
789
- method: "GET",
790
- headers,
791
- path: resolvedPath,
792
- body,
793
- });
499
+ b.m("GET").h(headers).b(body);
500
+ return b.build();
794
501
  };
795
502
  export const se_GetConnectPeerAssociationsCommand = async (input, context) => {
796
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
503
+ const b = rb(input, context);
797
504
  const headers = {};
798
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
799
- "/global-networks/{GlobalNetworkId}/connect-peer-associations";
800
- resolvedPath = __resolvedPath(resolvedPath, input, "GlobalNetworkId", () => input.GlobalNetworkId, "{GlobalNetworkId}", false);
505
+ b.bp("/global-networks/{GlobalNetworkId}/connect-peer-associations");
506
+ b.p("GlobalNetworkId", () => input.GlobalNetworkId, "{GlobalNetworkId}", false);
801
507
  const query = map({
802
- connectPeerIds: [
803
- () => input.ConnectPeerIds !== void 0,
804
- () => (input.ConnectPeerIds || []).map((_entry) => _entry),
805
- ],
806
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
807
- nextToken: [, input.NextToken],
508
+ [_cPI]: [() => input.ConnectPeerIds !== void 0, () => (input[_CPI] || []).map((_entry) => _entry)],
509
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
510
+ [_nT]: [, input[_NT]],
808
511
  });
809
512
  let body;
810
- return new __HttpRequest({
811
- protocol,
812
- hostname,
813
- port,
814
- method: "GET",
815
- headers,
816
- path: resolvedPath,
817
- query,
818
- body,
819
- });
513
+ b.m("GET").h(headers).q(query).b(body);
514
+ return b.build();
820
515
  };
821
516
  export const se_GetCoreNetworkCommand = async (input, context) => {
822
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
517
+ const b = rb(input, context);
823
518
  const headers = {};
824
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/core-networks/{CoreNetworkId}";
825
- resolvedPath = __resolvedPath(resolvedPath, input, "CoreNetworkId", () => input.CoreNetworkId, "{CoreNetworkId}", false);
519
+ b.bp("/core-networks/{CoreNetworkId}");
520
+ b.p("CoreNetworkId", () => input.CoreNetworkId, "{CoreNetworkId}", false);
826
521
  let body;
827
- return new __HttpRequest({
828
- protocol,
829
- hostname,
830
- port,
831
- method: "GET",
832
- headers,
833
- path: resolvedPath,
834
- body,
835
- });
522
+ b.m("GET").h(headers).b(body);
523
+ return b.build();
836
524
  };
837
525
  export const se_GetCoreNetworkChangeEventsCommand = async (input, context) => {
838
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
526
+ const b = rb(input, context);
839
527
  const headers = {};
840
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
841
- "/core-networks/{CoreNetworkId}/core-network-change-events/{PolicyVersionId}";
842
- resolvedPath = __resolvedPath(resolvedPath, input, "CoreNetworkId", () => input.CoreNetworkId, "{CoreNetworkId}", false);
843
- resolvedPath = __resolvedPath(resolvedPath, input, "PolicyVersionId", () => input.PolicyVersionId.toString(), "{PolicyVersionId}", false);
528
+ b.bp("/core-networks/{CoreNetworkId}/core-network-change-events/{PolicyVersionId}");
529
+ b.p("CoreNetworkId", () => input.CoreNetworkId, "{CoreNetworkId}", false);
530
+ b.p("PolicyVersionId", () => input.PolicyVersionId.toString(), "{PolicyVersionId}", false);
844
531
  const query = map({
845
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
846
- nextToken: [, input.NextToken],
532
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
533
+ [_nT]: [, input[_NT]],
847
534
  });
848
535
  let body;
849
- return new __HttpRequest({
850
- protocol,
851
- hostname,
852
- port,
853
- method: "GET",
854
- headers,
855
- path: resolvedPath,
856
- query,
857
- body,
858
- });
536
+ b.m("GET").h(headers).q(query).b(body);
537
+ return b.build();
859
538
  };
860
539
  export const se_GetCoreNetworkChangeSetCommand = async (input, context) => {
861
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
540
+ const b = rb(input, context);
862
541
  const headers = {};
863
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
864
- "/core-networks/{CoreNetworkId}/core-network-change-sets/{PolicyVersionId}";
865
- resolvedPath = __resolvedPath(resolvedPath, input, "CoreNetworkId", () => input.CoreNetworkId, "{CoreNetworkId}", false);
866
- resolvedPath = __resolvedPath(resolvedPath, input, "PolicyVersionId", () => input.PolicyVersionId.toString(), "{PolicyVersionId}", false);
542
+ b.bp("/core-networks/{CoreNetworkId}/core-network-change-sets/{PolicyVersionId}");
543
+ b.p("CoreNetworkId", () => input.CoreNetworkId, "{CoreNetworkId}", false);
544
+ b.p("PolicyVersionId", () => input.PolicyVersionId.toString(), "{PolicyVersionId}", false);
867
545
  const query = map({
868
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
869
- nextToken: [, input.NextToken],
546
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
547
+ [_nT]: [, input[_NT]],
870
548
  });
871
549
  let body;
872
- return new __HttpRequest({
873
- protocol,
874
- hostname,
875
- port,
876
- method: "GET",
877
- headers,
878
- path: resolvedPath,
879
- query,
880
- body,
881
- });
550
+ b.m("GET").h(headers).q(query).b(body);
551
+ return b.build();
882
552
  };
883
553
  export const se_GetCoreNetworkPolicyCommand = async (input, context) => {
884
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
554
+ const b = rb(input, context);
885
555
  const headers = {};
886
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
887
- "/core-networks/{CoreNetworkId}/core-network-policy";
888
- resolvedPath = __resolvedPath(resolvedPath, input, "CoreNetworkId", () => input.CoreNetworkId, "{CoreNetworkId}", false);
556
+ b.bp("/core-networks/{CoreNetworkId}/core-network-policy");
557
+ b.p("CoreNetworkId", () => input.CoreNetworkId, "{CoreNetworkId}", false);
889
558
  const query = map({
890
- policyVersionId: [() => input.PolicyVersionId !== void 0, () => input.PolicyVersionId.toString()],
891
- alias: [, input.Alias],
559
+ [_pVI]: [() => input.PolicyVersionId !== void 0, () => input[_PVI].toString()],
560
+ [_a]: [, input[_A]],
892
561
  });
893
562
  let body;
894
- return new __HttpRequest({
895
- protocol,
896
- hostname,
897
- port,
898
- method: "GET",
899
- headers,
900
- path: resolvedPath,
901
- query,
902
- body,
903
- });
563
+ b.m("GET").h(headers).q(query).b(body);
564
+ return b.build();
904
565
  };
905
566
  export const se_GetCustomerGatewayAssociationsCommand = async (input, context) => {
906
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
567
+ const b = rb(input, context);
907
568
  const headers = {};
908
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
909
- "/global-networks/{GlobalNetworkId}/customer-gateway-associations";
910
- resolvedPath = __resolvedPath(resolvedPath, input, "GlobalNetworkId", () => input.GlobalNetworkId, "{GlobalNetworkId}", false);
569
+ b.bp("/global-networks/{GlobalNetworkId}/customer-gateway-associations");
570
+ b.p("GlobalNetworkId", () => input.GlobalNetworkId, "{GlobalNetworkId}", false);
911
571
  const query = map({
912
- customerGatewayArns: [
913
- () => input.CustomerGatewayArns !== void 0,
914
- () => (input.CustomerGatewayArns || []).map((_entry) => _entry),
915
- ],
916
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
917
- nextToken: [, input.NextToken],
572
+ [_cGA]: [() => input.CustomerGatewayArns !== void 0, () => (input[_CGA] || []).map((_entry) => _entry)],
573
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
574
+ [_nT]: [, input[_NT]],
918
575
  });
919
576
  let body;
920
- return new __HttpRequest({
921
- protocol,
922
- hostname,
923
- port,
924
- method: "GET",
925
- headers,
926
- path: resolvedPath,
927
- query,
928
- body,
929
- });
577
+ b.m("GET").h(headers).q(query).b(body);
578
+ return b.build();
930
579
  };
931
580
  export const se_GetDevicesCommand = async (input, context) => {
932
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
581
+ const b = rb(input, context);
933
582
  const headers = {};
934
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
935
- "/global-networks/{GlobalNetworkId}/devices";
936
- resolvedPath = __resolvedPath(resolvedPath, input, "GlobalNetworkId", () => input.GlobalNetworkId, "{GlobalNetworkId}", false);
583
+ b.bp("/global-networks/{GlobalNetworkId}/devices");
584
+ b.p("GlobalNetworkId", () => input.GlobalNetworkId, "{GlobalNetworkId}", false);
937
585
  const query = map({
938
- deviceIds: [() => input.DeviceIds !== void 0, () => (input.DeviceIds || []).map((_entry) => _entry)],
939
- siteId: [, input.SiteId],
940
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
941
- nextToken: [, input.NextToken],
586
+ [_dIe]: [() => input.DeviceIds !== void 0, () => (input[_DIe] || []).map((_entry) => _entry)],
587
+ [_sI]: [, input[_SI]],
588
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
589
+ [_nT]: [, input[_NT]],
942
590
  });
943
591
  let body;
944
- return new __HttpRequest({
945
- protocol,
946
- hostname,
947
- port,
948
- method: "GET",
949
- headers,
950
- path: resolvedPath,
951
- query,
952
- body,
953
- });
592
+ b.m("GET").h(headers).q(query).b(body);
593
+ return b.build();
954
594
  };
955
595
  export const se_GetLinkAssociationsCommand = async (input, context) => {
956
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
596
+ const b = rb(input, context);
957
597
  const headers = {};
958
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
959
- "/global-networks/{GlobalNetworkId}/link-associations";
960
- resolvedPath = __resolvedPath(resolvedPath, input, "GlobalNetworkId", () => input.GlobalNetworkId, "{GlobalNetworkId}", false);
598
+ b.bp("/global-networks/{GlobalNetworkId}/link-associations");
599
+ b.p("GlobalNetworkId", () => input.GlobalNetworkId, "{GlobalNetworkId}", false);
961
600
  const query = map({
962
- deviceId: [, input.DeviceId],
963
- linkId: [, input.LinkId],
964
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
965
- nextToken: [, input.NextToken],
601
+ [_dI]: [, input[_DI]],
602
+ [_lI]: [, input[_LI]],
603
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
604
+ [_nT]: [, input[_NT]],
966
605
  });
967
606
  let body;
968
- return new __HttpRequest({
969
- protocol,
970
- hostname,
971
- port,
972
- method: "GET",
973
- headers,
974
- path: resolvedPath,
975
- query,
976
- body,
977
- });
607
+ b.m("GET").h(headers).q(query).b(body);
608
+ return b.build();
978
609
  };
979
610
  export const se_GetLinksCommand = async (input, context) => {
980
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
611
+ const b = rb(input, context);
981
612
  const headers = {};
982
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/global-networks/{GlobalNetworkId}/links";
983
- resolvedPath = __resolvedPath(resolvedPath, input, "GlobalNetworkId", () => input.GlobalNetworkId, "{GlobalNetworkId}", false);
613
+ b.bp("/global-networks/{GlobalNetworkId}/links");
614
+ b.p("GlobalNetworkId", () => input.GlobalNetworkId, "{GlobalNetworkId}", false);
984
615
  const query = map({
985
- linkIds: [() => input.LinkIds !== void 0, () => (input.LinkIds || []).map((_entry) => _entry)],
986
- siteId: [, input.SiteId],
987
- type: [, input.Type],
988
- provider: [, input.Provider],
989
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
990
- nextToken: [, input.NextToken],
616
+ [_lIi]: [() => input.LinkIds !== void 0, () => (input[_LIi] || []).map((_entry) => _entry)],
617
+ [_sI]: [, input[_SI]],
618
+ [_t]: [, input[_T]],
619
+ [_p]: [, input[_P]],
620
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
621
+ [_nT]: [, input[_NT]],
991
622
  });
992
623
  let body;
993
- return new __HttpRequest({
994
- protocol,
995
- hostname,
996
- port,
997
- method: "GET",
998
- headers,
999
- path: resolvedPath,
1000
- query,
1001
- body,
1002
- });
624
+ b.m("GET").h(headers).q(query).b(body);
625
+ return b.build();
1003
626
  };
1004
627
  export const se_GetNetworkResourceCountsCommand = async (input, context) => {
1005
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
628
+ const b = rb(input, context);
1006
629
  const headers = {};
1007
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1008
- "/global-networks/{GlobalNetworkId}/network-resource-count";
1009
- resolvedPath = __resolvedPath(resolvedPath, input, "GlobalNetworkId", () => input.GlobalNetworkId, "{GlobalNetworkId}", false);
630
+ b.bp("/global-networks/{GlobalNetworkId}/network-resource-count");
631
+ b.p("GlobalNetworkId", () => input.GlobalNetworkId, "{GlobalNetworkId}", false);
1010
632
  const query = map({
1011
- resourceType: [, input.ResourceType],
1012
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
1013
- nextToken: [, input.NextToken],
633
+ [_rT]: [, input[_RT]],
634
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
635
+ [_nT]: [, input[_NT]],
1014
636
  });
1015
637
  let body;
1016
- return new __HttpRequest({
1017
- protocol,
1018
- hostname,
1019
- port,
1020
- method: "GET",
1021
- headers,
1022
- path: resolvedPath,
1023
- query,
1024
- body,
1025
- });
638
+ b.m("GET").h(headers).q(query).b(body);
639
+ return b.build();
1026
640
  };
1027
641
  export const se_GetNetworkResourceRelationshipsCommand = async (input, context) => {
1028
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
642
+ const b = rb(input, context);
1029
643
  const headers = {};
1030
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1031
- "/global-networks/{GlobalNetworkId}/network-resource-relationships";
1032
- resolvedPath = __resolvedPath(resolvedPath, input, "GlobalNetworkId", () => input.GlobalNetworkId, "{GlobalNetworkId}", false);
644
+ b.bp("/global-networks/{GlobalNetworkId}/network-resource-relationships");
645
+ b.p("GlobalNetworkId", () => input.GlobalNetworkId, "{GlobalNetworkId}", false);
1033
646
  const query = map({
1034
- coreNetworkId: [, input.CoreNetworkId],
1035
- registeredGatewayArn: [, input.RegisteredGatewayArn],
1036
- awsRegion: [, input.AwsRegion],
1037
- accountId: [, input.AccountId],
1038
- resourceType: [, input.ResourceType],
1039
- resourceArn: [, input.ResourceArn],
1040
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
1041
- nextToken: [, input.NextToken],
647
+ [_cNI]: [, input[_CNI]],
648
+ [_rGA]: [, input[_RGA]],
649
+ [_aR]: [, input[_AR]],
650
+ [_aI]: [, input[_AI]],
651
+ [_rT]: [, input[_RT]],
652
+ [_rA]: [, input[_RA]],
653
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
654
+ [_nT]: [, input[_NT]],
1042
655
  });
1043
656
  let body;
1044
- return new __HttpRequest({
1045
- protocol,
1046
- hostname,
1047
- port,
1048
- method: "GET",
1049
- headers,
1050
- path: resolvedPath,
1051
- query,
1052
- body,
1053
- });
657
+ b.m("GET").h(headers).q(query).b(body);
658
+ return b.build();
1054
659
  };
1055
660
  export const se_GetNetworkResourcesCommand = async (input, context) => {
1056
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
661
+ const b = rb(input, context);
1057
662
  const headers = {};
1058
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1059
- "/global-networks/{GlobalNetworkId}/network-resources";
1060
- resolvedPath = __resolvedPath(resolvedPath, input, "GlobalNetworkId", () => input.GlobalNetworkId, "{GlobalNetworkId}", false);
663
+ b.bp("/global-networks/{GlobalNetworkId}/network-resources");
664
+ b.p("GlobalNetworkId", () => input.GlobalNetworkId, "{GlobalNetworkId}", false);
1061
665
  const query = map({
1062
- coreNetworkId: [, input.CoreNetworkId],
1063
- registeredGatewayArn: [, input.RegisteredGatewayArn],
1064
- awsRegion: [, input.AwsRegion],
1065
- accountId: [, input.AccountId],
1066
- resourceType: [, input.ResourceType],
1067
- resourceArn: [, input.ResourceArn],
1068
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
1069
- nextToken: [, input.NextToken],
666
+ [_cNI]: [, input[_CNI]],
667
+ [_rGA]: [, input[_RGA]],
668
+ [_aR]: [, input[_AR]],
669
+ [_aI]: [, input[_AI]],
670
+ [_rT]: [, input[_RT]],
671
+ [_rA]: [, input[_RA]],
672
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
673
+ [_nT]: [, input[_NT]],
1070
674
  });
1071
675
  let body;
1072
- return new __HttpRequest({
1073
- protocol,
1074
- hostname,
1075
- port,
1076
- method: "GET",
1077
- headers,
1078
- path: resolvedPath,
1079
- query,
1080
- body,
1081
- });
676
+ b.m("GET").h(headers).q(query).b(body);
677
+ return b.build();
1082
678
  };
1083
679
  export const se_GetNetworkRoutesCommand = async (input, context) => {
1084
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
680
+ const b = rb(input, context);
1085
681
  const headers = {
1086
682
  "content-type": "application/json",
1087
683
  };
1088
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1089
- "/global-networks/{GlobalNetworkId}/network-routes";
1090
- resolvedPath = __resolvedPath(resolvedPath, input, "GlobalNetworkId", () => input.GlobalNetworkId, "{GlobalNetworkId}", false);
684
+ b.bp("/global-networks/{GlobalNetworkId}/network-routes");
685
+ b.p("GlobalNetworkId", () => input.GlobalNetworkId, "{GlobalNetworkId}", false);
1091
686
  let body;
1092
687
  body = JSON.stringify(take(input, {
1093
688
  DestinationFilters: (_) => _json(_),
@@ -1100,374 +695,227 @@ export const se_GetNetworkRoutesCommand = async (input, context) => {
1100
695
  SupernetOfMatches: (_) => _json(_),
1101
696
  Types: (_) => _json(_),
1102
697
  }));
1103
- return new __HttpRequest({
1104
- protocol,
1105
- hostname,
1106
- port,
1107
- method: "POST",
1108
- headers,
1109
- path: resolvedPath,
1110
- body,
1111
- });
698
+ b.m("POST").h(headers).b(body);
699
+ return b.build();
1112
700
  };
1113
701
  export const se_GetNetworkTelemetryCommand = async (input, context) => {
1114
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
702
+ const b = rb(input, context);
1115
703
  const headers = {};
1116
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1117
- "/global-networks/{GlobalNetworkId}/network-telemetry";
1118
- resolvedPath = __resolvedPath(resolvedPath, input, "GlobalNetworkId", () => input.GlobalNetworkId, "{GlobalNetworkId}", false);
704
+ b.bp("/global-networks/{GlobalNetworkId}/network-telemetry");
705
+ b.p("GlobalNetworkId", () => input.GlobalNetworkId, "{GlobalNetworkId}", false);
1119
706
  const query = map({
1120
- coreNetworkId: [, input.CoreNetworkId],
1121
- registeredGatewayArn: [, input.RegisteredGatewayArn],
1122
- awsRegion: [, input.AwsRegion],
1123
- accountId: [, input.AccountId],
1124
- resourceType: [, input.ResourceType],
1125
- resourceArn: [, input.ResourceArn],
1126
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
1127
- nextToken: [, input.NextToken],
707
+ [_cNI]: [, input[_CNI]],
708
+ [_rGA]: [, input[_RGA]],
709
+ [_aR]: [, input[_AR]],
710
+ [_aI]: [, input[_AI]],
711
+ [_rT]: [, input[_RT]],
712
+ [_rA]: [, input[_RA]],
713
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
714
+ [_nT]: [, input[_NT]],
1128
715
  });
1129
716
  let body;
1130
- return new __HttpRequest({
1131
- protocol,
1132
- hostname,
1133
- port,
1134
- method: "GET",
1135
- headers,
1136
- path: resolvedPath,
1137
- query,
1138
- body,
1139
- });
717
+ b.m("GET").h(headers).q(query).b(body);
718
+ return b.build();
1140
719
  };
1141
720
  export const se_GetResourcePolicyCommand = async (input, context) => {
1142
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
721
+ const b = rb(input, context);
1143
722
  const headers = {};
1144
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/resource-policy/{ResourceArn}";
1145
- resolvedPath = __resolvedPath(resolvedPath, input, "ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
723
+ b.bp("/resource-policy/{ResourceArn}");
724
+ b.p("ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
1146
725
  let body;
1147
- return new __HttpRequest({
1148
- protocol,
1149
- hostname,
1150
- port,
1151
- method: "GET",
1152
- headers,
1153
- path: resolvedPath,
1154
- body,
1155
- });
726
+ b.m("GET").h(headers).b(body);
727
+ return b.build();
1156
728
  };
1157
729
  export const se_GetRouteAnalysisCommand = async (input, context) => {
1158
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
730
+ const b = rb(input, context);
1159
731
  const headers = {};
1160
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1161
- "/global-networks/{GlobalNetworkId}/route-analyses/{RouteAnalysisId}";
1162
- resolvedPath = __resolvedPath(resolvedPath, input, "GlobalNetworkId", () => input.GlobalNetworkId, "{GlobalNetworkId}", false);
1163
- resolvedPath = __resolvedPath(resolvedPath, input, "RouteAnalysisId", () => input.RouteAnalysisId, "{RouteAnalysisId}", false);
732
+ b.bp("/global-networks/{GlobalNetworkId}/route-analyses/{RouteAnalysisId}");
733
+ b.p("GlobalNetworkId", () => input.GlobalNetworkId, "{GlobalNetworkId}", false);
734
+ b.p("RouteAnalysisId", () => input.RouteAnalysisId, "{RouteAnalysisId}", false);
1164
735
  let body;
1165
- return new __HttpRequest({
1166
- protocol,
1167
- hostname,
1168
- port,
1169
- method: "GET",
1170
- headers,
1171
- path: resolvedPath,
1172
- body,
1173
- });
736
+ b.m("GET").h(headers).b(body);
737
+ return b.build();
1174
738
  };
1175
739
  export const se_GetSitesCommand = async (input, context) => {
1176
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
740
+ const b = rb(input, context);
1177
741
  const headers = {};
1178
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/global-networks/{GlobalNetworkId}/sites";
1179
- resolvedPath = __resolvedPath(resolvedPath, input, "GlobalNetworkId", () => input.GlobalNetworkId, "{GlobalNetworkId}", false);
742
+ b.bp("/global-networks/{GlobalNetworkId}/sites");
743
+ b.p("GlobalNetworkId", () => input.GlobalNetworkId, "{GlobalNetworkId}", false);
1180
744
  const query = map({
1181
- siteIds: [() => input.SiteIds !== void 0, () => (input.SiteIds || []).map((_entry) => _entry)],
1182
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
1183
- nextToken: [, input.NextToken],
745
+ [_sIi]: [() => input.SiteIds !== void 0, () => (input[_SIi] || []).map((_entry) => _entry)],
746
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
747
+ [_nT]: [, input[_NT]],
1184
748
  });
1185
749
  let body;
1186
- return new __HttpRequest({
1187
- protocol,
1188
- hostname,
1189
- port,
1190
- method: "GET",
1191
- headers,
1192
- path: resolvedPath,
1193
- query,
1194
- body,
1195
- });
750
+ b.m("GET").h(headers).q(query).b(body);
751
+ return b.build();
1196
752
  };
1197
753
  export const se_GetSiteToSiteVpnAttachmentCommand = async (input, context) => {
1198
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
754
+ const b = rb(input, context);
1199
755
  const headers = {};
1200
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1201
- "/site-to-site-vpn-attachments/{AttachmentId}";
1202
- resolvedPath = __resolvedPath(resolvedPath, input, "AttachmentId", () => input.AttachmentId, "{AttachmentId}", false);
756
+ b.bp("/site-to-site-vpn-attachments/{AttachmentId}");
757
+ b.p("AttachmentId", () => input.AttachmentId, "{AttachmentId}", false);
1203
758
  let body;
1204
- return new __HttpRequest({
1205
- protocol,
1206
- hostname,
1207
- port,
1208
- method: "GET",
1209
- headers,
1210
- path: resolvedPath,
1211
- body,
1212
- });
759
+ b.m("GET").h(headers).b(body);
760
+ return b.build();
1213
761
  };
1214
762
  export const se_GetTransitGatewayConnectPeerAssociationsCommand = async (input, context) => {
1215
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
763
+ const b = rb(input, context);
1216
764
  const headers = {};
1217
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1218
- "/global-networks/{GlobalNetworkId}/transit-gateway-connect-peer-associations";
1219
- resolvedPath = __resolvedPath(resolvedPath, input, "GlobalNetworkId", () => input.GlobalNetworkId, "{GlobalNetworkId}", false);
765
+ b.bp("/global-networks/{GlobalNetworkId}/transit-gateway-connect-peer-associations");
766
+ b.p("GlobalNetworkId", () => input.GlobalNetworkId, "{GlobalNetworkId}", false);
1220
767
  const query = map({
1221
- transitGatewayConnectPeerArns: [
768
+ [_tGCPA]: [
1222
769
  () => input.TransitGatewayConnectPeerArns !== void 0,
1223
- () => (input.TransitGatewayConnectPeerArns || []).map((_entry) => _entry),
770
+ () => (input[_TGCPA] || []).map((_entry) => _entry),
1224
771
  ],
1225
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
1226
- nextToken: [, input.NextToken],
772
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
773
+ [_nT]: [, input[_NT]],
1227
774
  });
1228
775
  let body;
1229
- return new __HttpRequest({
1230
- protocol,
1231
- hostname,
1232
- port,
1233
- method: "GET",
1234
- headers,
1235
- path: resolvedPath,
1236
- query,
1237
- body,
1238
- });
776
+ b.m("GET").h(headers).q(query).b(body);
777
+ return b.build();
1239
778
  };
1240
779
  export const se_GetTransitGatewayPeeringCommand = async (input, context) => {
1241
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
780
+ const b = rb(input, context);
1242
781
  const headers = {};
1243
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/transit-gateway-peerings/{PeeringId}";
1244
- resolvedPath = __resolvedPath(resolvedPath, input, "PeeringId", () => input.PeeringId, "{PeeringId}", false);
782
+ b.bp("/transit-gateway-peerings/{PeeringId}");
783
+ b.p("PeeringId", () => input.PeeringId, "{PeeringId}", false);
1245
784
  let body;
1246
- return new __HttpRequest({
1247
- protocol,
1248
- hostname,
1249
- port,
1250
- method: "GET",
1251
- headers,
1252
- path: resolvedPath,
1253
- body,
1254
- });
785
+ b.m("GET").h(headers).b(body);
786
+ return b.build();
1255
787
  };
1256
788
  export const se_GetTransitGatewayRegistrationsCommand = async (input, context) => {
1257
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
789
+ const b = rb(input, context);
1258
790
  const headers = {};
1259
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1260
- "/global-networks/{GlobalNetworkId}/transit-gateway-registrations";
1261
- resolvedPath = __resolvedPath(resolvedPath, input, "GlobalNetworkId", () => input.GlobalNetworkId, "{GlobalNetworkId}", false);
791
+ b.bp("/global-networks/{GlobalNetworkId}/transit-gateway-registrations");
792
+ b.p("GlobalNetworkId", () => input.GlobalNetworkId, "{GlobalNetworkId}", false);
1262
793
  const query = map({
1263
- transitGatewayArns: [
1264
- () => input.TransitGatewayArns !== void 0,
1265
- () => (input.TransitGatewayArns || []).map((_entry) => _entry),
1266
- ],
1267
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
1268
- nextToken: [, input.NextToken],
794
+ [_tGA]: [() => input.TransitGatewayArns !== void 0, () => (input[_TGA] || []).map((_entry) => _entry)],
795
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
796
+ [_nT]: [, input[_NT]],
1269
797
  });
1270
798
  let body;
1271
- return new __HttpRequest({
1272
- protocol,
1273
- hostname,
1274
- port,
1275
- method: "GET",
1276
- headers,
1277
- path: resolvedPath,
1278
- query,
1279
- body,
1280
- });
799
+ b.m("GET").h(headers).q(query).b(body);
800
+ return b.build();
1281
801
  };
1282
802
  export const se_GetTransitGatewayRouteTableAttachmentCommand = async (input, context) => {
1283
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
803
+ const b = rb(input, context);
1284
804
  const headers = {};
1285
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1286
- "/transit-gateway-route-table-attachments/{AttachmentId}";
1287
- resolvedPath = __resolvedPath(resolvedPath, input, "AttachmentId", () => input.AttachmentId, "{AttachmentId}", false);
805
+ b.bp("/transit-gateway-route-table-attachments/{AttachmentId}");
806
+ b.p("AttachmentId", () => input.AttachmentId, "{AttachmentId}", false);
1288
807
  let body;
1289
- return new __HttpRequest({
1290
- protocol,
1291
- hostname,
1292
- port,
1293
- method: "GET",
1294
- headers,
1295
- path: resolvedPath,
1296
- body,
1297
- });
808
+ b.m("GET").h(headers).b(body);
809
+ return b.build();
1298
810
  };
1299
811
  export const se_GetVpcAttachmentCommand = async (input, context) => {
1300
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
812
+ const b = rb(input, context);
1301
813
  const headers = {};
1302
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/vpc-attachments/{AttachmentId}";
1303
- resolvedPath = __resolvedPath(resolvedPath, input, "AttachmentId", () => input.AttachmentId, "{AttachmentId}", false);
814
+ b.bp("/vpc-attachments/{AttachmentId}");
815
+ b.p("AttachmentId", () => input.AttachmentId, "{AttachmentId}", false);
1304
816
  let body;
1305
- return new __HttpRequest({
1306
- protocol,
1307
- hostname,
1308
- port,
1309
- method: "GET",
1310
- headers,
1311
- path: resolvedPath,
1312
- body,
1313
- });
817
+ b.m("GET").h(headers).b(body);
818
+ return b.build();
1314
819
  };
1315
820
  export const se_ListAttachmentsCommand = async (input, context) => {
1316
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
821
+ const b = rb(input, context);
1317
822
  const headers = {};
1318
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/attachments";
823
+ b.bp("/attachments");
1319
824
  const query = map({
1320
- coreNetworkId: [, input.CoreNetworkId],
1321
- attachmentType: [, input.AttachmentType],
1322
- edgeLocation: [, input.EdgeLocation],
1323
- state: [, input.State],
1324
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
1325
- nextToken: [, input.NextToken],
825
+ [_cNI]: [, input[_CNI]],
826
+ [_aT]: [, input[_AT]],
827
+ [_eL]: [, input[_EL]],
828
+ [_s]: [, input[_S]],
829
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
830
+ [_nT]: [, input[_NT]],
1326
831
  });
1327
832
  let body;
1328
- return new __HttpRequest({
1329
- protocol,
1330
- hostname,
1331
- port,
1332
- method: "GET",
1333
- headers,
1334
- path: resolvedPath,
1335
- query,
1336
- body,
1337
- });
833
+ b.m("GET").h(headers).q(query).b(body);
834
+ return b.build();
1338
835
  };
1339
836
  export const se_ListConnectPeersCommand = async (input, context) => {
1340
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
837
+ const b = rb(input, context);
1341
838
  const headers = {};
1342
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/connect-peers";
839
+ b.bp("/connect-peers");
1343
840
  const query = map({
1344
- coreNetworkId: [, input.CoreNetworkId],
1345
- connectAttachmentId: [, input.ConnectAttachmentId],
1346
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
1347
- nextToken: [, input.NextToken],
841
+ [_cNI]: [, input[_CNI]],
842
+ [_cAI]: [, input[_CAI]],
843
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
844
+ [_nT]: [, input[_NT]],
1348
845
  });
1349
846
  let body;
1350
- return new __HttpRequest({
1351
- protocol,
1352
- hostname,
1353
- port,
1354
- method: "GET",
1355
- headers,
1356
- path: resolvedPath,
1357
- query,
1358
- body,
1359
- });
847
+ b.m("GET").h(headers).q(query).b(body);
848
+ return b.build();
1360
849
  };
1361
850
  export const se_ListCoreNetworkPolicyVersionsCommand = async (input, context) => {
1362
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
851
+ const b = rb(input, context);
1363
852
  const headers = {};
1364
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1365
- "/core-networks/{CoreNetworkId}/core-network-policy-versions";
1366
- resolvedPath = __resolvedPath(resolvedPath, input, "CoreNetworkId", () => input.CoreNetworkId, "{CoreNetworkId}", false);
853
+ b.bp("/core-networks/{CoreNetworkId}/core-network-policy-versions");
854
+ b.p("CoreNetworkId", () => input.CoreNetworkId, "{CoreNetworkId}", false);
1367
855
  const query = map({
1368
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
1369
- nextToken: [, input.NextToken],
856
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
857
+ [_nT]: [, input[_NT]],
1370
858
  });
1371
859
  let body;
1372
- return new __HttpRequest({
1373
- protocol,
1374
- hostname,
1375
- port,
1376
- method: "GET",
1377
- headers,
1378
- path: resolvedPath,
1379
- query,
1380
- body,
1381
- });
860
+ b.m("GET").h(headers).q(query).b(body);
861
+ return b.build();
1382
862
  };
1383
863
  export const se_ListCoreNetworksCommand = async (input, context) => {
1384
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
864
+ const b = rb(input, context);
1385
865
  const headers = {};
1386
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/core-networks";
866
+ b.bp("/core-networks");
1387
867
  const query = map({
1388
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
1389
- nextToken: [, input.NextToken],
868
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
869
+ [_nT]: [, input[_NT]],
1390
870
  });
1391
871
  let body;
1392
- return new __HttpRequest({
1393
- protocol,
1394
- hostname,
1395
- port,
1396
- method: "GET",
1397
- headers,
1398
- path: resolvedPath,
1399
- query,
1400
- body,
1401
- });
872
+ b.m("GET").h(headers).q(query).b(body);
873
+ return b.build();
1402
874
  };
1403
875
  export const se_ListOrganizationServiceAccessStatusCommand = async (input, context) => {
1404
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
876
+ const b = rb(input, context);
1405
877
  const headers = {};
1406
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/organizations/service-access";
878
+ b.bp("/organizations/service-access");
1407
879
  const query = map({
1408
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
1409
- nextToken: [, input.NextToken],
880
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
881
+ [_nT]: [, input[_NT]],
1410
882
  });
1411
883
  let body;
1412
- return new __HttpRequest({
1413
- protocol,
1414
- hostname,
1415
- port,
1416
- method: "GET",
1417
- headers,
1418
- path: resolvedPath,
1419
- query,
1420
- body,
1421
- });
884
+ b.m("GET").h(headers).q(query).b(body);
885
+ return b.build();
1422
886
  };
1423
887
  export const se_ListPeeringsCommand = async (input, context) => {
1424
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
888
+ const b = rb(input, context);
1425
889
  const headers = {};
1426
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/peerings";
890
+ b.bp("/peerings");
1427
891
  const query = map({
1428
- coreNetworkId: [, input.CoreNetworkId],
1429
- peeringType: [, input.PeeringType],
1430
- edgeLocation: [, input.EdgeLocation],
1431
- state: [, input.State],
1432
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
1433
- nextToken: [, input.NextToken],
892
+ [_cNI]: [, input[_CNI]],
893
+ [_pT]: [, input[_PT]],
894
+ [_eL]: [, input[_EL]],
895
+ [_s]: [, input[_S]],
896
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
897
+ [_nT]: [, input[_NT]],
1434
898
  });
1435
899
  let body;
1436
- return new __HttpRequest({
1437
- protocol,
1438
- hostname,
1439
- port,
1440
- method: "GET",
1441
- headers,
1442
- path: resolvedPath,
1443
- query,
1444
- body,
1445
- });
900
+ b.m("GET").h(headers).q(query).b(body);
901
+ return b.build();
1446
902
  };
1447
903
  export const se_ListTagsForResourceCommand = async (input, context) => {
1448
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
904
+ const b = rb(input, context);
1449
905
  const headers = {};
1450
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{ResourceArn}";
1451
- resolvedPath = __resolvedPath(resolvedPath, input, "ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
906
+ b.bp("/tags/{ResourceArn}");
907
+ b.p("ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
1452
908
  let body;
1453
- return new __HttpRequest({
1454
- protocol,
1455
- hostname,
1456
- port,
1457
- method: "GET",
1458
- headers,
1459
- path: resolvedPath,
1460
- body,
1461
- });
909
+ b.m("GET").h(headers).b(body);
910
+ return b.build();
1462
911
  };
1463
912
  export const se_PutCoreNetworkPolicyCommand = async (input, context) => {
1464
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
913
+ const b = rb(input, context);
1465
914
  const headers = {
1466
915
  "content-type": "application/json",
1467
916
  };
1468
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1469
- "/core-networks/{CoreNetworkId}/core-network-policy";
1470
- resolvedPath = __resolvedPath(resolvedPath, input, "CoreNetworkId", () => input.CoreNetworkId, "{CoreNetworkId}", false);
917
+ b.bp("/core-networks/{CoreNetworkId}/core-network-policy");
918
+ b.p("CoreNetworkId", () => input.CoreNetworkId, "{CoreNetworkId}", false);
1471
919
  let body;
1472
920
  body = JSON.stringify(take(input, {
1473
921
  ClientToken: [true, (_) => _ ?? generateIdempotencyToken()],
@@ -1475,121 +923,76 @@ export const se_PutCoreNetworkPolicyCommand = async (input, context) => {
1475
923
  LatestVersionId: [],
1476
924
  PolicyDocument: (_) => __LazyJsonString.fromObject(_),
1477
925
  }));
1478
- return new __HttpRequest({
1479
- protocol,
1480
- hostname,
1481
- port,
1482
- method: "POST",
1483
- headers,
1484
- path: resolvedPath,
1485
- body,
1486
- });
926
+ b.m("POST").h(headers).b(body);
927
+ return b.build();
1487
928
  };
1488
929
  export const se_PutResourcePolicyCommand = async (input, context) => {
1489
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
930
+ const b = rb(input, context);
1490
931
  const headers = {
1491
932
  "content-type": "application/json",
1492
933
  };
1493
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/resource-policy/{ResourceArn}";
1494
- resolvedPath = __resolvedPath(resolvedPath, input, "ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
934
+ b.bp("/resource-policy/{ResourceArn}");
935
+ b.p("ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
1495
936
  let body;
1496
937
  body = JSON.stringify(take(input, {
1497
938
  PolicyDocument: (_) => __LazyJsonString.fromObject(_),
1498
939
  }));
1499
- return new __HttpRequest({
1500
- protocol,
1501
- hostname,
1502
- port,
1503
- method: "POST",
1504
- headers,
1505
- path: resolvedPath,
1506
- body,
1507
- });
940
+ b.m("POST").h(headers).b(body);
941
+ return b.build();
1508
942
  };
1509
943
  export const se_RegisterTransitGatewayCommand = async (input, context) => {
1510
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
944
+ const b = rb(input, context);
1511
945
  const headers = {
1512
946
  "content-type": "application/json",
1513
947
  };
1514
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1515
- "/global-networks/{GlobalNetworkId}/transit-gateway-registrations";
1516
- resolvedPath = __resolvedPath(resolvedPath, input, "GlobalNetworkId", () => input.GlobalNetworkId, "{GlobalNetworkId}", false);
948
+ b.bp("/global-networks/{GlobalNetworkId}/transit-gateway-registrations");
949
+ b.p("GlobalNetworkId", () => input.GlobalNetworkId, "{GlobalNetworkId}", false);
1517
950
  let body;
1518
951
  body = JSON.stringify(take(input, {
1519
952
  TransitGatewayArn: [],
1520
953
  }));
1521
- return new __HttpRequest({
1522
- protocol,
1523
- hostname,
1524
- port,
1525
- method: "POST",
1526
- headers,
1527
- path: resolvedPath,
1528
- body,
1529
- });
954
+ b.m("POST").h(headers).b(body);
955
+ return b.build();
1530
956
  };
1531
957
  export const se_RejectAttachmentCommand = async (input, context) => {
1532
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
958
+ const b = rb(input, context);
1533
959
  const headers = {};
1534
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/attachments/{AttachmentId}/reject";
1535
- resolvedPath = __resolvedPath(resolvedPath, input, "AttachmentId", () => input.AttachmentId, "{AttachmentId}", false);
960
+ b.bp("/attachments/{AttachmentId}/reject");
961
+ b.p("AttachmentId", () => input.AttachmentId, "{AttachmentId}", false);
1536
962
  let body;
1537
- return new __HttpRequest({
1538
- protocol,
1539
- hostname,
1540
- port,
1541
- method: "POST",
1542
- headers,
1543
- path: resolvedPath,
1544
- body,
1545
- });
963
+ b.m("POST").h(headers).b(body);
964
+ return b.build();
1546
965
  };
1547
966
  export const se_RestoreCoreNetworkPolicyVersionCommand = async (input, context) => {
1548
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
967
+ const b = rb(input, context);
1549
968
  const headers = {};
1550
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1551
- "/core-networks/{CoreNetworkId}/core-network-policy-versions/{PolicyVersionId}/restore";
1552
- resolvedPath = __resolvedPath(resolvedPath, input, "CoreNetworkId", () => input.CoreNetworkId, "{CoreNetworkId}", false);
1553
- resolvedPath = __resolvedPath(resolvedPath, input, "PolicyVersionId", () => input.PolicyVersionId.toString(), "{PolicyVersionId}", false);
969
+ b.bp("/core-networks/{CoreNetworkId}/core-network-policy-versions/{PolicyVersionId}/restore");
970
+ b.p("CoreNetworkId", () => input.CoreNetworkId, "{CoreNetworkId}", false);
971
+ b.p("PolicyVersionId", () => input.PolicyVersionId.toString(), "{PolicyVersionId}", false);
1554
972
  let body;
1555
- return new __HttpRequest({
1556
- protocol,
1557
- hostname,
1558
- port,
1559
- method: "POST",
1560
- headers,
1561
- path: resolvedPath,
1562
- body,
1563
- });
973
+ b.m("POST").h(headers).b(body);
974
+ return b.build();
1564
975
  };
1565
976
  export const se_StartOrganizationServiceAccessUpdateCommand = async (input, context) => {
1566
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
977
+ const b = rb(input, context);
1567
978
  const headers = {
1568
979
  "content-type": "application/json",
1569
980
  };
1570
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/organizations/service-access";
981
+ b.bp("/organizations/service-access");
1571
982
  let body;
1572
983
  body = JSON.stringify(take(input, {
1573
984
  Action: [],
1574
985
  }));
1575
- return new __HttpRequest({
1576
- protocol,
1577
- hostname,
1578
- port,
1579
- method: "POST",
1580
- headers,
1581
- path: resolvedPath,
1582
- body,
1583
- });
986
+ b.m("POST").h(headers).b(body);
987
+ return b.build();
1584
988
  };
1585
989
  export const se_StartRouteAnalysisCommand = async (input, context) => {
1586
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
990
+ const b = rb(input, context);
1587
991
  const headers = {
1588
992
  "content-type": "application/json",
1589
993
  };
1590
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1591
- "/global-networks/{GlobalNetworkId}/route-analyses";
1592
- resolvedPath = __resolvedPath(resolvedPath, input, "GlobalNetworkId", () => input.GlobalNetworkId, "{GlobalNetworkId}", false);
994
+ b.bp("/global-networks/{GlobalNetworkId}/route-analyses");
995
+ b.p("GlobalNetworkId", () => input.GlobalNetworkId, "{GlobalNetworkId}", false);
1593
996
  let body;
1594
997
  body = JSON.stringify(take(input, {
1595
998
  Destination: (_) => _json(_),
@@ -1597,115 +1000,77 @@ export const se_StartRouteAnalysisCommand = async (input, context) => {
1597
1000
  Source: (_) => _json(_),
1598
1001
  UseMiddleboxes: [],
1599
1002
  }));
1600
- return new __HttpRequest({
1601
- protocol,
1602
- hostname,
1603
- port,
1604
- method: "POST",
1605
- headers,
1606
- path: resolvedPath,
1607
- body,
1608
- });
1003
+ b.m("POST").h(headers).b(body);
1004
+ return b.build();
1609
1005
  };
1610
1006
  export const se_TagResourceCommand = async (input, context) => {
1611
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1007
+ const b = rb(input, context);
1612
1008
  const headers = {
1613
1009
  "content-type": "application/json",
1614
1010
  };
1615
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{ResourceArn}";
1616
- resolvedPath = __resolvedPath(resolvedPath, input, "ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
1011
+ b.bp("/tags/{ResourceArn}");
1012
+ b.p("ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
1617
1013
  let body;
1618
1014
  body = JSON.stringify(take(input, {
1619
1015
  Tags: (_) => _json(_),
1620
1016
  }));
1621
- return new __HttpRequest({
1622
- protocol,
1623
- hostname,
1624
- port,
1625
- method: "POST",
1626
- headers,
1627
- path: resolvedPath,
1628
- body,
1629
- });
1017
+ b.m("POST").h(headers).b(body);
1018
+ return b.build();
1630
1019
  };
1631
1020
  export const se_UntagResourceCommand = async (input, context) => {
1632
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1021
+ const b = rb(input, context);
1633
1022
  const headers = {};
1634
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{ResourceArn}";
1635
- resolvedPath = __resolvedPath(resolvedPath, input, "ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
1023
+ b.bp("/tags/{ResourceArn}");
1024
+ b.p("ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
1636
1025
  const query = map({
1637
- tagKeys: [
1026
+ [_tK]: [
1638
1027
  __expectNonNull(input.TagKeys, `TagKeys`) != null,
1639
- () => (input.TagKeys || []).map((_entry) => _entry),
1028
+ () => (input[_TK] || []).map((_entry) => _entry),
1640
1029
  ],
1641
1030
  });
1642
1031
  let body;
1643
- return new __HttpRequest({
1644
- protocol,
1645
- hostname,
1646
- port,
1647
- method: "DELETE",
1648
- headers,
1649
- path: resolvedPath,
1650
- query,
1651
- body,
1652
- });
1032
+ b.m("DELETE").h(headers).q(query).b(body);
1033
+ return b.build();
1653
1034
  };
1654
1035
  export const se_UpdateConnectionCommand = async (input, context) => {
1655
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1036
+ const b = rb(input, context);
1656
1037
  const headers = {
1657
1038
  "content-type": "application/json",
1658
1039
  };
1659
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1660
- "/global-networks/{GlobalNetworkId}/connections/{ConnectionId}";
1661
- resolvedPath = __resolvedPath(resolvedPath, input, "GlobalNetworkId", () => input.GlobalNetworkId, "{GlobalNetworkId}", false);
1662
- resolvedPath = __resolvedPath(resolvedPath, input, "ConnectionId", () => input.ConnectionId, "{ConnectionId}", false);
1040
+ b.bp("/global-networks/{GlobalNetworkId}/connections/{ConnectionId}");
1041
+ b.p("GlobalNetworkId", () => input.GlobalNetworkId, "{GlobalNetworkId}", false);
1042
+ b.p("ConnectionId", () => input.ConnectionId, "{ConnectionId}", false);
1663
1043
  let body;
1664
1044
  body = JSON.stringify(take(input, {
1665
1045
  ConnectedLinkId: [],
1666
1046
  Description: [],
1667
1047
  LinkId: [],
1668
1048
  }));
1669
- return new __HttpRequest({
1670
- protocol,
1671
- hostname,
1672
- port,
1673
- method: "PATCH",
1674
- headers,
1675
- path: resolvedPath,
1676
- body,
1677
- });
1049
+ b.m("PATCH").h(headers).b(body);
1050
+ return b.build();
1678
1051
  };
1679
1052
  export const se_UpdateCoreNetworkCommand = async (input, context) => {
1680
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1053
+ const b = rb(input, context);
1681
1054
  const headers = {
1682
1055
  "content-type": "application/json",
1683
1056
  };
1684
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/core-networks/{CoreNetworkId}";
1685
- resolvedPath = __resolvedPath(resolvedPath, input, "CoreNetworkId", () => input.CoreNetworkId, "{CoreNetworkId}", false);
1057
+ b.bp("/core-networks/{CoreNetworkId}");
1058
+ b.p("CoreNetworkId", () => input.CoreNetworkId, "{CoreNetworkId}", false);
1686
1059
  let body;
1687
1060
  body = JSON.stringify(take(input, {
1688
1061
  Description: [],
1689
1062
  }));
1690
- return new __HttpRequest({
1691
- protocol,
1692
- hostname,
1693
- port,
1694
- method: "PATCH",
1695
- headers,
1696
- path: resolvedPath,
1697
- body,
1698
- });
1063
+ b.m("PATCH").h(headers).b(body);
1064
+ return b.build();
1699
1065
  };
1700
1066
  export const se_UpdateDeviceCommand = async (input, context) => {
1701
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1067
+ const b = rb(input, context);
1702
1068
  const headers = {
1703
1069
  "content-type": "application/json",
1704
1070
  };
1705
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1706
- "/global-networks/{GlobalNetworkId}/devices/{DeviceId}";
1707
- resolvedPath = __resolvedPath(resolvedPath, input, "GlobalNetworkId", () => input.GlobalNetworkId, "{GlobalNetworkId}", false);
1708
- resolvedPath = __resolvedPath(resolvedPath, input, "DeviceId", () => input.DeviceId, "{DeviceId}", false);
1071
+ b.bp("/global-networks/{GlobalNetworkId}/devices/{DeviceId}");
1072
+ b.p("GlobalNetworkId", () => input.GlobalNetworkId, "{GlobalNetworkId}", false);
1073
+ b.p("DeviceId", () => input.DeviceId, "{DeviceId}", false);
1709
1074
  let body;
1710
1075
  body = JSON.stringify(take(input, {
1711
1076
  AWSLocation: (_) => _json(_),
@@ -1717,46 +1082,31 @@ export const se_UpdateDeviceCommand = async (input, context) => {
1717
1082
  Type: [],
1718
1083
  Vendor: [],
1719
1084
  }));
1720
- return new __HttpRequest({
1721
- protocol,
1722
- hostname,
1723
- port,
1724
- method: "PATCH",
1725
- headers,
1726
- path: resolvedPath,
1727
- body,
1728
- });
1085
+ b.m("PATCH").h(headers).b(body);
1086
+ return b.build();
1729
1087
  };
1730
1088
  export const se_UpdateGlobalNetworkCommand = async (input, context) => {
1731
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1089
+ const b = rb(input, context);
1732
1090
  const headers = {
1733
1091
  "content-type": "application/json",
1734
1092
  };
1735
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/global-networks/{GlobalNetworkId}";
1736
- resolvedPath = __resolvedPath(resolvedPath, input, "GlobalNetworkId", () => input.GlobalNetworkId, "{GlobalNetworkId}", false);
1093
+ b.bp("/global-networks/{GlobalNetworkId}");
1094
+ b.p("GlobalNetworkId", () => input.GlobalNetworkId, "{GlobalNetworkId}", false);
1737
1095
  let body;
1738
1096
  body = JSON.stringify(take(input, {
1739
1097
  Description: [],
1740
1098
  }));
1741
- return new __HttpRequest({
1742
- protocol,
1743
- hostname,
1744
- port,
1745
- method: "PATCH",
1746
- headers,
1747
- path: resolvedPath,
1748
- body,
1749
- });
1099
+ b.m("PATCH").h(headers).b(body);
1100
+ return b.build();
1750
1101
  };
1751
1102
  export const se_UpdateLinkCommand = async (input, context) => {
1752
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1103
+ const b = rb(input, context);
1753
1104
  const headers = {
1754
1105
  "content-type": "application/json",
1755
1106
  };
1756
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1757
- "/global-networks/{GlobalNetworkId}/links/{LinkId}";
1758
- resolvedPath = __resolvedPath(resolvedPath, input, "GlobalNetworkId", () => input.GlobalNetworkId, "{GlobalNetworkId}", false);
1759
- resolvedPath = __resolvedPath(resolvedPath, input, "LinkId", () => input.LinkId, "{LinkId}", false);
1107
+ b.bp("/global-networks/{GlobalNetworkId}/links/{LinkId}");
1108
+ b.p("GlobalNetworkId", () => input.GlobalNetworkId, "{GlobalNetworkId}", false);
1109
+ b.p("LinkId", () => input.LinkId, "{LinkId}", false);
1760
1110
  let body;
1761
1111
  body = JSON.stringify(take(input, {
1762
1112
  Bandwidth: (_) => _json(_),
@@ -1764,85 +1114,55 @@ export const se_UpdateLinkCommand = async (input, context) => {
1764
1114
  Provider: [],
1765
1115
  Type: [],
1766
1116
  }));
1767
- return new __HttpRequest({
1768
- protocol,
1769
- hostname,
1770
- port,
1771
- method: "PATCH",
1772
- headers,
1773
- path: resolvedPath,
1774
- body,
1775
- });
1117
+ b.m("PATCH").h(headers).b(body);
1118
+ return b.build();
1776
1119
  };
1777
1120
  export const se_UpdateNetworkResourceMetadataCommand = async (input, context) => {
1778
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1121
+ const b = rb(input, context);
1779
1122
  const headers = {
1780
1123
  "content-type": "application/json",
1781
1124
  };
1782
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1783
- "/global-networks/{GlobalNetworkId}/network-resources/{ResourceArn}/metadata";
1784
- resolvedPath = __resolvedPath(resolvedPath, input, "GlobalNetworkId", () => input.GlobalNetworkId, "{GlobalNetworkId}", false);
1785
- resolvedPath = __resolvedPath(resolvedPath, input, "ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
1125
+ b.bp("/global-networks/{GlobalNetworkId}/network-resources/{ResourceArn}/metadata");
1126
+ b.p("GlobalNetworkId", () => input.GlobalNetworkId, "{GlobalNetworkId}", false);
1127
+ b.p("ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
1786
1128
  let body;
1787
1129
  body = JSON.stringify(take(input, {
1788
1130
  Metadata: (_) => _json(_),
1789
1131
  }));
1790
- return new __HttpRequest({
1791
- protocol,
1792
- hostname,
1793
- port,
1794
- method: "PATCH",
1795
- headers,
1796
- path: resolvedPath,
1797
- body,
1798
- });
1132
+ b.m("PATCH").h(headers).b(body);
1133
+ return b.build();
1799
1134
  };
1800
1135
  export const se_UpdateSiteCommand = async (input, context) => {
1801
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1136
+ const b = rb(input, context);
1802
1137
  const headers = {
1803
1138
  "content-type": "application/json",
1804
1139
  };
1805
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1806
- "/global-networks/{GlobalNetworkId}/sites/{SiteId}";
1807
- resolvedPath = __resolvedPath(resolvedPath, input, "GlobalNetworkId", () => input.GlobalNetworkId, "{GlobalNetworkId}", false);
1808
- resolvedPath = __resolvedPath(resolvedPath, input, "SiteId", () => input.SiteId, "{SiteId}", false);
1140
+ b.bp("/global-networks/{GlobalNetworkId}/sites/{SiteId}");
1141
+ b.p("GlobalNetworkId", () => input.GlobalNetworkId, "{GlobalNetworkId}", false);
1142
+ b.p("SiteId", () => input.SiteId, "{SiteId}", false);
1809
1143
  let body;
1810
1144
  body = JSON.stringify(take(input, {
1811
1145
  Description: [],
1812
1146
  Location: (_) => _json(_),
1813
1147
  }));
1814
- return new __HttpRequest({
1815
- protocol,
1816
- hostname,
1817
- port,
1818
- method: "PATCH",
1819
- headers,
1820
- path: resolvedPath,
1821
- body,
1822
- });
1148
+ b.m("PATCH").h(headers).b(body);
1149
+ return b.build();
1823
1150
  };
1824
1151
  export const se_UpdateVpcAttachmentCommand = async (input, context) => {
1825
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1152
+ const b = rb(input, context);
1826
1153
  const headers = {
1827
1154
  "content-type": "application/json",
1828
1155
  };
1829
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/vpc-attachments/{AttachmentId}";
1830
- resolvedPath = __resolvedPath(resolvedPath, input, "AttachmentId", () => input.AttachmentId, "{AttachmentId}", false);
1156
+ b.bp("/vpc-attachments/{AttachmentId}");
1157
+ b.p("AttachmentId", () => input.AttachmentId, "{AttachmentId}", false);
1831
1158
  let body;
1832
1159
  body = JSON.stringify(take(input, {
1833
1160
  AddSubnetArns: (_) => _json(_),
1834
1161
  Options: (_) => _json(_),
1835
1162
  RemoveSubnetArns: (_) => _json(_),
1836
1163
  }));
1837
- return new __HttpRequest({
1838
- protocol,
1839
- hostname,
1840
- port,
1841
- method: "PATCH",
1842
- headers,
1843
- path: resolvedPath,
1844
- body,
1845
- });
1164
+ b.m("PATCH").h(headers).b(body);
1165
+ return b.build();
1846
1166
  };
1847
1167
  export const de_AcceptAttachmentCommand = async (output, context) => {
1848
1168
  if (output.statusCode !== 200 && output.statusCode >= 300) {
@@ -5877,10 +5197,7 @@ const de_CoreNetworkPolicyExceptionRes = async (parsedOutput, context) => {
5877
5197
  };
5878
5198
  const de_InternalServerExceptionRes = async (parsedOutput, context) => {
5879
5199
  const contents = map({
5880
- RetryAfterSeconds: [
5881
- () => void 0 !== parsedOutput.headers["retry-after"],
5882
- () => __strictParseInt32(parsedOutput.headers["retry-after"]),
5883
- ],
5200
+ [_RAS]: [() => void 0 !== parsedOutput.headers[_ra], () => __strictParseInt32(parsedOutput.headers[_ra])],
5884
5201
  });
5885
5202
  const data = parsedOutput.body;
5886
5203
  const doc = take(data, {
@@ -5928,10 +5245,7 @@ const de_ServiceQuotaExceededExceptionRes = async (parsedOutput, context) => {
5928
5245
  };
5929
5246
  const de_ThrottlingExceptionRes = async (parsedOutput, context) => {
5930
5247
  const contents = map({
5931
- RetryAfterSeconds: [
5932
- () => void 0 !== parsedOutput.headers["retry-after"],
5933
- () => __strictParseInt32(parsedOutput.headers["retry-after"]),
5934
- ],
5248
+ [_RAS]: [() => void 0 !== parsedOutput.headers[_ra], () => __strictParseInt32(parsedOutput.headers[_ra])],
5935
5249
  });
5936
5250
  const data = parsedOutput.body;
5937
5251
  const doc = take(data, {
@@ -6323,6 +5637,68 @@ const isSerializableHeaderValue = (value) => value !== undefined &&
6323
5637
  value !== "" &&
6324
5638
  (!Object.getOwnPropertyNames(value).includes("length") || value.length != 0) &&
6325
5639
  (!Object.getOwnPropertyNames(value).includes("size") || value.size != 0);
5640
+ const _A = "Alias";
5641
+ const _AI = "AccountId";
5642
+ const _AR = "AwsRegion";
5643
+ const _AT = "AttachmentType";
5644
+ const _CAI = "ConnectAttachmentId";
5645
+ const _CGA = "CustomerGatewayArns";
5646
+ const _CI = "ConnectionIds";
5647
+ const _CNI = "CoreNetworkId";
5648
+ const _CPI = "ConnectPeerIds";
5649
+ const _DI = "DeviceId";
5650
+ const _DIe = "DeviceIds";
5651
+ const _EL = "EdgeLocation";
5652
+ const _GNI = "GlobalNetworkIds";
5653
+ const _LI = "LinkId";
5654
+ const _LIi = "LinkIds";
5655
+ const _MR = "MaxResults";
5656
+ const _NT = "NextToken";
5657
+ const _P = "Provider";
5658
+ const _PT = "PeeringType";
5659
+ const _PVI = "PolicyVersionId";
5660
+ const _RA = "ResourceArn";
5661
+ const _RAS = "RetryAfterSeconds";
5662
+ const _RGA = "RegisteredGatewayArn";
5663
+ const _RT = "ResourceType";
5664
+ const _S = "State";
5665
+ const _SI = "SiteId";
5666
+ const _SIi = "SiteIds";
5667
+ const _T = "Type";
5668
+ const _TGA = "TransitGatewayArns";
5669
+ const _TGCPA = "TransitGatewayConnectPeerArns";
5670
+ const _TK = "TagKeys";
5671
+ const _a = "alias";
5672
+ const _aI = "accountId";
5673
+ const _aR = "awsRegion";
5674
+ const _aT = "attachmentType";
5675
+ const _cAI = "connectAttachmentId";
5676
+ const _cGA = "customerGatewayArns";
5677
+ const _cI = "connectionIds";
5678
+ const _cNI = "coreNetworkId";
5679
+ const _cPI = "connectPeerIds";
5680
+ const _dI = "deviceId";
5681
+ const _dIe = "deviceIds";
5682
+ const _eL = "edgeLocation";
5683
+ const _gNI = "globalNetworkIds";
5684
+ const _lI = "linkId";
5685
+ const _lIi = "linkIds";
5686
+ const _mR = "maxResults";
5687
+ const _nT = "nextToken";
5688
+ const _p = "provider";
5689
+ const _pT = "peeringType";
5690
+ const _pVI = "policyVersionId";
5691
+ const _rA = "resourceArn";
5692
+ const _rGA = "registeredGatewayArn";
5693
+ const _rT = "resourceType";
5694
+ const _ra = "retry-after";
5695
+ const _s = "state";
5696
+ const _sI = "siteId";
5697
+ const _sIi = "siteIds";
5698
+ const _t = "type";
5699
+ const _tGA = "transitGatewayArns";
5700
+ const _tGCPA = "transitGatewayConnectPeerArns";
5701
+ const _tK = "tagKeys";
6326
5702
  const parseBody = (streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
6327
5703
  if (encoded.length) {
6328
5704
  return JSON.parse(encoded);