@aws-sdk/client-app-mesh 3.476.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 +268 -593
  2. package/dist-es/protocols/Aws_restJson1.js +269 -594
  3. package/package.json +5 -4
package/dist-es/protocols/Aws_restJson1.js CHANGED
@@ -1,19 +1,18 @@
1
- import { HttpRequest as __HttpRequest } from "@smithy/protocol-http";
2
- import { _json, collectBody, decorateServiceException as __decorateServiceException, expectLong as __expectLong, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectObject as __expectObject, expectString as __expectString, map, parseEpochTimestamp as __parseEpochTimestamp, resolvedPath as __resolvedPath, take, withBaseException, } from "@smithy/smithy-client";
1
+ import { requestBuilder as rb } from "@smithy/core";
2
+ import { _json, collectBody, decorateServiceException as __decorateServiceException, expectLong as __expectLong, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectObject as __expectObject, expectString as __expectString, map, parseEpochTimestamp as __parseEpochTimestamp, take, withBaseException, } from "@smithy/smithy-client";
3
3
  import { v4 as generateIdempotencyToken } from "uuid";
4
4
  import { AppMeshServiceException as __BaseException } from "../models/AppMeshServiceException";
5
5
  import { BadRequestException, ConflictException, ForbiddenException, InternalServerErrorException, LimitExceededException, NotFoundException, ResourceInUseException, ServiceUnavailableException, TooManyRequestsException, TooManyTagsException, } from "../models/models_0";
6
6
  export const se_CreateGatewayRouteCommand = 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
9
  "content-type": "application/json",
10
10
  };
11
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
12
- "/v20190125/meshes/{meshName}/virtualGateway/{virtualGatewayName}/gatewayRoutes";
13
- resolvedPath = __resolvedPath(resolvedPath, input, "meshName", () => input.meshName, "{meshName}", false);
14
- resolvedPath = __resolvedPath(resolvedPath, input, "virtualGatewayName", () => input.virtualGatewayName, "{virtualGatewayName}", false);
11
+ b.bp("/v20190125/meshes/{meshName}/virtualGateway/{virtualGatewayName}/gatewayRoutes");
12
+ b.p("meshName", () => input.meshName, "{meshName}", false);
13
+ b.p("virtualGatewayName", () => input.virtualGatewayName, "{virtualGatewayName}", false);
15
14
  const query = map({
16
- meshOwner: [, input.meshOwner],
15
+ [_mO]: [, input[_mO]],
17
16
  });
18
17
  let body;
19
18
  body = JSON.stringify(take(input, {
@@ -22,23 +21,15 @@ export const se_CreateGatewayRouteCommand = async (input, context) => {
22
21
  spec: (_) => _json(_),
23
22
  tags: (_) => _json(_),
24
23
  }));
25
- return new __HttpRequest({
26
- protocol,
27
- hostname,
28
- port,
29
- method: "PUT",
30
- headers,
31
- path: resolvedPath,
32
- query,
33
- body,
34
- });
24
+ b.m("PUT").h(headers).q(query).b(body);
25
+ return b.build();
35
26
  };
36
27
  export const se_CreateMeshCommand = async (input, context) => {
37
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
28
+ const b = rb(input, context);
38
29
  const headers = {
39
30
  "content-type": "application/json",
40
31
  };
41
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v20190125/meshes";
32
+ b.bp("/v20190125/meshes");
42
33
  let body;
43
34
  body = JSON.stringify(take(input, {
44
35
  clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
@@ -46,27 +37,19 @@ export const se_CreateMeshCommand = async (input, context) => {
46
37
  spec: (_) => _json(_),
47
38
  tags: (_) => _json(_),
48
39
  }));
49
- return new __HttpRequest({
50
- protocol,
51
- hostname,
52
- port,
53
- method: "PUT",
54
- headers,
55
- path: resolvedPath,
56
- body,
57
- });
40
+ b.m("PUT").h(headers).b(body);
41
+ return b.build();
58
42
  };
59
43
  export const se_CreateRouteCommand = async (input, context) => {
60
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
44
+ const b = rb(input, context);
61
45
  const headers = {
62
46
  "content-type": "application/json",
63
47
  };
64
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
65
- "/v20190125/meshes/{meshName}/virtualRouter/{virtualRouterName}/routes";
66
- resolvedPath = __resolvedPath(resolvedPath, input, "meshName", () => input.meshName, "{meshName}", false);
67
- resolvedPath = __resolvedPath(resolvedPath, input, "virtualRouterName", () => input.virtualRouterName, "{virtualRouterName}", false);
48
+ b.bp("/v20190125/meshes/{meshName}/virtualRouter/{virtualRouterName}/routes");
49
+ b.p("meshName", () => input.meshName, "{meshName}", false);
50
+ b.p("virtualRouterName", () => input.virtualRouterName, "{virtualRouterName}", false);
68
51
  const query = map({
69
- meshOwner: [, input.meshOwner],
52
+ [_mO]: [, input[_mO]],
70
53
  });
71
54
  let body;
72
55
  body = JSON.stringify(take(input, {
@@ -75,27 +58,18 @@ export const se_CreateRouteCommand = async (input, context) => {
75
58
  spec: (_) => _json(_),
76
59
  tags: (_) => _json(_),
77
60
  }));
78
- return new __HttpRequest({
79
- protocol,
80
- hostname,
81
- port,
82
- method: "PUT",
83
- headers,
84
- path: resolvedPath,
85
- query,
86
- body,
87
- });
61
+ b.m("PUT").h(headers).q(query).b(body);
62
+ return b.build();
88
63
  };
89
64
  export const se_CreateVirtualGatewayCommand = async (input, context) => {
90
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
65
+ const b = rb(input, context);
91
66
  const headers = {
92
67
  "content-type": "application/json",
93
68
  };
94
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
95
- "/v20190125/meshes/{meshName}/virtualGateways";
96
- resolvedPath = __resolvedPath(resolvedPath, input, "meshName", () => input.meshName, "{meshName}", false);
69
+ b.bp("/v20190125/meshes/{meshName}/virtualGateways");
70
+ b.p("meshName", () => input.meshName, "{meshName}", false);
97
71
  const query = map({
98
- meshOwner: [, input.meshOwner],
72
+ [_mO]: [, input[_mO]],
99
73
  });
100
74
  let body;
101
75
  body = JSON.stringify(take(input, {
@@ -104,26 +78,18 @@ export const se_CreateVirtualGatewayCommand = async (input, context) => {
104
78
  tags: (_) => _json(_),
105
79
  virtualGatewayName: [],
106
80
  }));
107
- return new __HttpRequest({
108
- protocol,
109
- hostname,
110
- port,
111
- method: "PUT",
112
- headers,
113
- path: resolvedPath,
114
- query,
115
- body,
116
- });
81
+ b.m("PUT").h(headers).q(query).b(body);
82
+ return b.build();
117
83
  };
118
84
  export const se_CreateVirtualNodeCommand = async (input, context) => {
119
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
85
+ const b = rb(input, context);
120
86
  const headers = {
121
87
  "content-type": "application/json",
122
88
  };
123
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v20190125/meshes/{meshName}/virtualNodes";
124
- resolvedPath = __resolvedPath(resolvedPath, input, "meshName", () => input.meshName, "{meshName}", false);
89
+ b.bp("/v20190125/meshes/{meshName}/virtualNodes");
90
+ b.p("meshName", () => input.meshName, "{meshName}", false);
125
91
  const query = map({
126
- meshOwner: [, input.meshOwner],
92
+ [_mO]: [, input[_mO]],
127
93
  });
128
94
  let body;
129
95
  body = JSON.stringify(take(input, {
@@ -132,27 +98,18 @@ export const se_CreateVirtualNodeCommand = async (input, context) => {
132
98
  tags: (_) => _json(_),
133
99
  virtualNodeName: [],
134
100
  }));
135
- return new __HttpRequest({
136
- protocol,
137
- hostname,
138
- port,
139
- method: "PUT",
140
- headers,
141
- path: resolvedPath,
142
- query,
143
- body,
144
- });
101
+ b.m("PUT").h(headers).q(query).b(body);
102
+ return b.build();
145
103
  };
146
104
  export const se_CreateVirtualRouterCommand = async (input, context) => {
147
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
105
+ const b = rb(input, context);
148
106
  const headers = {
149
107
  "content-type": "application/json",
150
108
  };
151
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
152
- "/v20190125/meshes/{meshName}/virtualRouters";
153
- resolvedPath = __resolvedPath(resolvedPath, input, "meshName", () => input.meshName, "{meshName}", false);
109
+ b.bp("/v20190125/meshes/{meshName}/virtualRouters");
110
+ b.p("meshName", () => input.meshName, "{meshName}", false);
154
111
  const query = map({
155
- meshOwner: [, input.meshOwner],
112
+ [_mO]: [, input[_mO]],
156
113
  });
157
114
  let body;
158
115
  body = JSON.stringify(take(input, {
@@ -161,27 +118,18 @@ export const se_CreateVirtualRouterCommand = async (input, context) => {
161
118
  tags: (_) => _json(_),
162
119
  virtualRouterName: [],
163
120
  }));
164
- return new __HttpRequest({
165
- protocol,
166
- hostname,
167
- port,
168
- method: "PUT",
169
- headers,
170
- path: resolvedPath,
171
- query,
172
- body,
173
- });
121
+ b.m("PUT").h(headers).q(query).b(body);
122
+ return b.build();
174
123
  };
175
124
  export const se_CreateVirtualServiceCommand = async (input, context) => {
176
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
125
+ const b = rb(input, context);
177
126
  const headers = {
178
127
  "content-type": "application/json",
179
128
  };
180
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
181
- "/v20190125/meshes/{meshName}/virtualServices";
182
- resolvedPath = __resolvedPath(resolvedPath, input, "meshName", () => input.meshName, "{meshName}", false);
129
+ b.bp("/v20190125/meshes/{meshName}/virtualServices");
130
+ b.p("meshName", () => input.meshName, "{meshName}", false);
183
131
  const query = map({
184
- meshOwner: [, input.meshOwner],
132
+ [_mO]: [, input[_mO]],
185
133
  });
186
134
  let body;
187
135
  body = JSON.stringify(take(input, {
@@ -190,740 +138,463 @@ export const se_CreateVirtualServiceCommand = async (input, context) => {
190
138
  tags: (_) => _json(_),
191
139
  virtualServiceName: [],
192
140
  }));
193
- return new __HttpRequest({
194
- protocol,
195
- hostname,
196
- port,
197
- method: "PUT",
198
- headers,
199
- path: resolvedPath,
200
- query,
201
- body,
202
- });
141
+ b.m("PUT").h(headers).q(query).b(body);
142
+ return b.build();
203
143
  };
204
144
  export const se_DeleteGatewayRouteCommand = async (input, context) => {
205
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
145
+ const b = rb(input, context);
206
146
  const headers = {};
207
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
208
- "/v20190125/meshes/{meshName}/virtualGateway/{virtualGatewayName}/gatewayRoutes/{gatewayRouteName}";
209
- resolvedPath = __resolvedPath(resolvedPath, input, "gatewayRouteName", () => input.gatewayRouteName, "{gatewayRouteName}", false);
210
- resolvedPath = __resolvedPath(resolvedPath, input, "meshName", () => input.meshName, "{meshName}", false);
211
- resolvedPath = __resolvedPath(resolvedPath, input, "virtualGatewayName", () => input.virtualGatewayName, "{virtualGatewayName}", false);
147
+ b.bp("/v20190125/meshes/{meshName}/virtualGateway/{virtualGatewayName}/gatewayRoutes/{gatewayRouteName}");
148
+ b.p("gatewayRouteName", () => input.gatewayRouteName, "{gatewayRouteName}", false);
149
+ b.p("meshName", () => input.meshName, "{meshName}", false);
150
+ b.p("virtualGatewayName", () => input.virtualGatewayName, "{virtualGatewayName}", false);
212
151
  const query = map({
213
- meshOwner: [, input.meshOwner],
152
+ [_mO]: [, input[_mO]],
214
153
  });
215
154
  let body;
216
- return new __HttpRequest({
217
- protocol,
218
- hostname,
219
- port,
220
- method: "DELETE",
221
- headers,
222
- path: resolvedPath,
223
- query,
224
- body,
225
- });
155
+ b.m("DELETE").h(headers).q(query).b(body);
156
+ return b.build();
226
157
  };
227
158
  export const se_DeleteMeshCommand = async (input, context) => {
228
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
159
+ const b = rb(input, context);
229
160
  const headers = {};
230
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v20190125/meshes/{meshName}";
231
- resolvedPath = __resolvedPath(resolvedPath, input, "meshName", () => input.meshName, "{meshName}", false);
161
+ b.bp("/v20190125/meshes/{meshName}");
162
+ b.p("meshName", () => input.meshName, "{meshName}", false);
232
163
  let body;
233
- return new __HttpRequest({
234
- protocol,
235
- hostname,
236
- port,
237
- method: "DELETE",
238
- headers,
239
- path: resolvedPath,
240
- body,
241
- });
164
+ b.m("DELETE").h(headers).b(body);
165
+ return b.build();
242
166
  };
243
167
  export const se_DeleteRouteCommand = async (input, context) => {
244
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
168
+ const b = rb(input, context);
245
169
  const headers = {};
246
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
247
- "/v20190125/meshes/{meshName}/virtualRouter/{virtualRouterName}/routes/{routeName}";
248
- resolvedPath = __resolvedPath(resolvedPath, input, "routeName", () => input.routeName, "{routeName}", false);
249
- resolvedPath = __resolvedPath(resolvedPath, input, "meshName", () => input.meshName, "{meshName}", false);
250
- resolvedPath = __resolvedPath(resolvedPath, input, "virtualRouterName", () => input.virtualRouterName, "{virtualRouterName}", false);
170
+ b.bp("/v20190125/meshes/{meshName}/virtualRouter/{virtualRouterName}/routes/{routeName}");
171
+ b.p("routeName", () => input.routeName, "{routeName}", false);
172
+ b.p("meshName", () => input.meshName, "{meshName}", false);
173
+ b.p("virtualRouterName", () => input.virtualRouterName, "{virtualRouterName}", false);
251
174
  const query = map({
252
- meshOwner: [, input.meshOwner],
175
+ [_mO]: [, input[_mO]],
253
176
  });
254
177
  let body;
255
- return new __HttpRequest({
256
- protocol,
257
- hostname,
258
- port,
259
- method: "DELETE",
260
- headers,
261
- path: resolvedPath,
262
- query,
263
- body,
264
- });
178
+ b.m("DELETE").h(headers).q(query).b(body);
179
+ return b.build();
265
180
  };
266
181
  export const se_DeleteVirtualGatewayCommand = async (input, context) => {
267
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
182
+ const b = rb(input, context);
268
183
  const headers = {};
269
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
270
- "/v20190125/meshes/{meshName}/virtualGateways/{virtualGatewayName}";
271
- resolvedPath = __resolvedPath(resolvedPath, input, "virtualGatewayName", () => input.virtualGatewayName, "{virtualGatewayName}", false);
272
- resolvedPath = __resolvedPath(resolvedPath, input, "meshName", () => input.meshName, "{meshName}", false);
184
+ b.bp("/v20190125/meshes/{meshName}/virtualGateways/{virtualGatewayName}");
185
+ b.p("virtualGatewayName", () => input.virtualGatewayName, "{virtualGatewayName}", false);
186
+ b.p("meshName", () => input.meshName, "{meshName}", false);
273
187
  const query = map({
274
- meshOwner: [, input.meshOwner],
188
+ [_mO]: [, input[_mO]],
275
189
  });
276
190
  let body;
277
- return new __HttpRequest({
278
- protocol,
279
- hostname,
280
- port,
281
- method: "DELETE",
282
- headers,
283
- path: resolvedPath,
284
- query,
285
- body,
286
- });
191
+ b.m("DELETE").h(headers).q(query).b(body);
192
+ return b.build();
287
193
  };
288
194
  export const se_DeleteVirtualNodeCommand = async (input, context) => {
289
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
195
+ const b = rb(input, context);
290
196
  const headers = {};
291
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
292
- "/v20190125/meshes/{meshName}/virtualNodes/{virtualNodeName}";
293
- resolvedPath = __resolvedPath(resolvedPath, input, "virtualNodeName", () => input.virtualNodeName, "{virtualNodeName}", false);
294
- resolvedPath = __resolvedPath(resolvedPath, input, "meshName", () => input.meshName, "{meshName}", false);
197
+ b.bp("/v20190125/meshes/{meshName}/virtualNodes/{virtualNodeName}");
198
+ b.p("virtualNodeName", () => input.virtualNodeName, "{virtualNodeName}", false);
199
+ b.p("meshName", () => input.meshName, "{meshName}", false);
295
200
  const query = map({
296
- meshOwner: [, input.meshOwner],
201
+ [_mO]: [, input[_mO]],
297
202
  });
298
203
  let body;
299
- return new __HttpRequest({
300
- protocol,
301
- hostname,
302
- port,
303
- method: "DELETE",
304
- headers,
305
- path: resolvedPath,
306
- query,
307
- body,
308
- });
204
+ b.m("DELETE").h(headers).q(query).b(body);
205
+ return b.build();
309
206
  };
310
207
  export const se_DeleteVirtualRouterCommand = async (input, context) => {
311
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
208
+ const b = rb(input, context);
312
209
  const headers = {};
313
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
314
- "/v20190125/meshes/{meshName}/virtualRouters/{virtualRouterName}";
315
- resolvedPath = __resolvedPath(resolvedPath, input, "virtualRouterName", () => input.virtualRouterName, "{virtualRouterName}", false);
316
- resolvedPath = __resolvedPath(resolvedPath, input, "meshName", () => input.meshName, "{meshName}", false);
210
+ b.bp("/v20190125/meshes/{meshName}/virtualRouters/{virtualRouterName}");
211
+ b.p("virtualRouterName", () => input.virtualRouterName, "{virtualRouterName}", false);
212
+ b.p("meshName", () => input.meshName, "{meshName}", false);
317
213
  const query = map({
318
- meshOwner: [, input.meshOwner],
214
+ [_mO]: [, input[_mO]],
319
215
  });
320
216
  let body;
321
- return new __HttpRequest({
322
- protocol,
323
- hostname,
324
- port,
325
- method: "DELETE",
326
- headers,
327
- path: resolvedPath,
328
- query,
329
- body,
330
- });
217
+ b.m("DELETE").h(headers).q(query).b(body);
218
+ return b.build();
331
219
  };
332
220
  export const se_DeleteVirtualServiceCommand = async (input, context) => {
333
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
221
+ const b = rb(input, context);
334
222
  const headers = {};
335
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
336
- "/v20190125/meshes/{meshName}/virtualServices/{virtualServiceName}";
337
- resolvedPath = __resolvedPath(resolvedPath, input, "virtualServiceName", () => input.virtualServiceName, "{virtualServiceName}", false);
338
- resolvedPath = __resolvedPath(resolvedPath, input, "meshName", () => input.meshName, "{meshName}", false);
223
+ b.bp("/v20190125/meshes/{meshName}/virtualServices/{virtualServiceName}");
224
+ b.p("virtualServiceName", () => input.virtualServiceName, "{virtualServiceName}", false);
225
+ b.p("meshName", () => input.meshName, "{meshName}", false);
339
226
  const query = map({
340
- meshOwner: [, input.meshOwner],
227
+ [_mO]: [, input[_mO]],
341
228
  });
342
229
  let body;
343
- return new __HttpRequest({
344
- protocol,
345
- hostname,
346
- port,
347
- method: "DELETE",
348
- headers,
349
- path: resolvedPath,
350
- query,
351
- body,
352
- });
230
+ b.m("DELETE").h(headers).q(query).b(body);
231
+ return b.build();
353
232
  };
354
233
  export const se_DescribeGatewayRouteCommand = async (input, context) => {
355
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
234
+ const b = rb(input, context);
356
235
  const headers = {};
357
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
358
- "/v20190125/meshes/{meshName}/virtualGateway/{virtualGatewayName}/gatewayRoutes/{gatewayRouteName}";
359
- resolvedPath = __resolvedPath(resolvedPath, input, "gatewayRouteName", () => input.gatewayRouteName, "{gatewayRouteName}", false);
360
- resolvedPath = __resolvedPath(resolvedPath, input, "meshName", () => input.meshName, "{meshName}", false);
361
- resolvedPath = __resolvedPath(resolvedPath, input, "virtualGatewayName", () => input.virtualGatewayName, "{virtualGatewayName}", false);
236
+ b.bp("/v20190125/meshes/{meshName}/virtualGateway/{virtualGatewayName}/gatewayRoutes/{gatewayRouteName}");
237
+ b.p("gatewayRouteName", () => input.gatewayRouteName, "{gatewayRouteName}", false);
238
+ b.p("meshName", () => input.meshName, "{meshName}", false);
239
+ b.p("virtualGatewayName", () => input.virtualGatewayName, "{virtualGatewayName}", false);
362
240
  const query = map({
363
- meshOwner: [, input.meshOwner],
241
+ [_mO]: [, input[_mO]],
364
242
  });
365
243
  let body;
366
- return new __HttpRequest({
367
- protocol,
368
- hostname,
369
- port,
370
- method: "GET",
371
- headers,
372
- path: resolvedPath,
373
- query,
374
- body,
375
- });
244
+ b.m("GET").h(headers).q(query).b(body);
245
+ return b.build();
376
246
  };
377
247
  export const se_DescribeMeshCommand = async (input, context) => {
378
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
248
+ const b = rb(input, context);
379
249
  const headers = {};
380
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v20190125/meshes/{meshName}";
381
- resolvedPath = __resolvedPath(resolvedPath, input, "meshName", () => input.meshName, "{meshName}", false);
250
+ b.bp("/v20190125/meshes/{meshName}");
251
+ b.p("meshName", () => input.meshName, "{meshName}", false);
382
252
  const query = map({
383
- meshOwner: [, input.meshOwner],
253
+ [_mO]: [, input[_mO]],
384
254
  });
385
255
  let body;
386
- return new __HttpRequest({
387
- protocol,
388
- hostname,
389
- port,
390
- method: "GET",
391
- headers,
392
- path: resolvedPath,
393
- query,
394
- body,
395
- });
256
+ b.m("GET").h(headers).q(query).b(body);
257
+ return b.build();
396
258
  };
397
259
  export const se_DescribeRouteCommand = async (input, context) => {
398
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
260
+ const b = rb(input, context);
399
261
  const headers = {};
400
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
401
- "/v20190125/meshes/{meshName}/virtualRouter/{virtualRouterName}/routes/{routeName}";
402
- resolvedPath = __resolvedPath(resolvedPath, input, "routeName", () => input.routeName, "{routeName}", false);
403
- resolvedPath = __resolvedPath(resolvedPath, input, "meshName", () => input.meshName, "{meshName}", false);
404
- resolvedPath = __resolvedPath(resolvedPath, input, "virtualRouterName", () => input.virtualRouterName, "{virtualRouterName}", false);
262
+ b.bp("/v20190125/meshes/{meshName}/virtualRouter/{virtualRouterName}/routes/{routeName}");
263
+ b.p("routeName", () => input.routeName, "{routeName}", false);
264
+ b.p("meshName", () => input.meshName, "{meshName}", false);
265
+ b.p("virtualRouterName", () => input.virtualRouterName, "{virtualRouterName}", false);
405
266
  const query = map({
406
- meshOwner: [, input.meshOwner],
267
+ [_mO]: [, input[_mO]],
407
268
  });
408
269
  let body;
409
- return new __HttpRequest({
410
- protocol,
411
- hostname,
412
- port,
413
- method: "GET",
414
- headers,
415
- path: resolvedPath,
416
- query,
417
- body,
418
- });
270
+ b.m("GET").h(headers).q(query).b(body);
271
+ return b.build();
419
272
  };
420
273
  export const se_DescribeVirtualGatewayCommand = async (input, context) => {
421
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
274
+ const b = rb(input, context);
422
275
  const headers = {};
423
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
424
- "/v20190125/meshes/{meshName}/virtualGateways/{virtualGatewayName}";
425
- resolvedPath = __resolvedPath(resolvedPath, input, "virtualGatewayName", () => input.virtualGatewayName, "{virtualGatewayName}", false);
426
- resolvedPath = __resolvedPath(resolvedPath, input, "meshName", () => input.meshName, "{meshName}", false);
276
+ b.bp("/v20190125/meshes/{meshName}/virtualGateways/{virtualGatewayName}");
277
+ b.p("virtualGatewayName", () => input.virtualGatewayName, "{virtualGatewayName}", false);
278
+ b.p("meshName", () => input.meshName, "{meshName}", false);
427
279
  const query = map({
428
- meshOwner: [, input.meshOwner],
280
+ [_mO]: [, input[_mO]],
429
281
  });
430
282
  let body;
431
- return new __HttpRequest({
432
- protocol,
433
- hostname,
434
- port,
435
- method: "GET",
436
- headers,
437
- path: resolvedPath,
438
- query,
439
- body,
440
- });
283
+ b.m("GET").h(headers).q(query).b(body);
284
+ return b.build();
441
285
  };
442
286
  export const se_DescribeVirtualNodeCommand = async (input, context) => {
443
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
287
+ const b = rb(input, context);
444
288
  const headers = {};
445
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
446
- "/v20190125/meshes/{meshName}/virtualNodes/{virtualNodeName}";
447
- resolvedPath = __resolvedPath(resolvedPath, input, "virtualNodeName", () => input.virtualNodeName, "{virtualNodeName}", false);
448
- resolvedPath = __resolvedPath(resolvedPath, input, "meshName", () => input.meshName, "{meshName}", false);
289
+ b.bp("/v20190125/meshes/{meshName}/virtualNodes/{virtualNodeName}");
290
+ b.p("virtualNodeName", () => input.virtualNodeName, "{virtualNodeName}", false);
291
+ b.p("meshName", () => input.meshName, "{meshName}", false);
449
292
  const query = map({
450
- meshOwner: [, input.meshOwner],
293
+ [_mO]: [, input[_mO]],
451
294
  });
452
295
  let body;
453
- return new __HttpRequest({
454
- protocol,
455
- hostname,
456
- port,
457
- method: "GET",
458
- headers,
459
- path: resolvedPath,
460
- query,
461
- body,
462
- });
296
+ b.m("GET").h(headers).q(query).b(body);
297
+ return b.build();
463
298
  };
464
299
  export const se_DescribeVirtualRouterCommand = async (input, context) => {
465
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
300
+ const b = rb(input, context);
466
301
  const headers = {};
467
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
468
- "/v20190125/meshes/{meshName}/virtualRouters/{virtualRouterName}";
469
- resolvedPath = __resolvedPath(resolvedPath, input, "virtualRouterName", () => input.virtualRouterName, "{virtualRouterName}", false);
470
- resolvedPath = __resolvedPath(resolvedPath, input, "meshName", () => input.meshName, "{meshName}", false);
302
+ b.bp("/v20190125/meshes/{meshName}/virtualRouters/{virtualRouterName}");
303
+ b.p("virtualRouterName", () => input.virtualRouterName, "{virtualRouterName}", false);
304
+ b.p("meshName", () => input.meshName, "{meshName}", false);
471
305
  const query = map({
472
- meshOwner: [, input.meshOwner],
306
+ [_mO]: [, input[_mO]],
473
307
  });
474
308
  let body;
475
- return new __HttpRequest({
476
- protocol,
477
- hostname,
478
- port,
479
- method: "GET",
480
- headers,
481
- path: resolvedPath,
482
- query,
483
- body,
484
- });
309
+ b.m("GET").h(headers).q(query).b(body);
310
+ return b.build();
485
311
  };
486
312
  export const se_DescribeVirtualServiceCommand = async (input, context) => {
487
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
313
+ const b = rb(input, context);
488
314
  const headers = {};
489
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
490
- "/v20190125/meshes/{meshName}/virtualServices/{virtualServiceName}";
491
- resolvedPath = __resolvedPath(resolvedPath, input, "virtualServiceName", () => input.virtualServiceName, "{virtualServiceName}", false);
492
- resolvedPath = __resolvedPath(resolvedPath, input, "meshName", () => input.meshName, "{meshName}", false);
315
+ b.bp("/v20190125/meshes/{meshName}/virtualServices/{virtualServiceName}");
316
+ b.p("virtualServiceName", () => input.virtualServiceName, "{virtualServiceName}", false);
317
+ b.p("meshName", () => input.meshName, "{meshName}", false);
493
318
  const query = map({
494
- meshOwner: [, input.meshOwner],
319
+ [_mO]: [, input[_mO]],
495
320
  });
496
321
  let body;
497
- return new __HttpRequest({
498
- protocol,
499
- hostname,
500
- port,
501
- method: "GET",
502
- headers,
503
- path: resolvedPath,
504
- query,
505
- body,
506
- });
322
+ b.m("GET").h(headers).q(query).b(body);
323
+ return b.build();
507
324
  };
508
325
  export const se_ListGatewayRoutesCommand = async (input, context) => {
509
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
326
+ const b = rb(input, context);
510
327
  const headers = {};
511
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
512
- "/v20190125/meshes/{meshName}/virtualGateway/{virtualGatewayName}/gatewayRoutes";
513
- resolvedPath = __resolvedPath(resolvedPath, input, "meshName", () => input.meshName, "{meshName}", false);
514
- resolvedPath = __resolvedPath(resolvedPath, input, "virtualGatewayName", () => input.virtualGatewayName, "{virtualGatewayName}", false);
328
+ b.bp("/v20190125/meshes/{meshName}/virtualGateway/{virtualGatewayName}/gatewayRoutes");
329
+ b.p("meshName", () => input.meshName, "{meshName}", false);
330
+ b.p("virtualGatewayName", () => input.virtualGatewayName, "{virtualGatewayName}", false);
515
331
  const query = map({
516
- nextToken: [, input.nextToken],
517
- limit: [() => input.limit !== void 0, () => input.limit.toString()],
518
- meshOwner: [, input.meshOwner],
332
+ [_nT]: [, input[_nT]],
333
+ [_l]: [() => input.limit !== void 0, () => input[_l].toString()],
334
+ [_mO]: [, input[_mO]],
519
335
  });
520
336
  let body;
521
- return new __HttpRequest({
522
- protocol,
523
- hostname,
524
- port,
525
- method: "GET",
526
- headers,
527
- path: resolvedPath,
528
- query,
529
- body,
530
- });
337
+ b.m("GET").h(headers).q(query).b(body);
338
+ return b.build();
531
339
  };
532
340
  export const se_ListMeshesCommand = async (input, context) => {
533
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
341
+ const b = rb(input, context);
534
342
  const headers = {};
535
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v20190125/meshes";
343
+ b.bp("/v20190125/meshes");
536
344
  const query = map({
537
- nextToken: [, input.nextToken],
538
- limit: [() => input.limit !== void 0, () => input.limit.toString()],
345
+ [_nT]: [, input[_nT]],
346
+ [_l]: [() => input.limit !== void 0, () => input[_l].toString()],
539
347
  });
540
348
  let body;
541
- return new __HttpRequest({
542
- protocol,
543
- hostname,
544
- port,
545
- method: "GET",
546
- headers,
547
- path: resolvedPath,
548
- query,
549
- body,
550
- });
349
+ b.m("GET").h(headers).q(query).b(body);
350
+ return b.build();
551
351
  };
552
352
  export const se_ListRoutesCommand = async (input, context) => {
553
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
353
+ const b = rb(input, context);
554
354
  const headers = {};
555
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
556
- "/v20190125/meshes/{meshName}/virtualRouter/{virtualRouterName}/routes";
557
- resolvedPath = __resolvedPath(resolvedPath, input, "meshName", () => input.meshName, "{meshName}", false);
558
- resolvedPath = __resolvedPath(resolvedPath, input, "virtualRouterName", () => input.virtualRouterName, "{virtualRouterName}", false);
355
+ b.bp("/v20190125/meshes/{meshName}/virtualRouter/{virtualRouterName}/routes");
356
+ b.p("meshName", () => input.meshName, "{meshName}", false);
357
+ b.p("virtualRouterName", () => input.virtualRouterName, "{virtualRouterName}", false);
559
358
  const query = map({
560
- nextToken: [, input.nextToken],
561
- limit: [() => input.limit !== void 0, () => input.limit.toString()],
562
- meshOwner: [, input.meshOwner],
359
+ [_nT]: [, input[_nT]],
360
+ [_l]: [() => input.limit !== void 0, () => input[_l].toString()],
361
+ [_mO]: [, input[_mO]],
563
362
  });
564
363
  let body;
565
- return new __HttpRequest({
566
- protocol,
567
- hostname,
568
- port,
569
- method: "GET",
570
- headers,
571
- path: resolvedPath,
572
- query,
573
- body,
574
- });
364
+ b.m("GET").h(headers).q(query).b(body);
365
+ return b.build();
575
366
  };
576
367
  export const se_ListTagsForResourceCommand = async (input, context) => {
577
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
368
+ const b = rb(input, context);
578
369
  const headers = {};
579
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v20190125/tags";
370
+ b.bp("/v20190125/tags");
580
371
  const query = map({
581
- resourceArn: [, __expectNonNull(input.resourceArn, `resourceArn`)],
582
- nextToken: [, input.nextToken],
583
- limit: [() => input.limit !== void 0, () => input.limit.toString()],
372
+ [_rA]: [, __expectNonNull(input[_rA], `resourceArn`)],
373
+ [_nT]: [, input[_nT]],
374
+ [_l]: [() => input.limit !== void 0, () => input[_l].toString()],
584
375
  });
585
376
  let body;
586
- return new __HttpRequest({
587
- protocol,
588
- hostname,
589
- port,
590
- method: "GET",
591
- headers,
592
- path: resolvedPath,
593
- query,
594
- body,
595
- });
377
+ b.m("GET").h(headers).q(query).b(body);
378
+ return b.build();
596
379
  };
597
380
  export const se_ListVirtualGatewaysCommand = async (input, context) => {
598
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
381
+ const b = rb(input, context);
599
382
  const headers = {};
600
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
601
- "/v20190125/meshes/{meshName}/virtualGateways";
602
- resolvedPath = __resolvedPath(resolvedPath, input, "meshName", () => input.meshName, "{meshName}", false);
383
+ b.bp("/v20190125/meshes/{meshName}/virtualGateways");
384
+ b.p("meshName", () => input.meshName, "{meshName}", false);
603
385
  const query = map({
604
- nextToken: [, input.nextToken],
605
- limit: [() => input.limit !== void 0, () => input.limit.toString()],
606
- meshOwner: [, input.meshOwner],
386
+ [_nT]: [, input[_nT]],
387
+ [_l]: [() => input.limit !== void 0, () => input[_l].toString()],
388
+ [_mO]: [, input[_mO]],
607
389
  });
608
390
  let body;
609
- return new __HttpRequest({
610
- protocol,
611
- hostname,
612
- port,
613
- method: "GET",
614
- headers,
615
- path: resolvedPath,
616
- query,
617
- body,
618
- });
391
+ b.m("GET").h(headers).q(query).b(body);
392
+ return b.build();
619
393
  };
620
394
  export const se_ListVirtualNodesCommand = async (input, context) => {
621
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
395
+ const b = rb(input, context);
622
396
  const headers = {};
623
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v20190125/meshes/{meshName}/virtualNodes";
624
- resolvedPath = __resolvedPath(resolvedPath, input, "meshName", () => input.meshName, "{meshName}", false);
397
+ b.bp("/v20190125/meshes/{meshName}/virtualNodes");
398
+ b.p("meshName", () => input.meshName, "{meshName}", false);
625
399
  const query = map({
626
- nextToken: [, input.nextToken],
627
- limit: [() => input.limit !== void 0, () => input.limit.toString()],
628
- meshOwner: [, input.meshOwner],
400
+ [_nT]: [, input[_nT]],
401
+ [_l]: [() => input.limit !== void 0, () => input[_l].toString()],
402
+ [_mO]: [, input[_mO]],
629
403
  });
630
404
  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
- });
405
+ b.m("GET").h(headers).q(query).b(body);
406
+ return b.build();
641
407
  };
642
408
  export const se_ListVirtualRoutersCommand = async (input, context) => {
643
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
409
+ const b = rb(input, context);
644
410
  const headers = {};
645
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
646
- "/v20190125/meshes/{meshName}/virtualRouters";
647
- resolvedPath = __resolvedPath(resolvedPath, input, "meshName", () => input.meshName, "{meshName}", false);
411
+ b.bp("/v20190125/meshes/{meshName}/virtualRouters");
412
+ b.p("meshName", () => input.meshName, "{meshName}", false);
648
413
  const query = map({
649
- nextToken: [, input.nextToken],
650
- limit: [() => input.limit !== void 0, () => input.limit.toString()],
651
- meshOwner: [, input.meshOwner],
414
+ [_nT]: [, input[_nT]],
415
+ [_l]: [() => input.limit !== void 0, () => input[_l].toString()],
416
+ [_mO]: [, input[_mO]],
652
417
  });
653
418
  let body;
654
- return new __HttpRequest({
655
- protocol,
656
- hostname,
657
- port,
658
- method: "GET",
659
- headers,
660
- path: resolvedPath,
661
- query,
662
- body,
663
- });
419
+ b.m("GET").h(headers).q(query).b(body);
420
+ return b.build();
664
421
  };
665
422
  export const se_ListVirtualServicesCommand = async (input, context) => {
666
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
423
+ const b = rb(input, context);
667
424
  const headers = {};
668
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
669
- "/v20190125/meshes/{meshName}/virtualServices";
670
- resolvedPath = __resolvedPath(resolvedPath, input, "meshName", () => input.meshName, "{meshName}", false);
425
+ b.bp("/v20190125/meshes/{meshName}/virtualServices");
426
+ b.p("meshName", () => input.meshName, "{meshName}", false);
671
427
  const query = map({
672
- nextToken: [, input.nextToken],
673
- limit: [() => input.limit !== void 0, () => input.limit.toString()],
674
- meshOwner: [, input.meshOwner],
428
+ [_nT]: [, input[_nT]],
429
+ [_l]: [() => input.limit !== void 0, () => input[_l].toString()],
430
+ [_mO]: [, input[_mO]],
675
431
  });
676
432
  let body;
677
- return new __HttpRequest({
678
- protocol,
679
- hostname,
680
- port,
681
- method: "GET",
682
- headers,
683
- path: resolvedPath,
684
- query,
685
- body,
686
- });
433
+ b.m("GET").h(headers).q(query).b(body);
434
+ return b.build();
687
435
  };
688
436
  export const se_TagResourceCommand = async (input, context) => {
689
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
437
+ const b = rb(input, context);
690
438
  const headers = {
691
439
  "content-type": "application/json",
692
440
  };
693
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v20190125/tag";
441
+ b.bp("/v20190125/tag");
694
442
  const query = map({
695
- resourceArn: [, __expectNonNull(input.resourceArn, `resourceArn`)],
443
+ [_rA]: [, __expectNonNull(input[_rA], `resourceArn`)],
696
444
  });
697
445
  let body;
698
446
  body = JSON.stringify(take(input, {
699
447
  tags: (_) => _json(_),
700
448
  }));
701
- return new __HttpRequest({
702
- protocol,
703
- hostname,
704
- port,
705
- method: "PUT",
706
- headers,
707
- path: resolvedPath,
708
- query,
709
- body,
710
- });
449
+ b.m("PUT").h(headers).q(query).b(body);
450
+ return b.build();
711
451
  };
712
452
  export const se_UntagResourceCommand = async (input, context) => {
713
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
453
+ const b = rb(input, context);
714
454
  const headers = {
715
455
  "content-type": "application/json",
716
456
  };
717
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v20190125/untag";
457
+ b.bp("/v20190125/untag");
718
458
  const query = map({
719
- resourceArn: [, __expectNonNull(input.resourceArn, `resourceArn`)],
459
+ [_rA]: [, __expectNonNull(input[_rA], `resourceArn`)],
720
460
  });
721
461
  let body;
722
462
  body = JSON.stringify(take(input, {
723
463
  tagKeys: (_) => _json(_),
724
464
  }));
725
- return new __HttpRequest({
726
- protocol,
727
- hostname,
728
- port,
729
- method: "PUT",
730
- headers,
731
- path: resolvedPath,
732
- query,
733
- body,
734
- });
465
+ b.m("PUT").h(headers).q(query).b(body);
466
+ return b.build();
735
467
  };
736
468
  export const se_UpdateGatewayRouteCommand = async (input, context) => {
737
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
469
+ const b = rb(input, context);
738
470
  const headers = {
739
471
  "content-type": "application/json",
740
472
  };
741
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
742
- "/v20190125/meshes/{meshName}/virtualGateway/{virtualGatewayName}/gatewayRoutes/{gatewayRouteName}";
743
- resolvedPath = __resolvedPath(resolvedPath, input, "gatewayRouteName", () => input.gatewayRouteName, "{gatewayRouteName}", false);
744
- resolvedPath = __resolvedPath(resolvedPath, input, "meshName", () => input.meshName, "{meshName}", false);
745
- resolvedPath = __resolvedPath(resolvedPath, input, "virtualGatewayName", () => input.virtualGatewayName, "{virtualGatewayName}", false);
473
+ b.bp("/v20190125/meshes/{meshName}/virtualGateway/{virtualGatewayName}/gatewayRoutes/{gatewayRouteName}");
474
+ b.p("gatewayRouteName", () => input.gatewayRouteName, "{gatewayRouteName}", false);
475
+ b.p("meshName", () => input.meshName, "{meshName}", false);
476
+ b.p("virtualGatewayName", () => input.virtualGatewayName, "{virtualGatewayName}", false);
746
477
  const query = map({
747
- meshOwner: [, input.meshOwner],
478
+ [_mO]: [, input[_mO]],
748
479
  });
749
480
  let body;
750
481
  body = JSON.stringify(take(input, {
751
482
  clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
752
483
  spec: (_) => _json(_),
753
484
  }));
754
- return new __HttpRequest({
755
- protocol,
756
- hostname,
757
- port,
758
- method: "PUT",
759
- headers,
760
- path: resolvedPath,
761
- query,
762
- body,
763
- });
485
+ b.m("PUT").h(headers).q(query).b(body);
486
+ return b.build();
764
487
  };
765
488
  export const se_UpdateMeshCommand = async (input, context) => {
766
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
489
+ const b = rb(input, context);
767
490
  const headers = {
768
491
  "content-type": "application/json",
769
492
  };
770
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v20190125/meshes/{meshName}";
771
- resolvedPath = __resolvedPath(resolvedPath, input, "meshName", () => input.meshName, "{meshName}", false);
493
+ b.bp("/v20190125/meshes/{meshName}");
494
+ b.p("meshName", () => input.meshName, "{meshName}", false);
772
495
  let body;
773
496
  body = JSON.stringify(take(input, {
774
497
  clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
775
498
  spec: (_) => _json(_),
776
499
  }));
777
- return new __HttpRequest({
778
- protocol,
779
- hostname,
780
- port,
781
- method: "PUT",
782
- headers,
783
- path: resolvedPath,
784
- body,
785
- });
500
+ b.m("PUT").h(headers).b(body);
501
+ return b.build();
786
502
  };
787
503
  export const se_UpdateRouteCommand = async (input, context) => {
788
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
504
+ const b = rb(input, context);
789
505
  const headers = {
790
506
  "content-type": "application/json",
791
507
  };
792
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
793
- "/v20190125/meshes/{meshName}/virtualRouter/{virtualRouterName}/routes/{routeName}";
794
- resolvedPath = __resolvedPath(resolvedPath, input, "routeName", () => input.routeName, "{routeName}", false);
795
- resolvedPath = __resolvedPath(resolvedPath, input, "meshName", () => input.meshName, "{meshName}", false);
796
- resolvedPath = __resolvedPath(resolvedPath, input, "virtualRouterName", () => input.virtualRouterName, "{virtualRouterName}", false);
508
+ b.bp("/v20190125/meshes/{meshName}/virtualRouter/{virtualRouterName}/routes/{routeName}");
509
+ b.p("routeName", () => input.routeName, "{routeName}", false);
510
+ b.p("meshName", () => input.meshName, "{meshName}", false);
511
+ b.p("virtualRouterName", () => input.virtualRouterName, "{virtualRouterName}", false);
797
512
  const query = map({
798
- meshOwner: [, input.meshOwner],
513
+ [_mO]: [, input[_mO]],
799
514
  });
800
515
  let body;
801
516
  body = JSON.stringify(take(input, {
802
517
  clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
803
518
  spec: (_) => _json(_),
804
519
  }));
805
- return new __HttpRequest({
806
- protocol,
807
- hostname,
808
- port,
809
- method: "PUT",
810
- headers,
811
- path: resolvedPath,
812
- query,
813
- body,
814
- });
520
+ b.m("PUT").h(headers).q(query).b(body);
521
+ return b.build();
815
522
  };
816
523
  export const se_UpdateVirtualGatewayCommand = async (input, context) => {
817
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
524
+ const b = rb(input, context);
818
525
  const headers = {
819
526
  "content-type": "application/json",
820
527
  };
821
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
822
- "/v20190125/meshes/{meshName}/virtualGateways/{virtualGatewayName}";
823
- resolvedPath = __resolvedPath(resolvedPath, input, "virtualGatewayName", () => input.virtualGatewayName, "{virtualGatewayName}", false);
824
- resolvedPath = __resolvedPath(resolvedPath, input, "meshName", () => input.meshName, "{meshName}", false);
528
+ b.bp("/v20190125/meshes/{meshName}/virtualGateways/{virtualGatewayName}");
529
+ b.p("virtualGatewayName", () => input.virtualGatewayName, "{virtualGatewayName}", false);
530
+ b.p("meshName", () => input.meshName, "{meshName}", false);
825
531
  const query = map({
826
- meshOwner: [, input.meshOwner],
532
+ [_mO]: [, input[_mO]],
827
533
  });
828
534
  let body;
829
535
  body = JSON.stringify(take(input, {
830
536
  clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
831
537
  spec: (_) => _json(_),
832
538
  }));
833
- return new __HttpRequest({
834
- protocol,
835
- hostname,
836
- port,
837
- method: "PUT",
838
- headers,
839
- path: resolvedPath,
840
- query,
841
- body,
842
- });
539
+ b.m("PUT").h(headers).q(query).b(body);
540
+ return b.build();
843
541
  };
844
542
  export const se_UpdateVirtualNodeCommand = async (input, context) => {
845
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
543
+ const b = rb(input, context);
846
544
  const headers = {
847
545
  "content-type": "application/json",
848
546
  };
849
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
850
- "/v20190125/meshes/{meshName}/virtualNodes/{virtualNodeName}";
851
- resolvedPath = __resolvedPath(resolvedPath, input, "virtualNodeName", () => input.virtualNodeName, "{virtualNodeName}", false);
852
- resolvedPath = __resolvedPath(resolvedPath, input, "meshName", () => input.meshName, "{meshName}", false);
547
+ b.bp("/v20190125/meshes/{meshName}/virtualNodes/{virtualNodeName}");
548
+ b.p("virtualNodeName", () => input.virtualNodeName, "{virtualNodeName}", false);
549
+ b.p("meshName", () => input.meshName, "{meshName}", false);
853
550
  const query = map({
854
- meshOwner: [, input.meshOwner],
551
+ [_mO]: [, input[_mO]],
855
552
  });
856
553
  let body;
857
554
  body = JSON.stringify(take(input, {
858
555
  clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
859
556
  spec: (_) => _json(_),
860
557
  }));
861
- return new __HttpRequest({
862
- protocol,
863
- hostname,
864
- port,
865
- method: "PUT",
866
- headers,
867
- path: resolvedPath,
868
- query,
869
- body,
870
- });
558
+ b.m("PUT").h(headers).q(query).b(body);
559
+ return b.build();
871
560
  };
872
561
  export const se_UpdateVirtualRouterCommand = async (input, context) => {
873
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
562
+ const b = rb(input, context);
874
563
  const headers = {
875
564
  "content-type": "application/json",
876
565
  };
877
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
878
- "/v20190125/meshes/{meshName}/virtualRouters/{virtualRouterName}";
879
- resolvedPath = __resolvedPath(resolvedPath, input, "virtualRouterName", () => input.virtualRouterName, "{virtualRouterName}", false);
880
- resolvedPath = __resolvedPath(resolvedPath, input, "meshName", () => input.meshName, "{meshName}", false);
566
+ b.bp("/v20190125/meshes/{meshName}/virtualRouters/{virtualRouterName}");
567
+ b.p("virtualRouterName", () => input.virtualRouterName, "{virtualRouterName}", false);
568
+ b.p("meshName", () => input.meshName, "{meshName}", false);
881
569
  const query = map({
882
- meshOwner: [, input.meshOwner],
570
+ [_mO]: [, input[_mO]],
883
571
  });
884
572
  let body;
885
573
  body = JSON.stringify(take(input, {
886
574
  clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
887
575
  spec: (_) => _json(_),
888
576
  }));
889
- return new __HttpRequest({
890
- protocol,
891
- hostname,
892
- port,
893
- method: "PUT",
894
- headers,
895
- path: resolvedPath,
896
- query,
897
- body,
898
- });
577
+ b.m("PUT").h(headers).q(query).b(body);
578
+ return b.build();
899
579
  };
900
580
  export const se_UpdateVirtualServiceCommand = async (input, context) => {
901
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
581
+ const b = rb(input, context);
902
582
  const headers = {
903
583
  "content-type": "application/json",
904
584
  };
905
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
906
- "/v20190125/meshes/{meshName}/virtualServices/{virtualServiceName}";
907
- resolvedPath = __resolvedPath(resolvedPath, input, "virtualServiceName", () => input.virtualServiceName, "{virtualServiceName}", false);
908
- resolvedPath = __resolvedPath(resolvedPath, input, "meshName", () => input.meshName, "{meshName}", false);
585
+ b.bp("/v20190125/meshes/{meshName}/virtualServices/{virtualServiceName}");
586
+ b.p("virtualServiceName", () => input.virtualServiceName, "{virtualServiceName}", false);
587
+ b.p("meshName", () => input.meshName, "{meshName}", false);
909
588
  const query = map({
910
- meshOwner: [, input.meshOwner],
589
+ [_mO]: [, input[_mO]],
911
590
  });
912
591
  let body;
913
592
  body = JSON.stringify(take(input, {
914
593
  clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
915
594
  spec: (_) => _json(_),
916
595
  }));
917
- return new __HttpRequest({
918
- protocol,
919
- hostname,
920
- port,
921
- method: "PUT",
922
- headers,
923
- path: resolvedPath,
924
- query,
925
- body,
926
- });
596
+ b.m("PUT").h(headers).q(query).b(body);
597
+ return b.build();
927
598
  };
928
599
  export const de_CreateGatewayRouteCommand = async (output, context) => {
929
600
  if (output.statusCode !== 200 && output.statusCode >= 300) {
@@ -3129,6 +2800,10 @@ const isSerializableHeaderValue = (value) => value !== undefined &&
3129
2800
  value !== "" &&
3130
2801
  (!Object.getOwnPropertyNames(value).includes("length") || value.length != 0) &&
3131
2802
  (!Object.getOwnPropertyNames(value).includes("size") || value.size != 0);
2803
+ const _l = "limit";
2804
+ const _mO = "meshOwner";
2805
+ const _nT = "nextToken";
2806
+ const _rA = "resourceArn";
3132
2807
  const parseBody = (streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
3133
2808
  if (encoded.length) {
3134
2809
  return JSON.parse(encoded);