@aws-sdk/client-vpc-lattice 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 +300 -693
  2. package/dist-es/protocols/Aws_restJson1.js +301 -694
  3. package/package.json +5 -4
package/dist-cjs/protocols/Aws_restJson1.js CHANGED
@@ -4,41 +4,33 @@ exports.se_UpdateServiceNetworkCommand = exports.se_UpdateServiceCommand = expor
4
4
  exports.de_UpdateRuleCommand = exports.de_UpdateListenerCommand = exports.de_UpdateAccessLogSubscriptionCommand = exports.de_UntagResourceCommand = exports.de_TagResourceCommand = exports.de_RegisterTargetsCommand = exports.de_PutResourcePolicyCommand = exports.de_PutAuthPolicyCommand = exports.de_ListTargetsCommand = exports.de_ListTargetGroupsCommand = exports.de_ListTagsForResourceCommand = exports.de_ListServicesCommand = exports.de_ListServiceNetworkVpcAssociationsCommand = exports.de_ListServiceNetworkServiceAssociationsCommand = exports.de_ListServiceNetworksCommand = exports.de_ListRulesCommand = exports.de_ListListenersCommand = exports.de_ListAccessLogSubscriptionsCommand = exports.de_GetTargetGroupCommand = exports.de_GetServiceNetworkVpcAssociationCommand = exports.de_GetServiceNetworkServiceAssociationCommand = exports.de_GetServiceNetworkCommand = exports.de_GetServiceCommand = exports.de_GetRuleCommand = exports.de_GetResourcePolicyCommand = exports.de_GetListenerCommand = exports.de_GetAuthPolicyCommand = exports.de_GetAccessLogSubscriptionCommand = exports.de_DeregisterTargetsCommand = exports.de_DeleteTargetGroupCommand = exports.de_DeleteServiceNetworkVpcAssociationCommand = exports.de_DeleteServiceNetworkServiceAssociationCommand = exports.de_DeleteServiceNetworkCommand = exports.de_DeleteServiceCommand = exports.de_DeleteRuleCommand = exports.de_DeleteResourcePolicyCommand = exports.de_DeleteListenerCommand = exports.de_DeleteAuthPolicyCommand = exports.de_DeleteAccessLogSubscriptionCommand = exports.de_CreateTargetGroupCommand = exports.de_CreateServiceNetworkVpcAssociationCommand = exports.de_CreateServiceNetworkServiceAssociationCommand = exports.de_CreateServiceNetworkCommand = exports.de_CreateServiceCommand = exports.de_CreateRuleCommand = exports.de_CreateListenerCommand = exports.de_CreateAccessLogSubscriptionCommand = exports.de_BatchUpdateRuleCommand = exports.se_UpdateTargetGroupCommand = exports.se_UpdateServiceNetworkVpcAssociationCommand = void 0;
5
5
  exports.de_UpdateTargetGroupCommand = exports.de_UpdateServiceNetworkVpcAssociationCommand = exports.de_UpdateServiceNetworkCommand = exports.de_UpdateServiceCommand = void 0;
6
6
  const core_1 = require("@aws-sdk/core");
7
- const protocol_http_1 = require("@smithy/protocol-http");
7
+ const core_2 = require("@smithy/core");
8
8
  const smithy_client_1 = require("@smithy/smithy-client");
9
9
  const uuid_1 = require("uuid");
10
10
  const models_0_1 = require("../models/models_0");
11
11
  const VPCLatticeServiceException_1 = require("../models/VPCLatticeServiceException");
12
12
  const se_BatchUpdateRuleCommand = async (input, context) => {
13
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
13
+ const b = (0, core_2.requestBuilder)(input, context);
14
14
  const headers = {
15
15
  "content-type": "application/json",
16
16
  };
17
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
18
- "/services/{serviceIdentifier}/listeners/{listenerIdentifier}/rules";
19
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "serviceIdentifier", () => input.serviceIdentifier, "{serviceIdentifier}", false);
20
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "listenerIdentifier", () => input.listenerIdentifier, "{listenerIdentifier}", false);
17
+ b.bp("/services/{serviceIdentifier}/listeners/{listenerIdentifier}/rules");
18
+ b.p("serviceIdentifier", () => input.serviceIdentifier, "{serviceIdentifier}", false);
19
+ b.p("listenerIdentifier", () => input.listenerIdentifier, "{listenerIdentifier}", false);
21
20
  let body;
22
21
  body = JSON.stringify((0, smithy_client_1.take)(input, {
23
22
  rules: (_) => (0, smithy_client_1._json)(_),
24
23
  }));
25
- return new protocol_http_1.HttpRequest({
26
- protocol,
27
- hostname,
28
- port,
29
- method: "PATCH",
30
- headers,
31
- path: resolvedPath,
32
- body,
33
- });
24
+ b.m("PATCH").h(headers).b(body);
25
+ return b.build();
34
26
  };
35
27
  exports.se_BatchUpdateRuleCommand = se_BatchUpdateRuleCommand;
36
28
  const se_CreateAccessLogSubscriptionCommand = async (input, context) => {
37
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
29
+ const b = (0, core_2.requestBuilder)(input, context);
38
30
  const headers = {
39
31
  "content-type": "application/json",
40
32
  };
41
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/accesslogsubscriptions";
33
+ b.bp("/accesslogsubscriptions");
42
34
  let body;
43
35
  body = JSON.stringify((0, smithy_client_1.take)(input, {
44
36
  clientToken: [true, (_) => _ ?? (0, uuid_1.v4)()],
@@ -46,24 +38,17 @@ const se_CreateAccessLogSubscriptionCommand = async (input, context) => {
46
38
  resourceIdentifier: [],
47
39
  tags: (_) => (0, smithy_client_1._json)(_),
48
40
  }));
49
- return new protocol_http_1.HttpRequest({
50
- protocol,
51
- hostname,
52
- port,
53
- method: "POST",
54
- headers,
55
- path: resolvedPath,
56
- body,
57
- });
41
+ b.m("POST").h(headers).b(body);
42
+ return b.build();
58
43
  };
59
44
  exports.se_CreateAccessLogSubscriptionCommand = se_CreateAccessLogSubscriptionCommand;
60
45
  const se_CreateListenerCommand = async (input, context) => {
61
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
46
+ const b = (0, core_2.requestBuilder)(input, context);
62
47
  const headers = {
63
48
  "content-type": "application/json",
64
49
  };
65
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/services/{serviceIdentifier}/listeners";
66
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "serviceIdentifier", () => input.serviceIdentifier, "{serviceIdentifier}", false);
50
+ b.bp("/services/{serviceIdentifier}/listeners");
51
+ b.p("serviceIdentifier", () => input.serviceIdentifier, "{serviceIdentifier}", false);
67
52
  let body;
68
53
  body = JSON.stringify((0, smithy_client_1.take)(input, {
69
54
  clientToken: [true, (_) => _ ?? (0, uuid_1.v4)()],
@@ -73,26 +58,18 @@ const se_CreateListenerCommand = async (input, context) => {
73
58
  protocol: [],
74
59
  tags: (_) => (0, smithy_client_1._json)(_),
75
60
  }));
76
- return new protocol_http_1.HttpRequest({
77
- protocol,
78
- hostname,
79
- port,
80
- method: "POST",
81
- headers,
82
- path: resolvedPath,
83
- body,
84
- });
61
+ b.m("POST").h(headers).b(body);
62
+ return b.build();
85
63
  };
86
64
  exports.se_CreateListenerCommand = se_CreateListenerCommand;
87
65
  const se_CreateRuleCommand = async (input, context) => {
88
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
66
+ const b = (0, core_2.requestBuilder)(input, context);
89
67
  const headers = {
90
68
  "content-type": "application/json",
91
69
  };
92
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
93
- "/services/{serviceIdentifier}/listeners/{listenerIdentifier}/rules";
94
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "serviceIdentifier", () => input.serviceIdentifier, "{serviceIdentifier}", false);
95
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "listenerIdentifier", () => input.listenerIdentifier, "{listenerIdentifier}", false);
70
+ b.bp("/services/{serviceIdentifier}/listeners/{listenerIdentifier}/rules");
71
+ b.p("serviceIdentifier", () => input.serviceIdentifier, "{serviceIdentifier}", false);
72
+ b.p("listenerIdentifier", () => input.listenerIdentifier, "{listenerIdentifier}", false);
96
73
  let body;
97
74
  body = JSON.stringify((0, smithy_client_1.take)(input, {
98
75
  action: (_) => (0, smithy_client_1._json)(_),
@@ -102,23 +79,16 @@ const se_CreateRuleCommand = async (input, context) => {
102
79
  priority: [],
103
80
  tags: (_) => (0, smithy_client_1._json)(_),
104
81
  }));
105
- return new protocol_http_1.HttpRequest({
106
- protocol,
107
- hostname,
108
- port,
109
- method: "POST",
110
- headers,
111
- path: resolvedPath,
112
- body,
113
- });
82
+ b.m("POST").h(headers).b(body);
83
+ return b.build();
114
84
  };
115
85
  exports.se_CreateRuleCommand = se_CreateRuleCommand;
116
86
  const se_CreateServiceCommand = async (input, context) => {
117
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
87
+ const b = (0, core_2.requestBuilder)(input, context);
118
88
  const headers = {
119
89
  "content-type": "application/json",
120
90
  };
121
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/services";
91
+ b.bp("/services");
122
92
  let body;
123
93
  body = JSON.stringify((0, smithy_client_1.take)(input, {
124
94
  authType: [],
@@ -128,23 +98,16 @@ const se_CreateServiceCommand = async (input, context) => {
128
98
  name: [],
129
99
  tags: (_) => (0, smithy_client_1._json)(_),
130
100
  }));
131
- return new protocol_http_1.HttpRequest({
132
- protocol,
133
- hostname,
134
- port,
135
- method: "POST",
136
- headers,
137
- path: resolvedPath,
138
- body,
139
- });
101
+ b.m("POST").h(headers).b(body);
102
+ return b.build();
140
103
  };
141
104
  exports.se_CreateServiceCommand = se_CreateServiceCommand;
142
105
  const se_CreateServiceNetworkCommand = async (input, context) => {
143
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
106
+ const b = (0, core_2.requestBuilder)(input, context);
144
107
  const headers = {
145
108
  "content-type": "application/json",
146
109
  };
147
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/servicenetworks";
110
+ b.bp("/servicenetworks");
148
111
  let body;
149
112
  body = JSON.stringify((0, smithy_client_1.take)(input, {
150
113
  authType: [],
@@ -152,23 +115,16 @@ const se_CreateServiceNetworkCommand = async (input, context) => {
152
115
  name: [],
153
116
  tags: (_) => (0, smithy_client_1._json)(_),
154
117
  }));
155
- return new protocol_http_1.HttpRequest({
156
- protocol,
157
- hostname,
158
- port,
159
- method: "POST",
160
- headers,
161
- path: resolvedPath,
162
- body,
163
- });
118
+ b.m("POST").h(headers).b(body);
119
+ return b.build();
164
120
  };
165
121
  exports.se_CreateServiceNetworkCommand = se_CreateServiceNetworkCommand;
166
122
  const se_CreateServiceNetworkServiceAssociationCommand = async (input, context) => {
167
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
123
+ const b = (0, core_2.requestBuilder)(input, context);
168
124
  const headers = {
169
125
  "content-type": "application/json",
170
126
  };
171
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/servicenetworkserviceassociations";
127
+ b.bp("/servicenetworkserviceassociations");
172
128
  let body;
173
129
  body = JSON.stringify((0, smithy_client_1.take)(input, {
174
130
  clientToken: [true, (_) => _ ?? (0, uuid_1.v4)()],
@@ -176,23 +132,16 @@ const se_CreateServiceNetworkServiceAssociationCommand = async (input, context)
176
132
  serviceNetworkIdentifier: [],
177
133
  tags: (_) => (0, smithy_client_1._json)(_),
178
134
  }));
179
- return new protocol_http_1.HttpRequest({
180
- protocol,
181
- hostname,
182
- port,
183
- method: "POST",
184
- headers,
185
- path: resolvedPath,
186
- body,
187
- });
135
+ b.m("POST").h(headers).b(body);
136
+ return b.build();
188
137
  };
189
138
  exports.se_CreateServiceNetworkServiceAssociationCommand = se_CreateServiceNetworkServiceAssociationCommand;
190
139
  const se_CreateServiceNetworkVpcAssociationCommand = async (input, context) => {
191
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
140
+ const b = (0, core_2.requestBuilder)(input, context);
192
141
  const headers = {
193
142
  "content-type": "application/json",
194
143
  };
195
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/servicenetworkvpcassociations";
144
+ b.bp("/servicenetworkvpcassociations");
196
145
  let body;
197
146
  body = JSON.stringify((0, smithy_client_1.take)(input, {
198
147
  clientToken: [true, (_) => _ ?? (0, uuid_1.v4)()],
@@ -201,23 +150,16 @@ const se_CreateServiceNetworkVpcAssociationCommand = async (input, context) => {
201
150
  tags: (_) => (0, smithy_client_1._json)(_),
202
151
  vpcIdentifier: [],
203
152
  }));
204
- return new protocol_http_1.HttpRequest({
205
- protocol,
206
- hostname,
207
- port,
208
- method: "POST",
209
- headers,
210
- path: resolvedPath,
211
- body,
212
- });
153
+ b.m("POST").h(headers).b(body);
154
+ return b.build();
213
155
  };
214
156
  exports.se_CreateServiceNetworkVpcAssociationCommand = se_CreateServiceNetworkVpcAssociationCommand;
215
157
  const se_CreateTargetGroupCommand = async (input, context) => {
216
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
158
+ const b = (0, core_2.requestBuilder)(input, context);
217
159
  const headers = {
218
160
  "content-type": "application/json",
219
161
  };
220
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/targetgroups";
162
+ b.bp("/targetgroups");
221
163
  let body;
222
164
  body = JSON.stringify((0, smithy_client_1.take)(input, {
223
165
  clientToken: [true, (_) => _ ?? (0, uuid_1.v4)()],
@@ -226,898 +168,559 @@ const se_CreateTargetGroupCommand = async (input, context) => {
226
168
  tags: (_) => (0, smithy_client_1._json)(_),
227
169
  type: [],
228
170
  }));
229
- return new protocol_http_1.HttpRequest({
230
- protocol,
231
- hostname,
232
- port,
233
- method: "POST",
234
- headers,
235
- path: resolvedPath,
236
- body,
237
- });
171
+ b.m("POST").h(headers).b(body);
172
+ return b.build();
238
173
  };
239
174
  exports.se_CreateTargetGroupCommand = se_CreateTargetGroupCommand;
240
175
  const se_DeleteAccessLogSubscriptionCommand = async (input, context) => {
241
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
176
+ const b = (0, core_2.requestBuilder)(input, context);
242
177
  const headers = {};
243
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
244
- "/accesslogsubscriptions/{accessLogSubscriptionIdentifier}";
245
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "accessLogSubscriptionIdentifier", () => input.accessLogSubscriptionIdentifier, "{accessLogSubscriptionIdentifier}", false);
178
+ b.bp("/accesslogsubscriptions/{accessLogSubscriptionIdentifier}");
179
+ b.p("accessLogSubscriptionIdentifier", () => input.accessLogSubscriptionIdentifier, "{accessLogSubscriptionIdentifier}", false);
246
180
  let body;
247
- return new protocol_http_1.HttpRequest({
248
- protocol,
249
- hostname,
250
- port,
251
- method: "DELETE",
252
- headers,
253
- path: resolvedPath,
254
- body,
255
- });
181
+ b.m("DELETE").h(headers).b(body);
182
+ return b.build();
256
183
  };
257
184
  exports.se_DeleteAccessLogSubscriptionCommand = se_DeleteAccessLogSubscriptionCommand;
258
185
  const se_DeleteAuthPolicyCommand = async (input, context) => {
259
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
186
+ const b = (0, core_2.requestBuilder)(input, context);
260
187
  const headers = {};
261
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/authpolicy/{resourceIdentifier}";
262
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "resourceIdentifier", () => input.resourceIdentifier, "{resourceIdentifier}", false);
188
+ b.bp("/authpolicy/{resourceIdentifier}");
189
+ b.p("resourceIdentifier", () => input.resourceIdentifier, "{resourceIdentifier}", false);
263
190
  let body;
264
- return new protocol_http_1.HttpRequest({
265
- protocol,
266
- hostname,
267
- port,
268
- method: "DELETE",
269
- headers,
270
- path: resolvedPath,
271
- body,
272
- });
191
+ b.m("DELETE").h(headers).b(body);
192
+ return b.build();
273
193
  };
274
194
  exports.se_DeleteAuthPolicyCommand = se_DeleteAuthPolicyCommand;
275
195
  const se_DeleteListenerCommand = async (input, context) => {
276
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
196
+ const b = (0, core_2.requestBuilder)(input, context);
277
197
  const headers = {};
278
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
279
- "/services/{serviceIdentifier}/listeners/{listenerIdentifier}";
280
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "serviceIdentifier", () => input.serviceIdentifier, "{serviceIdentifier}", false);
281
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "listenerIdentifier", () => input.listenerIdentifier, "{listenerIdentifier}", false);
198
+ b.bp("/services/{serviceIdentifier}/listeners/{listenerIdentifier}");
199
+ b.p("serviceIdentifier", () => input.serviceIdentifier, "{serviceIdentifier}", false);
200
+ b.p("listenerIdentifier", () => input.listenerIdentifier, "{listenerIdentifier}", false);
282
201
  let body;
283
- return new protocol_http_1.HttpRequest({
284
- protocol,
285
- hostname,
286
- port,
287
- method: "DELETE",
288
- headers,
289
- path: resolvedPath,
290
- body,
291
- });
202
+ b.m("DELETE").h(headers).b(body);
203
+ return b.build();
292
204
  };
293
205
  exports.se_DeleteListenerCommand = se_DeleteListenerCommand;
294
206
  const se_DeleteResourcePolicyCommand = async (input, context) => {
295
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
207
+ const b = (0, core_2.requestBuilder)(input, context);
296
208
  const headers = {};
297
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/resourcepolicy/{resourceArn}";
298
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "resourceArn", () => input.resourceArn, "{resourceArn}", false);
209
+ b.bp("/resourcepolicy/{resourceArn}");
210
+ b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
299
211
  let body;
300
- return new protocol_http_1.HttpRequest({
301
- protocol,
302
- hostname,
303
- port,
304
- method: "DELETE",
305
- headers,
306
- path: resolvedPath,
307
- body,
308
- });
212
+ b.m("DELETE").h(headers).b(body);
213
+ return b.build();
309
214
  };
310
215
  exports.se_DeleteResourcePolicyCommand = se_DeleteResourcePolicyCommand;
311
216
  const se_DeleteRuleCommand = async (input, context) => {
312
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
217
+ const b = (0, core_2.requestBuilder)(input, context);
313
218
  const headers = {};
314
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
315
- "/services/{serviceIdentifier}/listeners/{listenerIdentifier}/rules/{ruleIdentifier}";
316
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "serviceIdentifier", () => input.serviceIdentifier, "{serviceIdentifier}", false);
317
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "listenerIdentifier", () => input.listenerIdentifier, "{listenerIdentifier}", false);
318
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "ruleIdentifier", () => input.ruleIdentifier, "{ruleIdentifier}", false);
219
+ b.bp("/services/{serviceIdentifier}/listeners/{listenerIdentifier}/rules/{ruleIdentifier}");
220
+ b.p("serviceIdentifier", () => input.serviceIdentifier, "{serviceIdentifier}", false);
221
+ b.p("listenerIdentifier", () => input.listenerIdentifier, "{listenerIdentifier}", false);
222
+ b.p("ruleIdentifier", () => input.ruleIdentifier, "{ruleIdentifier}", false);
319
223
  let body;
320
- return new protocol_http_1.HttpRequest({
321
- protocol,
322
- hostname,
323
- port,
324
- method: "DELETE",
325
- headers,
326
- path: resolvedPath,
327
- body,
328
- });
224
+ b.m("DELETE").h(headers).b(body);
225
+ return b.build();
329
226
  };
330
227
  exports.se_DeleteRuleCommand = se_DeleteRuleCommand;
331
228
  const se_DeleteServiceCommand = async (input, context) => {
332
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
229
+ const b = (0, core_2.requestBuilder)(input, context);
333
230
  const headers = {};
334
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/services/{serviceIdentifier}";
335
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "serviceIdentifier", () => input.serviceIdentifier, "{serviceIdentifier}", false);
231
+ b.bp("/services/{serviceIdentifier}");
232
+ b.p("serviceIdentifier", () => input.serviceIdentifier, "{serviceIdentifier}", false);
336
233
  let body;
337
- return new protocol_http_1.HttpRequest({
338
- protocol,
339
- hostname,
340
- port,
341
- method: "DELETE",
342
- headers,
343
- path: resolvedPath,
344
- body,
345
- });
234
+ b.m("DELETE").h(headers).b(body);
235
+ return b.build();
346
236
  };
347
237
  exports.se_DeleteServiceCommand = se_DeleteServiceCommand;
348
238
  const se_DeleteServiceNetworkCommand = async (input, context) => {
349
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
239
+ const b = (0, core_2.requestBuilder)(input, context);
350
240
  const headers = {};
351
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
352
- "/servicenetworks/{serviceNetworkIdentifier}";
353
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "serviceNetworkIdentifier", () => input.serviceNetworkIdentifier, "{serviceNetworkIdentifier}", false);
241
+ b.bp("/servicenetworks/{serviceNetworkIdentifier}");
242
+ b.p("serviceNetworkIdentifier", () => input.serviceNetworkIdentifier, "{serviceNetworkIdentifier}", false);
354
243
  let body;
355
- return new protocol_http_1.HttpRequest({
356
- protocol,
357
- hostname,
358
- port,
359
- method: "DELETE",
360
- headers,
361
- path: resolvedPath,
362
- body,
363
- });
244
+ b.m("DELETE").h(headers).b(body);
245
+ return b.build();
364
246
  };
365
247
  exports.se_DeleteServiceNetworkCommand = se_DeleteServiceNetworkCommand;
366
248
  const se_DeleteServiceNetworkServiceAssociationCommand = async (input, context) => {
367
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
249
+ const b = (0, core_2.requestBuilder)(input, context);
368
250
  const headers = {};
369
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
370
- "/servicenetworkserviceassociations/{serviceNetworkServiceAssociationIdentifier}";
371
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "serviceNetworkServiceAssociationIdentifier", () => input.serviceNetworkServiceAssociationIdentifier, "{serviceNetworkServiceAssociationIdentifier}", false);
251
+ b.bp("/servicenetworkserviceassociations/{serviceNetworkServiceAssociationIdentifier}");
252
+ b.p("serviceNetworkServiceAssociationIdentifier", () => input.serviceNetworkServiceAssociationIdentifier, "{serviceNetworkServiceAssociationIdentifier}", false);
372
253
  let body;
373
- return new protocol_http_1.HttpRequest({
374
- protocol,
375
- hostname,
376
- port,
377
- method: "DELETE",
378
- headers,
379
- path: resolvedPath,
380
- body,
381
- });
254
+ b.m("DELETE").h(headers).b(body);
255
+ return b.build();
382
256
  };
383
257
  exports.se_DeleteServiceNetworkServiceAssociationCommand = se_DeleteServiceNetworkServiceAssociationCommand;
384
258
  const se_DeleteServiceNetworkVpcAssociationCommand = async (input, context) => {
385
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
259
+ const b = (0, core_2.requestBuilder)(input, context);
386
260
  const headers = {};
387
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
388
- "/servicenetworkvpcassociations/{serviceNetworkVpcAssociationIdentifier}";
389
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "serviceNetworkVpcAssociationIdentifier", () => input.serviceNetworkVpcAssociationIdentifier, "{serviceNetworkVpcAssociationIdentifier}", false);
261
+ b.bp("/servicenetworkvpcassociations/{serviceNetworkVpcAssociationIdentifier}");
262
+ b.p("serviceNetworkVpcAssociationIdentifier", () => input.serviceNetworkVpcAssociationIdentifier, "{serviceNetworkVpcAssociationIdentifier}", false);
390
263
  let body;
391
- return new protocol_http_1.HttpRequest({
392
- protocol,
393
- hostname,
394
- port,
395
- method: "DELETE",
396
- headers,
397
- path: resolvedPath,
398
- body,
399
- });
264
+ b.m("DELETE").h(headers).b(body);
265
+ return b.build();
400
266
  };
401
267
  exports.se_DeleteServiceNetworkVpcAssociationCommand = se_DeleteServiceNetworkVpcAssociationCommand;
402
268
  const se_DeleteTargetGroupCommand = async (input, context) => {
403
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
269
+ const b = (0, core_2.requestBuilder)(input, context);
404
270
  const headers = {};
405
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/targetgroups/{targetGroupIdentifier}";
406
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "targetGroupIdentifier", () => input.targetGroupIdentifier, "{targetGroupIdentifier}", false);
271
+ b.bp("/targetgroups/{targetGroupIdentifier}");
272
+ b.p("targetGroupIdentifier", () => input.targetGroupIdentifier, "{targetGroupIdentifier}", false);
407
273
  let body;
408
- return new protocol_http_1.HttpRequest({
409
- protocol,
410
- hostname,
411
- port,
412
- method: "DELETE",
413
- headers,
414
- path: resolvedPath,
415
- body,
416
- });
274
+ b.m("DELETE").h(headers).b(body);
275
+ return b.build();
417
276
  };
418
277
  exports.se_DeleteTargetGroupCommand = se_DeleteTargetGroupCommand;
419
278
  const se_DeregisterTargetsCommand = async (input, context) => {
420
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
279
+ const b = (0, core_2.requestBuilder)(input, context);
421
280
  const headers = {
422
281
  "content-type": "application/json",
423
282
  };
424
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
425
- "/targetgroups/{targetGroupIdentifier}/deregistertargets";
426
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "targetGroupIdentifier", () => input.targetGroupIdentifier, "{targetGroupIdentifier}", false);
283
+ b.bp("/targetgroups/{targetGroupIdentifier}/deregistertargets");
284
+ b.p("targetGroupIdentifier", () => input.targetGroupIdentifier, "{targetGroupIdentifier}", false);
427
285
  let body;
428
286
  body = JSON.stringify((0, smithy_client_1.take)(input, {
429
287
  targets: (_) => (0, smithy_client_1._json)(_),
430
288
  }));
431
- return new protocol_http_1.HttpRequest({
432
- protocol,
433
- hostname,
434
- port,
435
- method: "POST",
436
- headers,
437
- path: resolvedPath,
438
- body,
439
- });
289
+ b.m("POST").h(headers).b(body);
290
+ return b.build();
440
291
  };
441
292
  exports.se_DeregisterTargetsCommand = se_DeregisterTargetsCommand;
442
293
  const se_GetAccessLogSubscriptionCommand = async (input, context) => {
443
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
294
+ const b = (0, core_2.requestBuilder)(input, context);
444
295
  const headers = {};
445
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
446
- "/accesslogsubscriptions/{accessLogSubscriptionIdentifier}";
447
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "accessLogSubscriptionIdentifier", () => input.accessLogSubscriptionIdentifier, "{accessLogSubscriptionIdentifier}", false);
296
+ b.bp("/accesslogsubscriptions/{accessLogSubscriptionIdentifier}");
297
+ b.p("accessLogSubscriptionIdentifier", () => input.accessLogSubscriptionIdentifier, "{accessLogSubscriptionIdentifier}", false);
448
298
  let body;
449
- return new protocol_http_1.HttpRequest({
450
- protocol,
451
- hostname,
452
- port,
453
- method: "GET",
454
- headers,
455
- path: resolvedPath,
456
- body,
457
- });
299
+ b.m("GET").h(headers).b(body);
300
+ return b.build();
458
301
  };
459
302
  exports.se_GetAccessLogSubscriptionCommand = se_GetAccessLogSubscriptionCommand;
460
303
  const se_GetAuthPolicyCommand = async (input, context) => {
461
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
304
+ const b = (0, core_2.requestBuilder)(input, context);
462
305
  const headers = {};
463
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/authpolicy/{resourceIdentifier}";
464
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "resourceIdentifier", () => input.resourceIdentifier, "{resourceIdentifier}", false);
306
+ b.bp("/authpolicy/{resourceIdentifier}");
307
+ b.p("resourceIdentifier", () => input.resourceIdentifier, "{resourceIdentifier}", false);
465
308
  let body;
466
- return new protocol_http_1.HttpRequest({
467
- protocol,
468
- hostname,
469
- port,
470
- method: "GET",
471
- headers,
472
- path: resolvedPath,
473
- body,
474
- });
309
+ b.m("GET").h(headers).b(body);
310
+ return b.build();
475
311
  };
476
312
  exports.se_GetAuthPolicyCommand = se_GetAuthPolicyCommand;
477
313
  const se_GetListenerCommand = async (input, context) => {
478
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
314
+ const b = (0, core_2.requestBuilder)(input, context);
479
315
  const headers = {};
480
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
481
- "/services/{serviceIdentifier}/listeners/{listenerIdentifier}";
482
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "serviceIdentifier", () => input.serviceIdentifier, "{serviceIdentifier}", false);
483
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "listenerIdentifier", () => input.listenerIdentifier, "{listenerIdentifier}", false);
316
+ b.bp("/services/{serviceIdentifier}/listeners/{listenerIdentifier}");
317
+ b.p("serviceIdentifier", () => input.serviceIdentifier, "{serviceIdentifier}", false);
318
+ b.p("listenerIdentifier", () => input.listenerIdentifier, "{listenerIdentifier}", false);
484
319
  let body;
485
- return new protocol_http_1.HttpRequest({
486
- protocol,
487
- hostname,
488
- port,
489
- method: "GET",
490
- headers,
491
- path: resolvedPath,
492
- body,
493
- });
320
+ b.m("GET").h(headers).b(body);
321
+ return b.build();
494
322
  };
495
323
  exports.se_GetListenerCommand = se_GetListenerCommand;
496
324
  const se_GetResourcePolicyCommand = async (input, context) => {
497
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
325
+ const b = (0, core_2.requestBuilder)(input, context);
498
326
  const headers = {};
499
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/resourcepolicy/{resourceArn}";
500
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "resourceArn", () => input.resourceArn, "{resourceArn}", false);
327
+ b.bp("/resourcepolicy/{resourceArn}");
328
+ b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
501
329
  let body;
502
- return new protocol_http_1.HttpRequest({
503
- protocol,
504
- hostname,
505
- port,
506
- method: "GET",
507
- headers,
508
- path: resolvedPath,
509
- body,
510
- });
330
+ b.m("GET").h(headers).b(body);
331
+ return b.build();
511
332
  };
512
333
  exports.se_GetResourcePolicyCommand = se_GetResourcePolicyCommand;
513
334
  const se_GetRuleCommand = async (input, context) => {
514
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
335
+ const b = (0, core_2.requestBuilder)(input, context);
515
336
  const headers = {};
516
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
517
- "/services/{serviceIdentifier}/listeners/{listenerIdentifier}/rules/{ruleIdentifier}";
518
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "serviceIdentifier", () => input.serviceIdentifier, "{serviceIdentifier}", false);
519
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "listenerIdentifier", () => input.listenerIdentifier, "{listenerIdentifier}", false);
520
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "ruleIdentifier", () => input.ruleIdentifier, "{ruleIdentifier}", false);
337
+ b.bp("/services/{serviceIdentifier}/listeners/{listenerIdentifier}/rules/{ruleIdentifier}");
338
+ b.p("serviceIdentifier", () => input.serviceIdentifier, "{serviceIdentifier}", false);
339
+ b.p("listenerIdentifier", () => input.listenerIdentifier, "{listenerIdentifier}", false);
340
+ b.p("ruleIdentifier", () => input.ruleIdentifier, "{ruleIdentifier}", false);
521
341
  let body;
522
- return new protocol_http_1.HttpRequest({
523
- protocol,
524
- hostname,
525
- port,
526
- method: "GET",
527
- headers,
528
- path: resolvedPath,
529
- body,
530
- });
342
+ b.m("GET").h(headers).b(body);
343
+ return b.build();
531
344
  };
532
345
  exports.se_GetRuleCommand = se_GetRuleCommand;
533
346
  const se_GetServiceCommand = async (input, context) => {
534
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
347
+ const b = (0, core_2.requestBuilder)(input, context);
535
348
  const headers = {};
536
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/services/{serviceIdentifier}";
537
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "serviceIdentifier", () => input.serviceIdentifier, "{serviceIdentifier}", false);
349
+ b.bp("/services/{serviceIdentifier}");
350
+ b.p("serviceIdentifier", () => input.serviceIdentifier, "{serviceIdentifier}", false);
538
351
  let body;
539
- return new protocol_http_1.HttpRequest({
540
- protocol,
541
- hostname,
542
- port,
543
- method: "GET",
544
- headers,
545
- path: resolvedPath,
546
- body,
547
- });
352
+ b.m("GET").h(headers).b(body);
353
+ return b.build();
548
354
  };
549
355
  exports.se_GetServiceCommand = se_GetServiceCommand;
550
356
  const se_GetServiceNetworkCommand = async (input, context) => {
551
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
357
+ const b = (0, core_2.requestBuilder)(input, context);
552
358
  const headers = {};
553
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
554
- "/servicenetworks/{serviceNetworkIdentifier}";
555
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "serviceNetworkIdentifier", () => input.serviceNetworkIdentifier, "{serviceNetworkIdentifier}", false);
359
+ b.bp("/servicenetworks/{serviceNetworkIdentifier}");
360
+ b.p("serviceNetworkIdentifier", () => input.serviceNetworkIdentifier, "{serviceNetworkIdentifier}", false);
556
361
  let body;
557
- return new protocol_http_1.HttpRequest({
558
- protocol,
559
- hostname,
560
- port,
561
- method: "GET",
562
- headers,
563
- path: resolvedPath,
564
- body,
565
- });
362
+ b.m("GET").h(headers).b(body);
363
+ return b.build();
566
364
  };
567
365
  exports.se_GetServiceNetworkCommand = se_GetServiceNetworkCommand;
568
366
  const se_GetServiceNetworkServiceAssociationCommand = async (input, context) => {
569
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
367
+ const b = (0, core_2.requestBuilder)(input, context);
570
368
  const headers = {};
571
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
572
- "/servicenetworkserviceassociations/{serviceNetworkServiceAssociationIdentifier}";
573
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "serviceNetworkServiceAssociationIdentifier", () => input.serviceNetworkServiceAssociationIdentifier, "{serviceNetworkServiceAssociationIdentifier}", false);
369
+ b.bp("/servicenetworkserviceassociations/{serviceNetworkServiceAssociationIdentifier}");
370
+ b.p("serviceNetworkServiceAssociationIdentifier", () => input.serviceNetworkServiceAssociationIdentifier, "{serviceNetworkServiceAssociationIdentifier}", false);
574
371
  let body;
575
- return new protocol_http_1.HttpRequest({
576
- protocol,
577
- hostname,
578
- port,
579
- method: "GET",
580
- headers,
581
- path: resolvedPath,
582
- body,
583
- });
372
+ b.m("GET").h(headers).b(body);
373
+ return b.build();
584
374
  };
585
375
  exports.se_GetServiceNetworkServiceAssociationCommand = se_GetServiceNetworkServiceAssociationCommand;
586
376
  const se_GetServiceNetworkVpcAssociationCommand = async (input, context) => {
587
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
377
+ const b = (0, core_2.requestBuilder)(input, context);
588
378
  const headers = {};
589
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
590
- "/servicenetworkvpcassociations/{serviceNetworkVpcAssociationIdentifier}";
591
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "serviceNetworkVpcAssociationIdentifier", () => input.serviceNetworkVpcAssociationIdentifier, "{serviceNetworkVpcAssociationIdentifier}", false);
379
+ b.bp("/servicenetworkvpcassociations/{serviceNetworkVpcAssociationIdentifier}");
380
+ b.p("serviceNetworkVpcAssociationIdentifier", () => input.serviceNetworkVpcAssociationIdentifier, "{serviceNetworkVpcAssociationIdentifier}", false);
592
381
  let body;
593
- return new protocol_http_1.HttpRequest({
594
- protocol,
595
- hostname,
596
- port,
597
- method: "GET",
598
- headers,
599
- path: resolvedPath,
600
- body,
601
- });
382
+ b.m("GET").h(headers).b(body);
383
+ return b.build();
602
384
  };
603
385
  exports.se_GetServiceNetworkVpcAssociationCommand = se_GetServiceNetworkVpcAssociationCommand;
604
386
  const se_GetTargetGroupCommand = async (input, context) => {
605
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
387
+ const b = (0, core_2.requestBuilder)(input, context);
606
388
  const headers = {};
607
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/targetgroups/{targetGroupIdentifier}";
608
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "targetGroupIdentifier", () => input.targetGroupIdentifier, "{targetGroupIdentifier}", false);
389
+ b.bp("/targetgroups/{targetGroupIdentifier}");
390
+ b.p("targetGroupIdentifier", () => input.targetGroupIdentifier, "{targetGroupIdentifier}", false);
609
391
  let body;
610
- return new protocol_http_1.HttpRequest({
611
- protocol,
612
- hostname,
613
- port,
614
- method: "GET",
615
- headers,
616
- path: resolvedPath,
617
- body,
618
- });
392
+ b.m("GET").h(headers).b(body);
393
+ return b.build();
619
394
  };
620
395
  exports.se_GetTargetGroupCommand = se_GetTargetGroupCommand;
621
396
  const se_ListAccessLogSubscriptionsCommand = async (input, context) => {
622
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
397
+ const b = (0, core_2.requestBuilder)(input, context);
623
398
  const headers = {};
624
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/accesslogsubscriptions";
399
+ b.bp("/accesslogsubscriptions");
625
400
  const query = (0, smithy_client_1.map)({
626
- resourceIdentifier: [, (0, smithy_client_1.expectNonNull)(input.resourceIdentifier, `resourceIdentifier`)],
627
- maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
628
- nextToken: [, input.nextToken],
401
+ [_rI]: [, (0, smithy_client_1.expectNonNull)(input[_rI], `resourceIdentifier`)],
402
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
403
+ [_nT]: [, input[_nT]],
629
404
  });
630
405
  let body;
631
- return new protocol_http_1.HttpRequest({
632
- protocol,
633
- hostname,
634
- port,
635
- method: "GET",
636
- headers,
637
- path: resolvedPath,
638
- query,
639
- body,
640
- });
406
+ b.m("GET").h(headers).q(query).b(body);
407
+ return b.build();
641
408
  };
642
409
  exports.se_ListAccessLogSubscriptionsCommand = se_ListAccessLogSubscriptionsCommand;
643
410
  const se_ListListenersCommand = async (input, context) => {
644
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
411
+ const b = (0, core_2.requestBuilder)(input, context);
645
412
  const headers = {};
646
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/services/{serviceIdentifier}/listeners";
647
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "serviceIdentifier", () => input.serviceIdentifier, "{serviceIdentifier}", false);
413
+ b.bp("/services/{serviceIdentifier}/listeners");
414
+ b.p("serviceIdentifier", () => input.serviceIdentifier, "{serviceIdentifier}", false);
648
415
  const query = (0, smithy_client_1.map)({
649
- maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
650
- nextToken: [, input.nextToken],
416
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
417
+ [_nT]: [, input[_nT]],
651
418
  });
652
419
  let body;
653
- return new protocol_http_1.HttpRequest({
654
- protocol,
655
- hostname,
656
- port,
657
- method: "GET",
658
- headers,
659
- path: resolvedPath,
660
- query,
661
- body,
662
- });
420
+ b.m("GET").h(headers).q(query).b(body);
421
+ return b.build();
663
422
  };
664
423
  exports.se_ListListenersCommand = se_ListListenersCommand;
665
424
  const se_ListRulesCommand = async (input, context) => {
666
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
425
+ const b = (0, core_2.requestBuilder)(input, context);
667
426
  const headers = {};
668
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
669
- "/services/{serviceIdentifier}/listeners/{listenerIdentifier}/rules";
670
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "serviceIdentifier", () => input.serviceIdentifier, "{serviceIdentifier}", false);
671
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "listenerIdentifier", () => input.listenerIdentifier, "{listenerIdentifier}", false);
427
+ b.bp("/services/{serviceIdentifier}/listeners/{listenerIdentifier}/rules");
428
+ b.p("serviceIdentifier", () => input.serviceIdentifier, "{serviceIdentifier}", false);
429
+ b.p("listenerIdentifier", () => input.listenerIdentifier, "{listenerIdentifier}", false);
672
430
  const query = (0, smithy_client_1.map)({
673
- maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
674
- nextToken: [, input.nextToken],
431
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
432
+ [_nT]: [, input[_nT]],
675
433
  });
676
434
  let body;
677
- return new protocol_http_1.HttpRequest({
678
- protocol,
679
- hostname,
680
- port,
681
- method: "GET",
682
- headers,
683
- path: resolvedPath,
684
- query,
685
- body,
686
- });
435
+ b.m("GET").h(headers).q(query).b(body);
436
+ return b.build();
687
437
  };
688
438
  exports.se_ListRulesCommand = se_ListRulesCommand;
689
439
  const se_ListServiceNetworksCommand = async (input, context) => {
690
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
440
+ const b = (0, core_2.requestBuilder)(input, context);
691
441
  const headers = {};
692
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/servicenetworks";
442
+ b.bp("/servicenetworks");
693
443
  const query = (0, smithy_client_1.map)({
694
- maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
695
- nextToken: [, input.nextToken],
444
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
445
+ [_nT]: [, input[_nT]],
696
446
  });
697
447
  let body;
698
- return new protocol_http_1.HttpRequest({
699
- protocol,
700
- hostname,
701
- port,
702
- method: "GET",
703
- headers,
704
- path: resolvedPath,
705
- query,
706
- body,
707
- });
448
+ b.m("GET").h(headers).q(query).b(body);
449
+ return b.build();
708
450
  };
709
451
  exports.se_ListServiceNetworksCommand = se_ListServiceNetworksCommand;
710
452
  const se_ListServiceNetworkServiceAssociationsCommand = async (input, context) => {
711
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
453
+ const b = (0, core_2.requestBuilder)(input, context);
712
454
  const headers = {};
713
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/servicenetworkserviceassociations";
455
+ b.bp("/servicenetworkserviceassociations");
714
456
  const query = (0, smithy_client_1.map)({
715
- serviceNetworkIdentifier: [, input.serviceNetworkIdentifier],
716
- serviceIdentifier: [, input.serviceIdentifier],
717
- maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
718
- nextToken: [, input.nextToken],
457
+ [_sNI]: [, input[_sNI]],
458
+ [_sI]: [, input[_sI]],
459
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
460
+ [_nT]: [, input[_nT]],
719
461
  });
720
462
  let body;
721
- return new protocol_http_1.HttpRequest({
722
- protocol,
723
- hostname,
724
- port,
725
- method: "GET",
726
- headers,
727
- path: resolvedPath,
728
- query,
729
- body,
730
- });
463
+ b.m("GET").h(headers).q(query).b(body);
464
+ return b.build();
731
465
  };
732
466
  exports.se_ListServiceNetworkServiceAssociationsCommand = se_ListServiceNetworkServiceAssociationsCommand;
733
467
  const se_ListServiceNetworkVpcAssociationsCommand = async (input, context) => {
734
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
468
+ const b = (0, core_2.requestBuilder)(input, context);
735
469
  const headers = {};
736
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/servicenetworkvpcassociations";
470
+ b.bp("/servicenetworkvpcassociations");
737
471
  const query = (0, smithy_client_1.map)({
738
- serviceNetworkIdentifier: [, input.serviceNetworkIdentifier],
739
- vpcIdentifier: [, input.vpcIdentifier],
740
- maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
741
- nextToken: [, input.nextToken],
472
+ [_sNI]: [, input[_sNI]],
473
+ [_vI]: [, input[_vI]],
474
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
475
+ [_nT]: [, input[_nT]],
742
476
  });
743
477
  let body;
744
- return new protocol_http_1.HttpRequest({
745
- protocol,
746
- hostname,
747
- port,
748
- method: "GET",
749
- headers,
750
- path: resolvedPath,
751
- query,
752
- body,
753
- });
478
+ b.m("GET").h(headers).q(query).b(body);
479
+ return b.build();
754
480
  };
755
481
  exports.se_ListServiceNetworkVpcAssociationsCommand = se_ListServiceNetworkVpcAssociationsCommand;
756
482
  const se_ListServicesCommand = async (input, context) => {
757
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
483
+ const b = (0, core_2.requestBuilder)(input, context);
758
484
  const headers = {};
759
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/services";
485
+ b.bp("/services");
760
486
  const query = (0, smithy_client_1.map)({
761
- maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
762
- nextToken: [, input.nextToken],
487
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
488
+ [_nT]: [, input[_nT]],
763
489
  });
764
490
  let body;
765
- return new protocol_http_1.HttpRequest({
766
- protocol,
767
- hostname,
768
- port,
769
- method: "GET",
770
- headers,
771
- path: resolvedPath,
772
- query,
773
- body,
774
- });
491
+ b.m("GET").h(headers).q(query).b(body);
492
+ return b.build();
775
493
  };
776
494
  exports.se_ListServicesCommand = se_ListServicesCommand;
777
495
  const se_ListTagsForResourceCommand = async (input, context) => {
778
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
496
+ const b = (0, core_2.requestBuilder)(input, context);
779
497
  const headers = {};
780
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{resourceArn}";
781
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "resourceArn", () => input.resourceArn, "{resourceArn}", false);
498
+ b.bp("/tags/{resourceArn}");
499
+ b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
782
500
  let body;
783
- return new protocol_http_1.HttpRequest({
784
- protocol,
785
- hostname,
786
- port,
787
- method: "GET",
788
- headers,
789
- path: resolvedPath,
790
- body,
791
- });
501
+ b.m("GET").h(headers).b(body);
502
+ return b.build();
792
503
  };
793
504
  exports.se_ListTagsForResourceCommand = se_ListTagsForResourceCommand;
794
505
  const se_ListTargetGroupsCommand = async (input, context) => {
795
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
506
+ const b = (0, core_2.requestBuilder)(input, context);
796
507
  const headers = {};
797
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/targetgroups";
508
+ b.bp("/targetgroups");
798
509
  const query = (0, smithy_client_1.map)({
799
- maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
800
- nextToken: [, input.nextToken],
801
- vpcIdentifier: [, input.vpcIdentifier],
802
- targetGroupType: [, input.targetGroupType],
510
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
511
+ [_nT]: [, input[_nT]],
512
+ [_vI]: [, input[_vI]],
513
+ [_tGT]: [, input[_tGT]],
803
514
  });
804
515
  let body;
805
- return new protocol_http_1.HttpRequest({
806
- protocol,
807
- hostname,
808
- port,
809
- method: "GET",
810
- headers,
811
- path: resolvedPath,
812
- query,
813
- body,
814
- });
516
+ b.m("GET").h(headers).q(query).b(body);
517
+ return b.build();
815
518
  };
816
519
  exports.se_ListTargetGroupsCommand = se_ListTargetGroupsCommand;
817
520
  const se_ListTargetsCommand = async (input, context) => {
818
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
521
+ const b = (0, core_2.requestBuilder)(input, context);
819
522
  const headers = {
820
523
  "content-type": "application/json",
821
524
  };
822
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
823
- "/targetgroups/{targetGroupIdentifier}/listtargets";
824
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "targetGroupIdentifier", () => input.targetGroupIdentifier, "{targetGroupIdentifier}", false);
525
+ b.bp("/targetgroups/{targetGroupIdentifier}/listtargets");
526
+ b.p("targetGroupIdentifier", () => input.targetGroupIdentifier, "{targetGroupIdentifier}", false);
825
527
  const query = (0, smithy_client_1.map)({
826
- maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
827
- nextToken: [, input.nextToken],
528
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
529
+ [_nT]: [, input[_nT]],
828
530
  });
829
531
  let body;
830
532
  body = JSON.stringify((0, smithy_client_1.take)(input, {
831
533
  targets: (_) => (0, smithy_client_1._json)(_),
832
534
  }));
833
- return new protocol_http_1.HttpRequest({
834
- protocol,
835
- hostname,
836
- port,
837
- method: "POST",
838
- headers,
839
- path: resolvedPath,
840
- query,
841
- body,
842
- });
535
+ b.m("POST").h(headers).q(query).b(body);
536
+ return b.build();
843
537
  };
844
538
  exports.se_ListTargetsCommand = se_ListTargetsCommand;
845
539
  const se_PutAuthPolicyCommand = async (input, context) => {
846
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
540
+ const b = (0, core_2.requestBuilder)(input, context);
847
541
  const headers = {
848
542
  "content-type": "application/json",
849
543
  };
850
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/authpolicy/{resourceIdentifier}";
851
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "resourceIdentifier", () => input.resourceIdentifier, "{resourceIdentifier}", false);
544
+ b.bp("/authpolicy/{resourceIdentifier}");
545
+ b.p("resourceIdentifier", () => input.resourceIdentifier, "{resourceIdentifier}", false);
852
546
  let body;
853
547
  body = JSON.stringify((0, smithy_client_1.take)(input, {
854
548
  policy: [],
855
549
  }));
856
- return new protocol_http_1.HttpRequest({
857
- protocol,
858
- hostname,
859
- port,
860
- method: "PUT",
861
- headers,
862
- path: resolvedPath,
863
- body,
864
- });
550
+ b.m("PUT").h(headers).b(body);
551
+ return b.build();
865
552
  };
866
553
  exports.se_PutAuthPolicyCommand = se_PutAuthPolicyCommand;
867
554
  const se_PutResourcePolicyCommand = async (input, context) => {
868
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
555
+ const b = (0, core_2.requestBuilder)(input, context);
869
556
  const headers = {
870
557
  "content-type": "application/json",
871
558
  };
872
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/resourcepolicy/{resourceArn}";
873
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "resourceArn", () => input.resourceArn, "{resourceArn}", false);
559
+ b.bp("/resourcepolicy/{resourceArn}");
560
+ b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
874
561
  let body;
875
562
  body = JSON.stringify((0, smithy_client_1.take)(input, {
876
563
  policy: [],
877
564
  }));
878
- return new protocol_http_1.HttpRequest({
879
- protocol,
880
- hostname,
881
- port,
882
- method: "PUT",
883
- headers,
884
- path: resolvedPath,
885
- body,
886
- });
565
+ b.m("PUT").h(headers).b(body);
566
+ return b.build();
887
567
  };
888
568
  exports.se_PutResourcePolicyCommand = se_PutResourcePolicyCommand;
889
569
  const se_RegisterTargetsCommand = async (input, context) => {
890
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
570
+ const b = (0, core_2.requestBuilder)(input, context);
891
571
  const headers = {
892
572
  "content-type": "application/json",
893
573
  };
894
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
895
- "/targetgroups/{targetGroupIdentifier}/registertargets";
896
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "targetGroupIdentifier", () => input.targetGroupIdentifier, "{targetGroupIdentifier}", false);
574
+ b.bp("/targetgroups/{targetGroupIdentifier}/registertargets");
575
+ b.p("targetGroupIdentifier", () => input.targetGroupIdentifier, "{targetGroupIdentifier}", false);
897
576
  let body;
898
577
  body = JSON.stringify((0, smithy_client_1.take)(input, {
899
578
  targets: (_) => (0, smithy_client_1._json)(_),
900
579
  }));
901
- return new protocol_http_1.HttpRequest({
902
- protocol,
903
- hostname,
904
- port,
905
- method: "POST",
906
- headers,
907
- path: resolvedPath,
908
- body,
909
- });
580
+ b.m("POST").h(headers).b(body);
581
+ return b.build();
910
582
  };
911
583
  exports.se_RegisterTargetsCommand = se_RegisterTargetsCommand;
912
584
  const se_TagResourceCommand = async (input, context) => {
913
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
585
+ const b = (0, core_2.requestBuilder)(input, context);
914
586
  const headers = {
915
587
  "content-type": "application/json",
916
588
  };
917
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{resourceArn}";
918
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "resourceArn", () => input.resourceArn, "{resourceArn}", false);
589
+ b.bp("/tags/{resourceArn}");
590
+ b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
919
591
  let body;
920
592
  body = JSON.stringify((0, smithy_client_1.take)(input, {
921
593
  tags: (_) => (0, smithy_client_1._json)(_),
922
594
  }));
923
- return new protocol_http_1.HttpRequest({
924
- protocol,
925
- hostname,
926
- port,
927
- method: "POST",
928
- headers,
929
- path: resolvedPath,
930
- body,
931
- });
595
+ b.m("POST").h(headers).b(body);
596
+ return b.build();
932
597
  };
933
598
  exports.se_TagResourceCommand = se_TagResourceCommand;
934
599
  const se_UntagResourceCommand = async (input, context) => {
935
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
600
+ const b = (0, core_2.requestBuilder)(input, context);
936
601
  const headers = {};
937
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{resourceArn}";
938
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "resourceArn", () => input.resourceArn, "{resourceArn}", false);
602
+ b.bp("/tags/{resourceArn}");
603
+ b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
939
604
  const query = (0, smithy_client_1.map)({
940
- tagKeys: [
605
+ [_tK]: [
941
606
  (0, smithy_client_1.expectNonNull)(input.tagKeys, `tagKeys`) != null,
942
- () => (input.tagKeys || []).map((_entry) => _entry),
607
+ () => (input[_tK] || []).map((_entry) => _entry),
943
608
  ],
944
609
  });
945
610
  let body;
946
- return new protocol_http_1.HttpRequest({
947
- protocol,
948
- hostname,
949
- port,
950
- method: "DELETE",
951
- headers,
952
- path: resolvedPath,
953
- query,
954
- body,
955
- });
611
+ b.m("DELETE").h(headers).q(query).b(body);
612
+ return b.build();
956
613
  };
957
614
  exports.se_UntagResourceCommand = se_UntagResourceCommand;
958
615
  const se_UpdateAccessLogSubscriptionCommand = async (input, context) => {
959
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
616
+ const b = (0, core_2.requestBuilder)(input, context);
960
617
  const headers = {
961
618
  "content-type": "application/json",
962
619
  };
963
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
964
- "/accesslogsubscriptions/{accessLogSubscriptionIdentifier}";
965
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "accessLogSubscriptionIdentifier", () => input.accessLogSubscriptionIdentifier, "{accessLogSubscriptionIdentifier}", false);
620
+ b.bp("/accesslogsubscriptions/{accessLogSubscriptionIdentifier}");
621
+ b.p("accessLogSubscriptionIdentifier", () => input.accessLogSubscriptionIdentifier, "{accessLogSubscriptionIdentifier}", false);
966
622
  let body;
967
623
  body = JSON.stringify((0, smithy_client_1.take)(input, {
968
624
  destinationArn: [],
969
625
  }));
970
- return new protocol_http_1.HttpRequest({
971
- protocol,
972
- hostname,
973
- port,
974
- method: "PATCH",
975
- headers,
976
- path: resolvedPath,
977
- body,
978
- });
626
+ b.m("PATCH").h(headers).b(body);
627
+ return b.build();
979
628
  };
980
629
  exports.se_UpdateAccessLogSubscriptionCommand = se_UpdateAccessLogSubscriptionCommand;
981
630
  const se_UpdateListenerCommand = async (input, context) => {
982
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
631
+ const b = (0, core_2.requestBuilder)(input, context);
983
632
  const headers = {
984
633
  "content-type": "application/json",
985
634
  };
986
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
987
- "/services/{serviceIdentifier}/listeners/{listenerIdentifier}";
988
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "serviceIdentifier", () => input.serviceIdentifier, "{serviceIdentifier}", false);
989
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "listenerIdentifier", () => input.listenerIdentifier, "{listenerIdentifier}", false);
635
+ b.bp("/services/{serviceIdentifier}/listeners/{listenerIdentifier}");
636
+ b.p("serviceIdentifier", () => input.serviceIdentifier, "{serviceIdentifier}", false);
637
+ b.p("listenerIdentifier", () => input.listenerIdentifier, "{listenerIdentifier}", false);
990
638
  let body;
991
639
  body = JSON.stringify((0, smithy_client_1.take)(input, {
992
640
  defaultAction: (_) => (0, smithy_client_1._json)(_),
993
641
  }));
994
- return new protocol_http_1.HttpRequest({
995
- protocol,
996
- hostname,
997
- port,
998
- method: "PATCH",
999
- headers,
1000
- path: resolvedPath,
1001
- body,
1002
- });
642
+ b.m("PATCH").h(headers).b(body);
643
+ return b.build();
1003
644
  };
1004
645
  exports.se_UpdateListenerCommand = se_UpdateListenerCommand;
1005
646
  const se_UpdateRuleCommand = async (input, context) => {
1006
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
647
+ const b = (0, core_2.requestBuilder)(input, context);
1007
648
  const headers = {
1008
649
  "content-type": "application/json",
1009
650
  };
1010
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1011
- "/services/{serviceIdentifier}/listeners/{listenerIdentifier}/rules/{ruleIdentifier}";
1012
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "serviceIdentifier", () => input.serviceIdentifier, "{serviceIdentifier}", false);
1013
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "listenerIdentifier", () => input.listenerIdentifier, "{listenerIdentifier}", false);
1014
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "ruleIdentifier", () => input.ruleIdentifier, "{ruleIdentifier}", false);
651
+ b.bp("/services/{serviceIdentifier}/listeners/{listenerIdentifier}/rules/{ruleIdentifier}");
652
+ b.p("serviceIdentifier", () => input.serviceIdentifier, "{serviceIdentifier}", false);
653
+ b.p("listenerIdentifier", () => input.listenerIdentifier, "{listenerIdentifier}", false);
654
+ b.p("ruleIdentifier", () => input.ruleIdentifier, "{ruleIdentifier}", false);
1015
655
  let body;
1016
656
  body = JSON.stringify((0, smithy_client_1.take)(input, {
1017
657
  action: (_) => (0, smithy_client_1._json)(_),
1018
658
  match: (_) => (0, smithy_client_1._json)(_),
1019
659
  priority: [],
1020
660
  }));
1021
- return new protocol_http_1.HttpRequest({
1022
- protocol,
1023
- hostname,
1024
- port,
1025
- method: "PATCH",
1026
- headers,
1027
- path: resolvedPath,
1028
- body,
1029
- });
661
+ b.m("PATCH").h(headers).b(body);
662
+ return b.build();
1030
663
  };
1031
664
  exports.se_UpdateRuleCommand = se_UpdateRuleCommand;
1032
665
  const se_UpdateServiceCommand = async (input, context) => {
1033
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
666
+ const b = (0, core_2.requestBuilder)(input, context);
1034
667
  const headers = {
1035
668
  "content-type": "application/json",
1036
669
  };
1037
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/services/{serviceIdentifier}";
1038
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "serviceIdentifier", () => input.serviceIdentifier, "{serviceIdentifier}", false);
670
+ b.bp("/services/{serviceIdentifier}");
671
+ b.p("serviceIdentifier", () => input.serviceIdentifier, "{serviceIdentifier}", false);
1039
672
  let body;
1040
673
  body = JSON.stringify((0, smithy_client_1.take)(input, {
1041
674
  authType: [],
1042
675
  certificateArn: [],
1043
676
  }));
1044
- return new protocol_http_1.HttpRequest({
1045
- protocol,
1046
- hostname,
1047
- port,
1048
- method: "PATCH",
1049
- headers,
1050
- path: resolvedPath,
1051
- body,
1052
- });
677
+ b.m("PATCH").h(headers).b(body);
678
+ return b.build();
1053
679
  };
1054
680
  exports.se_UpdateServiceCommand = se_UpdateServiceCommand;
1055
681
  const se_UpdateServiceNetworkCommand = async (input, context) => {
1056
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
682
+ const b = (0, core_2.requestBuilder)(input, context);
1057
683
  const headers = {
1058
684
  "content-type": "application/json",
1059
685
  };
1060
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1061
- "/servicenetworks/{serviceNetworkIdentifier}";
1062
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "serviceNetworkIdentifier", () => input.serviceNetworkIdentifier, "{serviceNetworkIdentifier}", false);
686
+ b.bp("/servicenetworks/{serviceNetworkIdentifier}");
687
+ b.p("serviceNetworkIdentifier", () => input.serviceNetworkIdentifier, "{serviceNetworkIdentifier}", false);
1063
688
  let body;
1064
689
  body = JSON.stringify((0, smithy_client_1.take)(input, {
1065
690
  authType: [],
1066
691
  }));
1067
- return new protocol_http_1.HttpRequest({
1068
- protocol,
1069
- hostname,
1070
- port,
1071
- method: "PATCH",
1072
- headers,
1073
- path: resolvedPath,
1074
- body,
1075
- });
692
+ b.m("PATCH").h(headers).b(body);
693
+ return b.build();
1076
694
  };
1077
695
  exports.se_UpdateServiceNetworkCommand = se_UpdateServiceNetworkCommand;
1078
696
  const se_UpdateServiceNetworkVpcAssociationCommand = async (input, context) => {
1079
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
697
+ const b = (0, core_2.requestBuilder)(input, context);
1080
698
  const headers = {
1081
699
  "content-type": "application/json",
1082
700
  };
1083
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1084
- "/servicenetworkvpcassociations/{serviceNetworkVpcAssociationIdentifier}";
1085
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "serviceNetworkVpcAssociationIdentifier", () => input.serviceNetworkVpcAssociationIdentifier, "{serviceNetworkVpcAssociationIdentifier}", false);
701
+ b.bp("/servicenetworkvpcassociations/{serviceNetworkVpcAssociationIdentifier}");
702
+ b.p("serviceNetworkVpcAssociationIdentifier", () => input.serviceNetworkVpcAssociationIdentifier, "{serviceNetworkVpcAssociationIdentifier}", false);
1086
703
  let body;
1087
704
  body = JSON.stringify((0, smithy_client_1.take)(input, {
1088
705
  securityGroupIds: (_) => (0, smithy_client_1._json)(_),
1089
706
  }));
1090
- return new protocol_http_1.HttpRequest({
1091
- protocol,
1092
- hostname,
1093
- port,
1094
- method: "PATCH",
1095
- headers,
1096
- path: resolvedPath,
1097
- body,
1098
- });
707
+ b.m("PATCH").h(headers).b(body);
708
+ return b.build();
1099
709
  };
1100
710
  exports.se_UpdateServiceNetworkVpcAssociationCommand = se_UpdateServiceNetworkVpcAssociationCommand;
1101
711
  const se_UpdateTargetGroupCommand = async (input, context) => {
1102
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
712
+ const b = (0, core_2.requestBuilder)(input, context);
1103
713
  const headers = {
1104
714
  "content-type": "application/json",
1105
715
  };
1106
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/targetgroups/{targetGroupIdentifier}";
1107
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "targetGroupIdentifier", () => input.targetGroupIdentifier, "{targetGroupIdentifier}", false);
716
+ b.bp("/targetgroups/{targetGroupIdentifier}");
717
+ b.p("targetGroupIdentifier", () => input.targetGroupIdentifier, "{targetGroupIdentifier}", false);
1108
718
  let body;
1109
719
  body = JSON.stringify((0, smithy_client_1.take)(input, {
1110
720
  healthCheck: (_) => (0, smithy_client_1._json)(_),
1111
721
  }));
1112
- return new protocol_http_1.HttpRequest({
1113
- protocol,
1114
- hostname,
1115
- port,
1116
- method: "PATCH",
1117
- headers,
1118
- path: resolvedPath,
1119
- body,
1120
- });
722
+ b.m("PATCH").h(headers).b(body);
723
+ return b.build();
1121
724
  };
1122
725
  exports.se_UpdateTargetGroupCommand = se_UpdateTargetGroupCommand;
1123
726
  const de_BatchUpdateRuleCommand = async (output, context) => {
@@ -3755,10 +3358,7 @@ const de_ConflictExceptionRes = async (parsedOutput, context) => {
3755
3358
  };
3756
3359
  const de_InternalServerExceptionRes = async (parsedOutput, context) => {
3757
3360
  const contents = (0, smithy_client_1.map)({
3758
- retryAfterSeconds: [
3759
- () => void 0 !== parsedOutput.headers["retry-after"],
3760
- () => (0, smithy_client_1.strictParseInt32)(parsedOutput.headers["retry-after"]),
3761
- ],
3361
+ [_rAS]: [() => void 0 !== parsedOutput.headers[_ra], () => (0, smithy_client_1.strictParseInt32)(parsedOutput.headers[_ra])],
3762
3362
  });
3763
3363
  const data = parsedOutput.body;
3764
3364
  const doc = (0, smithy_client_1.take)(data, {
@@ -3805,10 +3405,7 @@ const de_ServiceQuotaExceededExceptionRes = async (parsedOutput, context) => {
3805
3405
  };
3806
3406
  const de_ThrottlingExceptionRes = async (parsedOutput, context) => {
3807
3407
  const contents = (0, smithy_client_1.map)({
3808
- retryAfterSeconds: [
3809
- () => void 0 !== parsedOutput.headers["retry-after"],
3810
- () => (0, smithy_client_1.strictParseInt32)(parsedOutput.headers["retry-after"]),
3811
- ],
3408
+ [_rAS]: [() => void 0 !== parsedOutput.headers[_ra], () => (0, smithy_client_1.strictParseInt32)(parsedOutput.headers[_ra])],
3812
3409
  });
3813
3410
  const data = parsedOutput.body;
3814
3411
  const doc = (0, smithy_client_1.take)(data, {
@@ -4018,6 +3615,16 @@ const isSerializableHeaderValue = (value) => value !== undefined &&
4018
3615
  value !== "" &&
4019
3616
  (!Object.getOwnPropertyNames(value).includes("length") || value.length != 0) &&
4020
3617
  (!Object.getOwnPropertyNames(value).includes("size") || value.size != 0);
3618
+ const _mR = "maxResults";
3619
+ const _nT = "nextToken";
3620
+ const _rAS = "retryAfterSeconds";
3621
+ const _rI = "resourceIdentifier";
3622
+ const _ra = "retry-after";
3623
+ const _sI = "serviceIdentifier";
3624
+ const _sNI = "serviceNetworkIdentifier";
3625
+ const _tGT = "targetGroupType";
3626
+ const _tK = "tagKeys";
3627
+ const _vI = "vpcIdentifier";
4021
3628
  const parseBody = (streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
4022
3629
  if (encoded.length) {
4023
3630
  return JSON.parse(encoded);