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