@aws-sdk/client-kafka 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 +299 -670
  2. package/dist-es/protocols/Aws_restJson1.js +300 -671
  3. package/package.json +5 -4
package/dist-cjs/protocols/Aws_restJson1.js CHANGED
@@ -3,60 +3,46 @@ Object.defineProperty(exports, "__esModule", { value: true });
3
3
  exports.se_UpdateReplicationInfoCommand = exports.se_UpdateMonitoringCommand = exports.se_UpdateConnectivityCommand = exports.se_UpdateConfigurationCommand = exports.se_UpdateClusterKafkaVersionCommand = exports.se_UpdateClusterConfigurationCommand = exports.se_UpdateBrokerTypeCommand = exports.se_UpdateBrokerStorageCommand = exports.se_UpdateBrokerCountCommand = exports.se_UntagResourceCommand = exports.se_TagResourceCommand = exports.se_RejectClientVpcConnectionCommand = exports.se_RebootBrokerCommand = exports.se_PutClusterPolicyCommand = exports.se_ListVpcConnectionsCommand = exports.se_ListTagsForResourceCommand = exports.se_ListScramSecretsCommand = exports.se_ListReplicatorsCommand = exports.se_ListNodesCommand = exports.se_ListKafkaVersionsCommand = exports.se_ListConfigurationsCommand = exports.se_ListConfigurationRevisionsCommand = exports.se_ListClustersV2Command = exports.se_ListClustersCommand = exports.se_ListClusterOperationsV2Command = exports.se_ListClusterOperationsCommand = exports.se_ListClientVpcConnectionsCommand = exports.se_GetCompatibleKafkaVersionsCommand = exports.se_GetClusterPolicyCommand = exports.se_GetBootstrapBrokersCommand = exports.se_DescribeVpcConnectionCommand = exports.se_DescribeReplicatorCommand = exports.se_DescribeConfigurationRevisionCommand = exports.se_DescribeConfigurationCommand = exports.se_DescribeClusterV2Command = exports.se_DescribeClusterOperationV2Command = exports.se_DescribeClusterOperationCommand = exports.se_DescribeClusterCommand = exports.se_DeleteVpcConnectionCommand = exports.se_DeleteReplicatorCommand = exports.se_DeleteConfigurationCommand = exports.se_DeleteClusterPolicyCommand = exports.se_DeleteClusterCommand = exports.se_CreateVpcConnectionCommand = exports.se_CreateReplicatorCommand = exports.se_CreateConfigurationCommand = exports.se_CreateClusterV2Command = exports.se_CreateClusterCommand = exports.se_BatchDisassociateScramSecretCommand = exports.se_BatchAssociateScramSecretCommand = void 0;
4
4
  exports.de_UpdateConnectivityCommand = exports.de_UpdateConfigurationCommand = exports.de_UpdateClusterKafkaVersionCommand = exports.de_UpdateClusterConfigurationCommand = exports.de_UpdateBrokerTypeCommand = exports.de_UpdateBrokerStorageCommand = exports.de_UpdateBrokerCountCommand = exports.de_UntagResourceCommand = exports.de_TagResourceCommand = exports.de_RejectClientVpcConnectionCommand = exports.de_RebootBrokerCommand = exports.de_PutClusterPolicyCommand = exports.de_ListVpcConnectionsCommand = exports.de_ListTagsForResourceCommand = exports.de_ListScramSecretsCommand = exports.de_ListReplicatorsCommand = exports.de_ListNodesCommand = exports.de_ListKafkaVersionsCommand = exports.de_ListConfigurationsCommand = exports.de_ListConfigurationRevisionsCommand = exports.de_ListClustersV2Command = exports.de_ListClustersCommand = exports.de_ListClusterOperationsV2Command = exports.de_ListClusterOperationsCommand = exports.de_ListClientVpcConnectionsCommand = exports.de_GetCompatibleKafkaVersionsCommand = exports.de_GetClusterPolicyCommand = exports.de_GetBootstrapBrokersCommand = exports.de_DescribeVpcConnectionCommand = exports.de_DescribeReplicatorCommand = exports.de_DescribeConfigurationRevisionCommand = exports.de_DescribeConfigurationCommand = exports.de_DescribeClusterV2Command = exports.de_DescribeClusterOperationV2Command = exports.de_DescribeClusterOperationCommand = exports.de_DescribeClusterCommand = exports.de_DeleteVpcConnectionCommand = exports.de_DeleteReplicatorCommand = exports.de_DeleteConfigurationCommand = exports.de_DeleteClusterPolicyCommand = exports.de_DeleteClusterCommand = exports.de_CreateVpcConnectionCommand = exports.de_CreateReplicatorCommand = exports.de_CreateConfigurationCommand = exports.de_CreateClusterV2Command = exports.de_CreateClusterCommand = exports.de_BatchDisassociateScramSecretCommand = exports.de_BatchAssociateScramSecretCommand = exports.se_UpdateStorageCommand = exports.se_UpdateSecurityCommand = void 0;
5
5
  exports.de_UpdateStorageCommand = exports.de_UpdateSecurityCommand = exports.de_UpdateReplicationInfoCommand = exports.de_UpdateMonitoringCommand = void 0;
6
- const protocol_http_1 = require("@smithy/protocol-http");
6
+ const core_1 = require("@smithy/core");
7
7
  const smithy_client_1 = require("@smithy/smithy-client");
8
8
  const KafkaServiceException_1 = require("../models/KafkaServiceException");
9
9
  const models_0_1 = require("../models/models_0");
10
10
  const se_BatchAssociateScramSecretCommand = 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 || ""}` + "/v1/clusters/{ClusterArn}/scram-secrets";
16
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "ClusterArn", () => input.ClusterArn, "{ClusterArn}", false);
15
+ b.bp("/v1/clusters/{ClusterArn}/scram-secrets");
16
+ b.p("ClusterArn", () => input.ClusterArn, "{ClusterArn}", false);
17
17
  let body;
18
18
  body = JSON.stringify((0, smithy_client_1.take)(input, {
19
19
  secretArnList: [, (_) => (0, smithy_client_1._json)(_), `SecretArnList`],
20
20
  }));
21
- return new protocol_http_1.HttpRequest({
22
- protocol,
23
- hostname,
24
- port,
25
- method: "POST",
26
- headers,
27
- path: resolvedPath,
28
- body,
29
- });
21
+ b.m("POST").h(headers).b(body);
22
+ return b.build();
30
23
  };
31
24
  exports.se_BatchAssociateScramSecretCommand = se_BatchAssociateScramSecretCommand;
32
25
  const se_BatchDisassociateScramSecretCommand = async (input, context) => {
33
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
26
+ const b = (0, core_1.requestBuilder)(input, context);
34
27
  const headers = {
35
28
  "content-type": "application/json",
36
29
  };
37
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/clusters/{ClusterArn}/scram-secrets";
38
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "ClusterArn", () => input.ClusterArn, "{ClusterArn}", false);
30
+ b.bp("/v1/clusters/{ClusterArn}/scram-secrets");
31
+ b.p("ClusterArn", () => input.ClusterArn, "{ClusterArn}", false);
39
32
  let body;
40
33
  body = JSON.stringify((0, smithy_client_1.take)(input, {
41
34
  secretArnList: [, (_) => (0, smithy_client_1._json)(_), `SecretArnList`],
42
35
  }));
43
- return new protocol_http_1.HttpRequest({
44
- protocol,
45
- hostname,
46
- port,
47
- method: "PATCH",
48
- headers,
49
- path: resolvedPath,
50
- body,
51
- });
36
+ b.m("PATCH").h(headers).b(body);
37
+ return b.build();
52
38
  };
53
39
  exports.se_BatchDisassociateScramSecretCommand = se_BatchDisassociateScramSecretCommand;
54
40
  const se_CreateClusterCommand = async (input, context) => {
55
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
41
+ const b = (0, core_1.requestBuilder)(input, context);
56
42
  const headers = {
57
43
  "content-type": "application/json",
58
44
  };
59
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/clusters";
45
+ b.bp("/v1/clusters");
60
46
  let body;
61
47
  body = JSON.stringify((0, smithy_client_1.take)(input, {
62
48
  brokerNodeGroupInfo: [, (_) => se_BrokerNodeGroupInfo(_, context), `BrokerNodeGroupInfo`],
@@ -72,23 +58,16 @@ const se_CreateClusterCommand = async (input, context) => {
72
58
  storageMode: [, , `StorageMode`],
73
59
  tags: [, (_) => (0, smithy_client_1._json)(_), `Tags`],
74
60
  }));
75
- return new protocol_http_1.HttpRequest({
76
- protocol,
77
- hostname,
78
- port,
79
- method: "POST",
80
- headers,
81
- path: resolvedPath,
82
- body,
83
- });
61
+ b.m("POST").h(headers).b(body);
62
+ return b.build();
84
63
  };
85
64
  exports.se_CreateClusterCommand = se_CreateClusterCommand;
86
65
  const se_CreateClusterV2Command = async (input, context) => {
87
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
66
+ const b = (0, core_1.requestBuilder)(input, context);
88
67
  const headers = {
89
68
  "content-type": "application/json",
90
69
  };
91
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/api/v2/clusters";
70
+ b.bp("/api/v2/clusters");
92
71
  let body;
93
72
  body = JSON.stringify((0, smithy_client_1.take)(input, {
94
73
  clusterName: [, , `ClusterName`],
@@ -96,23 +75,16 @@ const se_CreateClusterV2Command = async (input, context) => {
96
75
  serverless: [, (_) => se_ServerlessRequest(_, context), `Serverless`],
97
76
  tags: [, (_) => (0, smithy_client_1._json)(_), `Tags`],
98
77
  }));
99
- return new protocol_http_1.HttpRequest({
100
- protocol,
101
- hostname,
102
- port,
103
- method: "POST",
104
- headers,
105
- path: resolvedPath,
106
- body,
107
- });
78
+ b.m("POST").h(headers).b(body);
79
+ return b.build();
108
80
  };
109
81
  exports.se_CreateClusterV2Command = se_CreateClusterV2Command;
110
82
  const se_CreateConfigurationCommand = async (input, context) => {
111
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
83
+ const b = (0, core_1.requestBuilder)(input, context);
112
84
  const headers = {
113
85
  "content-type": "application/json",
114
86
  };
115
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/configurations";
87
+ b.bp("/v1/configurations");
116
88
  let body;
117
89
  body = JSON.stringify((0, smithy_client_1.take)(input, {
118
90
  description: [, , `Description`],
@@ -120,23 +92,16 @@ const se_CreateConfigurationCommand = async (input, context) => {
120
92
  name: [, , `Name`],
121
93
  serverProperties: [, (_) => context.base64Encoder(_), `ServerProperties`],
122
94
  }));
123
- return new protocol_http_1.HttpRequest({
124
- protocol,
125
- hostname,
126
- port,
127
- method: "POST",
128
- headers,
129
- path: resolvedPath,
130
- body,
131
- });
95
+ b.m("POST").h(headers).b(body);
96
+ return b.build();
132
97
  };
133
98
  exports.se_CreateConfigurationCommand = se_CreateConfigurationCommand;
134
99
  const se_CreateReplicatorCommand = async (input, context) => {
135
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
100
+ const b = (0, core_1.requestBuilder)(input, context);
136
101
  const headers = {
137
102
  "content-type": "application/json",
138
103
  };
139
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/replication/v1/replicators";
104
+ b.bp("/replication/v1/replicators");
140
105
  let body;
141
106
  body = JSON.stringify((0, smithy_client_1.take)(input, {
142
107
  description: [, , `Description`],
@@ -146,23 +111,16 @@ const se_CreateReplicatorCommand = async (input, context) => {
146
111
  serviceExecutionRoleArn: [, , `ServiceExecutionRoleArn`],
147
112
  tags: [, (_) => (0, smithy_client_1._json)(_), `Tags`],
148
113
  }));
149
- return new protocol_http_1.HttpRequest({
150
- protocol,
151
- hostname,
152
- port,
153
- method: "POST",
154
- headers,
155
- path: resolvedPath,
156
- body,
157
- });
114
+ b.m("POST").h(headers).b(body);
115
+ return b.build();
158
116
  };
159
117
  exports.se_CreateReplicatorCommand = se_CreateReplicatorCommand;
160
118
  const se_CreateVpcConnectionCommand = async (input, context) => {
161
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
119
+ const b = (0, core_1.requestBuilder)(input, context);
162
120
  const headers = {
163
121
  "content-type": "application/json",
164
122
  };
165
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/vpc-connection";
123
+ b.bp("/v1/vpc-connection");
166
124
  let body;
167
125
  body = JSON.stringify((0, smithy_client_1.take)(input, {
168
126
  authentication: [, , `Authentication`],
@@ -172,868 +130,552 @@ const se_CreateVpcConnectionCommand = async (input, context) => {
172
130
  targetClusterArn: [, , `TargetClusterArn`],
173
131
  vpcId: [, , `VpcId`],
174
132
  }));
175
- return new protocol_http_1.HttpRequest({
176
- protocol,
177
- hostname,
178
- port,
179
- method: "POST",
180
- headers,
181
- path: resolvedPath,
182
- body,
183
- });
133
+ b.m("POST").h(headers).b(body);
134
+ return b.build();
184
135
  };
185
136
  exports.se_CreateVpcConnectionCommand = se_CreateVpcConnectionCommand;
186
137
  const se_DeleteClusterCommand = async (input, context) => {
187
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
138
+ const b = (0, core_1.requestBuilder)(input, context);
188
139
  const headers = {};
189
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/clusters/{ClusterArn}";
190
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "ClusterArn", () => input.ClusterArn, "{ClusterArn}", false);
140
+ b.bp("/v1/clusters/{ClusterArn}");
141
+ b.p("ClusterArn", () => input.ClusterArn, "{ClusterArn}", false);
191
142
  const query = (0, smithy_client_1.map)({
192
- currentVersion: [, input.CurrentVersion],
143
+ [_cV]: [, input[_CV]],
193
144
  });
194
145
  let body;
195
- return new protocol_http_1.HttpRequest({
196
- protocol,
197
- hostname,
198
- port,
199
- method: "DELETE",
200
- headers,
201
- path: resolvedPath,
202
- query,
203
- body,
204
- });
146
+ b.m("DELETE").h(headers).q(query).b(body);
147
+ return b.build();
205
148
  };
206
149
  exports.se_DeleteClusterCommand = se_DeleteClusterCommand;
207
150
  const se_DeleteClusterPolicyCommand = async (input, context) => {
208
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
151
+ const b = (0, core_1.requestBuilder)(input, context);
209
152
  const headers = {};
210
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/clusters/{ClusterArn}/policy";
211
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "ClusterArn", () => input.ClusterArn, "{ClusterArn}", false);
153
+ b.bp("/v1/clusters/{ClusterArn}/policy");
154
+ b.p("ClusterArn", () => input.ClusterArn, "{ClusterArn}", false);
212
155
  let body;
213
- return new protocol_http_1.HttpRequest({
214
- protocol,
215
- hostname,
216
- port,
217
- method: "DELETE",
218
- headers,
219
- path: resolvedPath,
220
- body,
221
- });
156
+ b.m("DELETE").h(headers).b(body);
157
+ return b.build();
222
158
  };
223
159
  exports.se_DeleteClusterPolicyCommand = se_DeleteClusterPolicyCommand;
224
160
  const se_DeleteConfigurationCommand = async (input, context) => {
225
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
161
+ const b = (0, core_1.requestBuilder)(input, context);
226
162
  const headers = {};
227
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/configurations/{Arn}";
228
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Arn", () => input.Arn, "{Arn}", false);
163
+ b.bp("/v1/configurations/{Arn}");
164
+ b.p("Arn", () => input.Arn, "{Arn}", false);
229
165
  let body;
230
- return new protocol_http_1.HttpRequest({
231
- protocol,
232
- hostname,
233
- port,
234
- method: "DELETE",
235
- headers,
236
- path: resolvedPath,
237
- body,
238
- });
166
+ b.m("DELETE").h(headers).b(body);
167
+ return b.build();
239
168
  };
240
169
  exports.se_DeleteConfigurationCommand = se_DeleteConfigurationCommand;
241
170
  const se_DeleteReplicatorCommand = async (input, context) => {
242
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
171
+ const b = (0, core_1.requestBuilder)(input, context);
243
172
  const headers = {};
244
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
245
- "/replication/v1/replicators/{ReplicatorArn}";
246
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "ReplicatorArn", () => input.ReplicatorArn, "{ReplicatorArn}", false);
173
+ b.bp("/replication/v1/replicators/{ReplicatorArn}");
174
+ b.p("ReplicatorArn", () => input.ReplicatorArn, "{ReplicatorArn}", false);
247
175
  const query = (0, smithy_client_1.map)({
248
- currentVersion: [, input.CurrentVersion],
176
+ [_cV]: [, input[_CV]],
249
177
  });
250
178
  let body;
251
- return new protocol_http_1.HttpRequest({
252
- protocol,
253
- hostname,
254
- port,
255
- method: "DELETE",
256
- headers,
257
- path: resolvedPath,
258
- query,
259
- body,
260
- });
179
+ b.m("DELETE").h(headers).q(query).b(body);
180
+ return b.build();
261
181
  };
262
182
  exports.se_DeleteReplicatorCommand = se_DeleteReplicatorCommand;
263
183
  const se_DeleteVpcConnectionCommand = async (input, context) => {
264
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
184
+ const b = (0, core_1.requestBuilder)(input, context);
265
185
  const headers = {};
266
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/vpc-connection/{Arn}";
267
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Arn", () => input.Arn, "{Arn}", false);
186
+ b.bp("/v1/vpc-connection/{Arn}");
187
+ b.p("Arn", () => input.Arn, "{Arn}", false);
268
188
  let body;
269
- return new protocol_http_1.HttpRequest({
270
- protocol,
271
- hostname,
272
- port,
273
- method: "DELETE",
274
- headers,
275
- path: resolvedPath,
276
- body,
277
- });
189
+ b.m("DELETE").h(headers).b(body);
190
+ return b.build();
278
191
  };
279
192
  exports.se_DeleteVpcConnectionCommand = se_DeleteVpcConnectionCommand;
280
193
  const se_DescribeClusterCommand = async (input, context) => {
281
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
194
+ const b = (0, core_1.requestBuilder)(input, context);
282
195
  const headers = {};
283
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/clusters/{ClusterArn}";
284
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "ClusterArn", () => input.ClusterArn, "{ClusterArn}", false);
196
+ b.bp("/v1/clusters/{ClusterArn}");
197
+ b.p("ClusterArn", () => input.ClusterArn, "{ClusterArn}", false);
285
198
  let body;
286
- return new protocol_http_1.HttpRequest({
287
- protocol,
288
- hostname,
289
- port,
290
- method: "GET",
291
- headers,
292
- path: resolvedPath,
293
- body,
294
- });
199
+ b.m("GET").h(headers).b(body);
200
+ return b.build();
295
201
  };
296
202
  exports.se_DescribeClusterCommand = se_DescribeClusterCommand;
297
203
  const se_DescribeClusterOperationCommand = async (input, context) => {
298
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
204
+ const b = (0, core_1.requestBuilder)(input, context);
299
205
  const headers = {};
300
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/operations/{ClusterOperationArn}";
301
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "ClusterOperationArn", () => input.ClusterOperationArn, "{ClusterOperationArn}", false);
206
+ b.bp("/v1/operations/{ClusterOperationArn}");
207
+ b.p("ClusterOperationArn", () => input.ClusterOperationArn, "{ClusterOperationArn}", false);
302
208
  let body;
303
- return new protocol_http_1.HttpRequest({
304
- protocol,
305
- hostname,
306
- port,
307
- method: "GET",
308
- headers,
309
- path: resolvedPath,
310
- body,
311
- });
209
+ b.m("GET").h(headers).b(body);
210
+ return b.build();
312
211
  };
313
212
  exports.se_DescribeClusterOperationCommand = se_DescribeClusterOperationCommand;
314
213
  const se_DescribeClusterOperationV2Command = async (input, context) => {
315
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
214
+ const b = (0, core_1.requestBuilder)(input, context);
316
215
  const headers = {};
317
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/api/v2/operations/{ClusterOperationArn}";
318
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "ClusterOperationArn", () => input.ClusterOperationArn, "{ClusterOperationArn}", false);
216
+ b.bp("/api/v2/operations/{ClusterOperationArn}");
217
+ b.p("ClusterOperationArn", () => input.ClusterOperationArn, "{ClusterOperationArn}", false);
319
218
  let body;
320
- return new protocol_http_1.HttpRequest({
321
- protocol,
322
- hostname,
323
- port,
324
- method: "GET",
325
- headers,
326
- path: resolvedPath,
327
- body,
328
- });
219
+ b.m("GET").h(headers).b(body);
220
+ return b.build();
329
221
  };
330
222
  exports.se_DescribeClusterOperationV2Command = se_DescribeClusterOperationV2Command;
331
223
  const se_DescribeClusterV2Command = async (input, context) => {
332
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
224
+ const b = (0, core_1.requestBuilder)(input, context);
333
225
  const headers = {};
334
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/api/v2/clusters/{ClusterArn}";
335
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "ClusterArn", () => input.ClusterArn, "{ClusterArn}", false);
226
+ b.bp("/api/v2/clusters/{ClusterArn}");
227
+ b.p("ClusterArn", () => input.ClusterArn, "{ClusterArn}", false);
336
228
  let body;
337
- return new protocol_http_1.HttpRequest({
338
- protocol,
339
- hostname,
340
- port,
341
- method: "GET",
342
- headers,
343
- path: resolvedPath,
344
- body,
345
- });
229
+ b.m("GET").h(headers).b(body);
230
+ return b.build();
346
231
  };
347
232
  exports.se_DescribeClusterV2Command = se_DescribeClusterV2Command;
348
233
  const se_DescribeConfigurationCommand = async (input, context) => {
349
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
234
+ const b = (0, core_1.requestBuilder)(input, context);
350
235
  const headers = {};
351
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/configurations/{Arn}";
352
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Arn", () => input.Arn, "{Arn}", false);
236
+ b.bp("/v1/configurations/{Arn}");
237
+ b.p("Arn", () => input.Arn, "{Arn}", false);
353
238
  let body;
354
- return new protocol_http_1.HttpRequest({
355
- protocol,
356
- hostname,
357
- port,
358
- method: "GET",
359
- headers,
360
- path: resolvedPath,
361
- body,
362
- });
239
+ b.m("GET").h(headers).b(body);
240
+ return b.build();
363
241
  };
364
242
  exports.se_DescribeConfigurationCommand = se_DescribeConfigurationCommand;
365
243
  const se_DescribeConfigurationRevisionCommand = async (input, context) => {
366
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
244
+ const b = (0, core_1.requestBuilder)(input, context);
367
245
  const headers = {};
368
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
369
- "/v1/configurations/{Arn}/revisions/{Revision}";
370
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Arn", () => input.Arn, "{Arn}", false);
371
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Revision", () => input.Revision.toString(), "{Revision}", false);
246
+ b.bp("/v1/configurations/{Arn}/revisions/{Revision}");
247
+ b.p("Arn", () => input.Arn, "{Arn}", false);
248
+ b.p("Revision", () => input.Revision.toString(), "{Revision}", false);
372
249
  let body;
373
- return new protocol_http_1.HttpRequest({
374
- protocol,
375
- hostname,
376
- port,
377
- method: "GET",
378
- headers,
379
- path: resolvedPath,
380
- body,
381
- });
250
+ b.m("GET").h(headers).b(body);
251
+ return b.build();
382
252
  };
383
253
  exports.se_DescribeConfigurationRevisionCommand = se_DescribeConfigurationRevisionCommand;
384
254
  const se_DescribeReplicatorCommand = async (input, context) => {
385
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
255
+ const b = (0, core_1.requestBuilder)(input, context);
386
256
  const headers = {};
387
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
388
- "/replication/v1/replicators/{ReplicatorArn}";
389
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "ReplicatorArn", () => input.ReplicatorArn, "{ReplicatorArn}", false);
257
+ b.bp("/replication/v1/replicators/{ReplicatorArn}");
258
+ b.p("ReplicatorArn", () => input.ReplicatorArn, "{ReplicatorArn}", false);
390
259
  let body;
391
- return new protocol_http_1.HttpRequest({
392
- protocol,
393
- hostname,
394
- port,
395
- method: "GET",
396
- headers,
397
- path: resolvedPath,
398
- body,
399
- });
260
+ b.m("GET").h(headers).b(body);
261
+ return b.build();
400
262
  };
401
263
  exports.se_DescribeReplicatorCommand = se_DescribeReplicatorCommand;
402
264
  const se_DescribeVpcConnectionCommand = async (input, context) => {
403
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
265
+ const b = (0, core_1.requestBuilder)(input, context);
404
266
  const headers = {};
405
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/vpc-connection/{Arn}";
406
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Arn", () => input.Arn, "{Arn}", false);
267
+ b.bp("/v1/vpc-connection/{Arn}");
268
+ b.p("Arn", () => input.Arn, "{Arn}", false);
407
269
  let body;
408
- return new protocol_http_1.HttpRequest({
409
- protocol,
410
- hostname,
411
- port,
412
- method: "GET",
413
- headers,
414
- path: resolvedPath,
415
- body,
416
- });
270
+ b.m("GET").h(headers).b(body);
271
+ return b.build();
417
272
  };
418
273
  exports.se_DescribeVpcConnectionCommand = se_DescribeVpcConnectionCommand;
419
274
  const se_GetBootstrapBrokersCommand = async (input, context) => {
420
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
275
+ const b = (0, core_1.requestBuilder)(input, context);
421
276
  const headers = {};
422
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
423
- "/v1/clusters/{ClusterArn}/bootstrap-brokers";
424
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "ClusterArn", () => input.ClusterArn, "{ClusterArn}", false);
277
+ b.bp("/v1/clusters/{ClusterArn}/bootstrap-brokers");
278
+ b.p("ClusterArn", () => input.ClusterArn, "{ClusterArn}", false);
425
279
  let body;
426
- return new protocol_http_1.HttpRequest({
427
- protocol,
428
- hostname,
429
- port,
430
- method: "GET",
431
- headers,
432
- path: resolvedPath,
433
- body,
434
- });
280
+ b.m("GET").h(headers).b(body);
281
+ return b.build();
435
282
  };
436
283
  exports.se_GetBootstrapBrokersCommand = se_GetBootstrapBrokersCommand;
437
284
  const se_GetClusterPolicyCommand = async (input, context) => {
438
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
285
+ const b = (0, core_1.requestBuilder)(input, context);
439
286
  const headers = {};
440
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/clusters/{ClusterArn}/policy";
441
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "ClusterArn", () => input.ClusterArn, "{ClusterArn}", false);
287
+ b.bp("/v1/clusters/{ClusterArn}/policy");
288
+ b.p("ClusterArn", () => input.ClusterArn, "{ClusterArn}", false);
442
289
  let body;
443
- return new protocol_http_1.HttpRequest({
444
- protocol,
445
- hostname,
446
- port,
447
- method: "GET",
448
- headers,
449
- path: resolvedPath,
450
- body,
451
- });
290
+ b.m("GET").h(headers).b(body);
291
+ return b.build();
452
292
  };
453
293
  exports.se_GetClusterPolicyCommand = se_GetClusterPolicyCommand;
454
294
  const se_GetCompatibleKafkaVersionsCommand = async (input, context) => {
455
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
295
+ const b = (0, core_1.requestBuilder)(input, context);
456
296
  const headers = {};
457
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/compatible-kafka-versions";
297
+ b.bp("/v1/compatible-kafka-versions");
458
298
  const query = (0, smithy_client_1.map)({
459
- clusterArn: [, input.ClusterArn],
299
+ [_cA]: [, input[_CA]],
460
300
  });
461
301
  let body;
462
- return new protocol_http_1.HttpRequest({
463
- protocol,
464
- hostname,
465
- port,
466
- method: "GET",
467
- headers,
468
- path: resolvedPath,
469
- query,
470
- body,
471
- });
302
+ b.m("GET").h(headers).q(query).b(body);
303
+ return b.build();
472
304
  };
473
305
  exports.se_GetCompatibleKafkaVersionsCommand = se_GetCompatibleKafkaVersionsCommand;
474
306
  const se_ListClientVpcConnectionsCommand = async (input, context) => {
475
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
307
+ const b = (0, core_1.requestBuilder)(input, context);
476
308
  const headers = {};
477
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
478
- "/v1/clusters/{ClusterArn}/client-vpc-connections";
479
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "ClusterArn", () => input.ClusterArn, "{ClusterArn}", false);
309
+ b.bp("/v1/clusters/{ClusterArn}/client-vpc-connections");
310
+ b.p("ClusterArn", () => input.ClusterArn, "{ClusterArn}", false);
480
311
  const query = (0, smithy_client_1.map)({
481
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
482
- nextToken: [, input.NextToken],
312
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
313
+ [_nT]: [, input[_NT]],
483
314
  });
484
315
  let body;
485
- return new protocol_http_1.HttpRequest({
486
- protocol,
487
- hostname,
488
- port,
489
- method: "GET",
490
- headers,
491
- path: resolvedPath,
492
- query,
493
- body,
494
- });
316
+ b.m("GET").h(headers).q(query).b(body);
317
+ return b.build();
495
318
  };
496
319
  exports.se_ListClientVpcConnectionsCommand = se_ListClientVpcConnectionsCommand;
497
320
  const se_ListClusterOperationsCommand = async (input, context) => {
498
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
321
+ const b = (0, core_1.requestBuilder)(input, context);
499
322
  const headers = {};
500
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/clusters/{ClusterArn}/operations";
501
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "ClusterArn", () => input.ClusterArn, "{ClusterArn}", false);
323
+ b.bp("/v1/clusters/{ClusterArn}/operations");
324
+ b.p("ClusterArn", () => input.ClusterArn, "{ClusterArn}", false);
502
325
  const query = (0, smithy_client_1.map)({
503
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
504
- nextToken: [, input.NextToken],
326
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
327
+ [_nT]: [, input[_NT]],
505
328
  });
506
329
  let body;
507
- return new protocol_http_1.HttpRequest({
508
- protocol,
509
- hostname,
510
- port,
511
- method: "GET",
512
- headers,
513
- path: resolvedPath,
514
- query,
515
- body,
516
- });
330
+ b.m("GET").h(headers).q(query).b(body);
331
+ return b.build();
517
332
  };
518
333
  exports.se_ListClusterOperationsCommand = se_ListClusterOperationsCommand;
519
334
  const se_ListClusterOperationsV2Command = async (input, context) => {
520
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
335
+ const b = (0, core_1.requestBuilder)(input, context);
521
336
  const headers = {};
522
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/api/v2/clusters/{ClusterArn}/operations";
523
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "ClusterArn", () => input.ClusterArn, "{ClusterArn}", false);
337
+ b.bp("/api/v2/clusters/{ClusterArn}/operations");
338
+ b.p("ClusterArn", () => input.ClusterArn, "{ClusterArn}", false);
524
339
  const query = (0, smithy_client_1.map)({
525
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
526
- nextToken: [, input.NextToken],
340
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
341
+ [_nT]: [, input[_NT]],
527
342
  });
528
343
  let body;
529
- return new protocol_http_1.HttpRequest({
530
- protocol,
531
- hostname,
532
- port,
533
- method: "GET",
534
- headers,
535
- path: resolvedPath,
536
- query,
537
- body,
538
- });
344
+ b.m("GET").h(headers).q(query).b(body);
345
+ return b.build();
539
346
  };
540
347
  exports.se_ListClusterOperationsV2Command = se_ListClusterOperationsV2Command;
541
348
  const se_ListClustersCommand = async (input, context) => {
542
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
349
+ const b = (0, core_1.requestBuilder)(input, context);
543
350
  const headers = {};
544
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/clusters";
351
+ b.bp("/v1/clusters");
545
352
  const query = (0, smithy_client_1.map)({
546
- clusterNameFilter: [, input.ClusterNameFilter],
547
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
548
- nextToken: [, input.NextToken],
353
+ [_cNF]: [, input[_CNF]],
354
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
355
+ [_nT]: [, input[_NT]],
549
356
  });
550
357
  let body;
551
- return new protocol_http_1.HttpRequest({
552
- protocol,
553
- hostname,
554
- port,
555
- method: "GET",
556
- headers,
557
- path: resolvedPath,
558
- query,
559
- body,
560
- });
358
+ b.m("GET").h(headers).q(query).b(body);
359
+ return b.build();
561
360
  };
562
361
  exports.se_ListClustersCommand = se_ListClustersCommand;
563
362
  const se_ListClustersV2Command = async (input, context) => {
564
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
363
+ const b = (0, core_1.requestBuilder)(input, context);
565
364
  const headers = {};
566
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/api/v2/clusters";
365
+ b.bp("/api/v2/clusters");
567
366
  const query = (0, smithy_client_1.map)({
568
- clusterNameFilter: [, input.ClusterNameFilter],
569
- clusterTypeFilter: [, input.ClusterTypeFilter],
570
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
571
- nextToken: [, input.NextToken],
367
+ [_cNF]: [, input[_CNF]],
368
+ [_cTF]: [, input[_CTF]],
369
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
370
+ [_nT]: [, input[_NT]],
572
371
  });
573
372
  let body;
574
- return new protocol_http_1.HttpRequest({
575
- protocol,
576
- hostname,
577
- port,
578
- method: "GET",
579
- headers,
580
- path: resolvedPath,
581
- query,
582
- body,
583
- });
373
+ b.m("GET").h(headers).q(query).b(body);
374
+ return b.build();
584
375
  };
585
376
  exports.se_ListClustersV2Command = se_ListClustersV2Command;
586
377
  const se_ListConfigurationRevisionsCommand = async (input, context) => {
587
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
378
+ const b = (0, core_1.requestBuilder)(input, context);
588
379
  const headers = {};
589
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/configurations/{Arn}/revisions";
590
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Arn", () => input.Arn, "{Arn}", false);
380
+ b.bp("/v1/configurations/{Arn}/revisions");
381
+ b.p("Arn", () => input.Arn, "{Arn}", false);
591
382
  const query = (0, smithy_client_1.map)({
592
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
593
- nextToken: [, input.NextToken],
383
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
384
+ [_nT]: [, input[_NT]],
594
385
  });
595
386
  let body;
596
- return new protocol_http_1.HttpRequest({
597
- protocol,
598
- hostname,
599
- port,
600
- method: "GET",
601
- headers,
602
- path: resolvedPath,
603
- query,
604
- body,
605
- });
387
+ b.m("GET").h(headers).q(query).b(body);
388
+ return b.build();
606
389
  };
607
390
  exports.se_ListConfigurationRevisionsCommand = se_ListConfigurationRevisionsCommand;
608
391
  const se_ListConfigurationsCommand = async (input, context) => {
609
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
392
+ const b = (0, core_1.requestBuilder)(input, context);
610
393
  const headers = {};
611
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/configurations";
394
+ b.bp("/v1/configurations");
612
395
  const query = (0, smithy_client_1.map)({
613
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
614
- nextToken: [, input.NextToken],
396
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
397
+ [_nT]: [, input[_NT]],
615
398
  });
616
399
  let body;
617
- return new protocol_http_1.HttpRequest({
618
- protocol,
619
- hostname,
620
- port,
621
- method: "GET",
622
- headers,
623
- path: resolvedPath,
624
- query,
625
- body,
626
- });
400
+ b.m("GET").h(headers).q(query).b(body);
401
+ return b.build();
627
402
  };
628
403
  exports.se_ListConfigurationsCommand = se_ListConfigurationsCommand;
629
404
  const se_ListKafkaVersionsCommand = async (input, context) => {
630
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
405
+ const b = (0, core_1.requestBuilder)(input, context);
631
406
  const headers = {};
632
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/kafka-versions";
407
+ b.bp("/v1/kafka-versions");
633
408
  const query = (0, smithy_client_1.map)({
634
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
635
- nextToken: [, input.NextToken],
409
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
410
+ [_nT]: [, input[_NT]],
636
411
  });
637
412
  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
- });
413
+ b.m("GET").h(headers).q(query).b(body);
414
+ return b.build();
648
415
  };
649
416
  exports.se_ListKafkaVersionsCommand = se_ListKafkaVersionsCommand;
650
417
  const se_ListNodesCommand = async (input, context) => {
651
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
418
+ const b = (0, core_1.requestBuilder)(input, context);
652
419
  const headers = {};
653
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/clusters/{ClusterArn}/nodes";
654
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "ClusterArn", () => input.ClusterArn, "{ClusterArn}", false);
420
+ b.bp("/v1/clusters/{ClusterArn}/nodes");
421
+ b.p("ClusterArn", () => input.ClusterArn, "{ClusterArn}", false);
655
422
  const query = (0, smithy_client_1.map)({
656
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
657
- nextToken: [, input.NextToken],
423
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
424
+ [_nT]: [, input[_NT]],
658
425
  });
659
426
  let body;
660
- return new protocol_http_1.HttpRequest({
661
- protocol,
662
- hostname,
663
- port,
664
- method: "GET",
665
- headers,
666
- path: resolvedPath,
667
- query,
668
- body,
669
- });
427
+ b.m("GET").h(headers).q(query).b(body);
428
+ return b.build();
670
429
  };
671
430
  exports.se_ListNodesCommand = se_ListNodesCommand;
672
431
  const se_ListReplicatorsCommand = async (input, context) => {
673
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
432
+ const b = (0, core_1.requestBuilder)(input, context);
674
433
  const headers = {};
675
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/replication/v1/replicators";
434
+ b.bp("/replication/v1/replicators");
676
435
  const query = (0, smithy_client_1.map)({
677
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
678
- nextToken: [, input.NextToken],
679
- replicatorNameFilter: [, input.ReplicatorNameFilter],
436
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
437
+ [_nT]: [, input[_NT]],
438
+ [_rNF]: [, input[_RNF]],
680
439
  });
681
440
  let body;
682
- return new protocol_http_1.HttpRequest({
683
- protocol,
684
- hostname,
685
- port,
686
- method: "GET",
687
- headers,
688
- path: resolvedPath,
689
- query,
690
- body,
691
- });
441
+ b.m("GET").h(headers).q(query).b(body);
442
+ return b.build();
692
443
  };
693
444
  exports.se_ListReplicatorsCommand = se_ListReplicatorsCommand;
694
445
  const se_ListScramSecretsCommand = async (input, context) => {
695
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
446
+ const b = (0, core_1.requestBuilder)(input, context);
696
447
  const headers = {};
697
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/clusters/{ClusterArn}/scram-secrets";
698
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "ClusterArn", () => input.ClusterArn, "{ClusterArn}", false);
448
+ b.bp("/v1/clusters/{ClusterArn}/scram-secrets");
449
+ b.p("ClusterArn", () => input.ClusterArn, "{ClusterArn}", false);
699
450
  const query = (0, smithy_client_1.map)({
700
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
701
- nextToken: [, input.NextToken],
451
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
452
+ [_nT]: [, input[_NT]],
702
453
  });
703
454
  let body;
704
- return new protocol_http_1.HttpRequest({
705
- protocol,
706
- hostname,
707
- port,
708
- method: "GET",
709
- headers,
710
- path: resolvedPath,
711
- query,
712
- body,
713
- });
455
+ b.m("GET").h(headers).q(query).b(body);
456
+ return b.build();
714
457
  };
715
458
  exports.se_ListScramSecretsCommand = se_ListScramSecretsCommand;
716
459
  const se_ListTagsForResourceCommand = async (input, context) => {
717
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
460
+ const b = (0, core_1.requestBuilder)(input, context);
718
461
  const headers = {};
719
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/tags/{ResourceArn}";
720
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
462
+ b.bp("/v1/tags/{ResourceArn}");
463
+ b.p("ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
721
464
  let body;
722
- return new protocol_http_1.HttpRequest({
723
- protocol,
724
- hostname,
725
- port,
726
- method: "GET",
727
- headers,
728
- path: resolvedPath,
729
- body,
730
- });
465
+ b.m("GET").h(headers).b(body);
466
+ return b.build();
731
467
  };
732
468
  exports.se_ListTagsForResourceCommand = se_ListTagsForResourceCommand;
733
469
  const se_ListVpcConnectionsCommand = async (input, context) => {
734
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
470
+ const b = (0, core_1.requestBuilder)(input, context);
735
471
  const headers = {};
736
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/vpc-connections";
472
+ b.bp("/v1/vpc-connections");
737
473
  const query = (0, smithy_client_1.map)({
738
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
739
- nextToken: [, input.NextToken],
474
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
475
+ [_nT]: [, input[_NT]],
740
476
  });
741
477
  let body;
742
- return new protocol_http_1.HttpRequest({
743
- protocol,
744
- hostname,
745
- port,
746
- method: "GET",
747
- headers,
748
- path: resolvedPath,
749
- query,
750
- body,
751
- });
478
+ b.m("GET").h(headers).q(query).b(body);
479
+ return b.build();
752
480
  };
753
481
  exports.se_ListVpcConnectionsCommand = se_ListVpcConnectionsCommand;
754
482
  const se_PutClusterPolicyCommand = async (input, context) => {
755
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
483
+ const b = (0, core_1.requestBuilder)(input, context);
756
484
  const headers = {
757
485
  "content-type": "application/json",
758
486
  };
759
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/clusters/{ClusterArn}/policy";
760
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "ClusterArn", () => input.ClusterArn, "{ClusterArn}", false);
487
+ b.bp("/v1/clusters/{ClusterArn}/policy");
488
+ b.p("ClusterArn", () => input.ClusterArn, "{ClusterArn}", false);
761
489
  let body;
762
490
  body = JSON.stringify((0, smithy_client_1.take)(input, {
763
491
  currentVersion: [, , `CurrentVersion`],
764
492
  policy: [, , `Policy`],
765
493
  }));
766
- return new protocol_http_1.HttpRequest({
767
- protocol,
768
- hostname,
769
- port,
770
- method: "PUT",
771
- headers,
772
- path: resolvedPath,
773
- body,
774
- });
494
+ b.m("PUT").h(headers).b(body);
495
+ return b.build();
775
496
  };
776
497
  exports.se_PutClusterPolicyCommand = se_PutClusterPolicyCommand;
777
498
  const se_RebootBrokerCommand = async (input, context) => {
778
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
499
+ const b = (0, core_1.requestBuilder)(input, context);
779
500
  const headers = {
780
501
  "content-type": "application/json",
781
502
  };
782
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/clusters/{ClusterArn}/reboot-broker";
783
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "ClusterArn", () => input.ClusterArn, "{ClusterArn}", false);
503
+ b.bp("/v1/clusters/{ClusterArn}/reboot-broker");
504
+ b.p("ClusterArn", () => input.ClusterArn, "{ClusterArn}", false);
784
505
  let body;
785
506
  body = JSON.stringify((0, smithy_client_1.take)(input, {
786
507
  brokerIds: [, (_) => (0, smithy_client_1._json)(_), `BrokerIds`],
787
508
  }));
788
- return new protocol_http_1.HttpRequest({
789
- protocol,
790
- hostname,
791
- port,
792
- method: "PUT",
793
- headers,
794
- path: resolvedPath,
795
- body,
796
- });
509
+ b.m("PUT").h(headers).b(body);
510
+ return b.build();
797
511
  };
798
512
  exports.se_RebootBrokerCommand = se_RebootBrokerCommand;
799
513
  const se_RejectClientVpcConnectionCommand = async (input, context) => {
800
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
514
+ const b = (0, core_1.requestBuilder)(input, context);
801
515
  const headers = {
802
516
  "content-type": "application/json",
803
517
  };
804
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
805
- "/v1/clusters/{ClusterArn}/client-vpc-connection";
806
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "ClusterArn", () => input.ClusterArn, "{ClusterArn}", false);
518
+ b.bp("/v1/clusters/{ClusterArn}/client-vpc-connection");
519
+ b.p("ClusterArn", () => input.ClusterArn, "{ClusterArn}", false);
807
520
  let body;
808
521
  body = JSON.stringify((0, smithy_client_1.take)(input, {
809
522
  vpcConnectionArn: [, , `VpcConnectionArn`],
810
523
  }));
811
- return new protocol_http_1.HttpRequest({
812
- protocol,
813
- hostname,
814
- port,
815
- method: "PUT",
816
- headers,
817
- path: resolvedPath,
818
- body,
819
- });
524
+ b.m("PUT").h(headers).b(body);
525
+ return b.build();
820
526
  };
821
527
  exports.se_RejectClientVpcConnectionCommand = se_RejectClientVpcConnectionCommand;
822
528
  const se_TagResourceCommand = async (input, context) => {
823
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
529
+ const b = (0, core_1.requestBuilder)(input, context);
824
530
  const headers = {
825
531
  "content-type": "application/json",
826
532
  };
827
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/tags/{ResourceArn}";
828
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
533
+ b.bp("/v1/tags/{ResourceArn}");
534
+ b.p("ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
829
535
  let body;
830
536
  body = JSON.stringify((0, smithy_client_1.take)(input, {
831
537
  tags: [, (_) => (0, smithy_client_1._json)(_), `Tags`],
832
538
  }));
833
- return new protocol_http_1.HttpRequest({
834
- protocol,
835
- hostname,
836
- port,
837
- method: "POST",
838
- headers,
839
- path: resolvedPath,
840
- body,
841
- });
539
+ b.m("POST").h(headers).b(body);
540
+ return b.build();
842
541
  };
843
542
  exports.se_TagResourceCommand = se_TagResourceCommand;
844
543
  const se_UntagResourceCommand = async (input, context) => {
845
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
544
+ const b = (0, core_1.requestBuilder)(input, context);
846
545
  const headers = {};
847
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/tags/{ResourceArn}";
848
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
546
+ b.bp("/v1/tags/{ResourceArn}");
547
+ b.p("ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
849
548
  const query = (0, smithy_client_1.map)({
850
- tagKeys: [
549
+ [_tK]: [
851
550
  (0, smithy_client_1.expectNonNull)(input.TagKeys, `TagKeys`) != null,
852
- () => (input.TagKeys || []).map((_entry) => _entry),
551
+ () => (input[_TK] || []).map((_entry) => _entry),
853
552
  ],
854
553
  });
855
554
  let body;
856
- return new protocol_http_1.HttpRequest({
857
- protocol,
858
- hostname,
859
- port,
860
- method: "DELETE",
861
- headers,
862
- path: resolvedPath,
863
- query,
864
- body,
865
- });
555
+ b.m("DELETE").h(headers).q(query).b(body);
556
+ return b.build();
866
557
  };
867
558
  exports.se_UntagResourceCommand = se_UntagResourceCommand;
868
559
  const se_UpdateBrokerCountCommand = async (input, context) => {
869
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
560
+ const b = (0, core_1.requestBuilder)(input, context);
870
561
  const headers = {
871
562
  "content-type": "application/json",
872
563
  };
873
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/clusters/{ClusterArn}/nodes/count";
874
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "ClusterArn", () => input.ClusterArn, "{ClusterArn}", false);
564
+ b.bp("/v1/clusters/{ClusterArn}/nodes/count");
565
+ b.p("ClusterArn", () => input.ClusterArn, "{ClusterArn}", false);
875
566
  let body;
876
567
  body = JSON.stringify((0, smithy_client_1.take)(input, {
877
568
  currentVersion: [, , `CurrentVersion`],
878
569
  targetNumberOfBrokerNodes: [, , `TargetNumberOfBrokerNodes`],
879
570
  }));
880
- return new protocol_http_1.HttpRequest({
881
- protocol,
882
- hostname,
883
- port,
884
- method: "PUT",
885
- headers,
886
- path: resolvedPath,
887
- body,
888
- });
571
+ b.m("PUT").h(headers).b(body);
572
+ return b.build();
889
573
  };
890
574
  exports.se_UpdateBrokerCountCommand = se_UpdateBrokerCountCommand;
891
575
  const se_UpdateBrokerStorageCommand = async (input, context) => {
892
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
576
+ const b = (0, core_1.requestBuilder)(input, context);
893
577
  const headers = {
894
578
  "content-type": "application/json",
895
579
  };
896
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/clusters/{ClusterArn}/nodes/storage";
897
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "ClusterArn", () => input.ClusterArn, "{ClusterArn}", false);
580
+ b.bp("/v1/clusters/{ClusterArn}/nodes/storage");
581
+ b.p("ClusterArn", () => input.ClusterArn, "{ClusterArn}", false);
898
582
  let body;
899
583
  body = JSON.stringify((0, smithy_client_1.take)(input, {
900
584
  currentVersion: [, , `CurrentVersion`],
901
585
  targetBrokerEBSVolumeInfo: [, (_) => se___listOfBrokerEBSVolumeInfo(_, context), `TargetBrokerEBSVolumeInfo`],
902
586
  }));
903
- return new protocol_http_1.HttpRequest({
904
- protocol,
905
- hostname,
906
- port,
907
- method: "PUT",
908
- headers,
909
- path: resolvedPath,
910
- body,
911
- });
587
+ b.m("PUT").h(headers).b(body);
588
+ return b.build();
912
589
  };
913
590
  exports.se_UpdateBrokerStorageCommand = se_UpdateBrokerStorageCommand;
914
591
  const se_UpdateBrokerTypeCommand = async (input, context) => {
915
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
592
+ const b = (0, core_1.requestBuilder)(input, context);
916
593
  const headers = {
917
594
  "content-type": "application/json",
918
595
  };
919
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/clusters/{ClusterArn}/nodes/type";
920
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "ClusterArn", () => input.ClusterArn, "{ClusterArn}", false);
596
+ b.bp("/v1/clusters/{ClusterArn}/nodes/type");
597
+ b.p("ClusterArn", () => input.ClusterArn, "{ClusterArn}", false);
921
598
  let body;
922
599
  body = JSON.stringify((0, smithy_client_1.take)(input, {
923
600
  currentVersion: [, , `CurrentVersion`],
924
601
  targetInstanceType: [, , `TargetInstanceType`],
925
602
  }));
926
- return new protocol_http_1.HttpRequest({
927
- protocol,
928
- hostname,
929
- port,
930
- method: "PUT",
931
- headers,
932
- path: resolvedPath,
933
- body,
934
- });
603
+ b.m("PUT").h(headers).b(body);
604
+ return b.build();
935
605
  };
936
606
  exports.se_UpdateBrokerTypeCommand = se_UpdateBrokerTypeCommand;
937
607
  const se_UpdateClusterConfigurationCommand = async (input, context) => {
938
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
608
+ const b = (0, core_1.requestBuilder)(input, context);
939
609
  const headers = {
940
610
  "content-type": "application/json",
941
611
  };
942
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/clusters/{ClusterArn}/configuration";
943
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "ClusterArn", () => input.ClusterArn, "{ClusterArn}", false);
612
+ b.bp("/v1/clusters/{ClusterArn}/configuration");
613
+ b.p("ClusterArn", () => input.ClusterArn, "{ClusterArn}", false);
944
614
  let body;
945
615
  body = JSON.stringify((0, smithy_client_1.take)(input, {
946
616
  configurationInfo: [, (_) => se_ConfigurationInfo(_, context), `ConfigurationInfo`],
947
617
  currentVersion: [, , `CurrentVersion`],
948
618
  }));
949
- return new protocol_http_1.HttpRequest({
950
- protocol,
951
- hostname,
952
- port,
953
- method: "PUT",
954
- headers,
955
- path: resolvedPath,
956
- body,
957
- });
619
+ b.m("PUT").h(headers).b(body);
620
+ return b.build();
958
621
  };
959
622
  exports.se_UpdateClusterConfigurationCommand = se_UpdateClusterConfigurationCommand;
960
623
  const se_UpdateClusterKafkaVersionCommand = async (input, context) => {
961
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
624
+ const b = (0, core_1.requestBuilder)(input, context);
962
625
  const headers = {
963
626
  "content-type": "application/json",
964
627
  };
965
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/clusters/{ClusterArn}/version";
966
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "ClusterArn", () => input.ClusterArn, "{ClusterArn}", false);
628
+ b.bp("/v1/clusters/{ClusterArn}/version");
629
+ b.p("ClusterArn", () => input.ClusterArn, "{ClusterArn}", false);
967
630
  let body;
968
631
  body = JSON.stringify((0, smithy_client_1.take)(input, {
969
632
  configurationInfo: [, (_) => se_ConfigurationInfo(_, context), `ConfigurationInfo`],
970
633
  currentVersion: [, , `CurrentVersion`],
971
634
  targetKafkaVersion: [, , `TargetKafkaVersion`],
972
635
  }));
973
- return new protocol_http_1.HttpRequest({
974
- protocol,
975
- hostname,
976
- port,
977
- method: "PUT",
978
- headers,
979
- path: resolvedPath,
980
- body,
981
- });
636
+ b.m("PUT").h(headers).b(body);
637
+ return b.build();
982
638
  };
983
639
  exports.se_UpdateClusterKafkaVersionCommand = se_UpdateClusterKafkaVersionCommand;
984
640
  const se_UpdateConfigurationCommand = async (input, context) => {
985
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
641
+ const b = (0, core_1.requestBuilder)(input, context);
986
642
  const headers = {
987
643
  "content-type": "application/json",
988
644
  };
989
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/configurations/{Arn}";
990
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Arn", () => input.Arn, "{Arn}", false);
645
+ b.bp("/v1/configurations/{Arn}");
646
+ b.p("Arn", () => input.Arn, "{Arn}", false);
991
647
  let body;
992
648
  body = JSON.stringify((0, smithy_client_1.take)(input, {
993
649
  description: [, , `Description`],
994
650
  serverProperties: [, (_) => context.base64Encoder(_), `ServerProperties`],
995
651
  }));
996
- return new protocol_http_1.HttpRequest({
997
- protocol,
998
- hostname,
999
- port,
1000
- method: "PUT",
1001
- headers,
1002
- path: resolvedPath,
1003
- body,
1004
- });
652
+ b.m("PUT").h(headers).b(body);
653
+ return b.build();
1005
654
  };
1006
655
  exports.se_UpdateConfigurationCommand = se_UpdateConfigurationCommand;
1007
656
  const se_UpdateConnectivityCommand = async (input, context) => {
1008
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
657
+ const b = (0, core_1.requestBuilder)(input, context);
1009
658
  const headers = {
1010
659
  "content-type": "application/json",
1011
660
  };
1012
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/clusters/{ClusterArn}/connectivity";
1013
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "ClusterArn", () => input.ClusterArn, "{ClusterArn}", false);
661
+ b.bp("/v1/clusters/{ClusterArn}/connectivity");
662
+ b.p("ClusterArn", () => input.ClusterArn, "{ClusterArn}", false);
1014
663
  let body;
1015
664
  body = JSON.stringify((0, smithy_client_1.take)(input, {
1016
665
  connectivityInfo: [, (_) => se_ConnectivityInfo(_, context), `ConnectivityInfo`],
1017
666
  currentVersion: [, , `CurrentVersion`],
1018
667
  }));
1019
- return new protocol_http_1.HttpRequest({
1020
- protocol,
1021
- hostname,
1022
- port,
1023
- method: "PUT",
1024
- headers,
1025
- path: resolvedPath,
1026
- body,
1027
- });
668
+ b.m("PUT").h(headers).b(body);
669
+ return b.build();
1028
670
  };
1029
671
  exports.se_UpdateConnectivityCommand = se_UpdateConnectivityCommand;
1030
672
  const se_UpdateMonitoringCommand = async (input, context) => {
1031
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
673
+ const b = (0, core_1.requestBuilder)(input, context);
1032
674
  const headers = {
1033
675
  "content-type": "application/json",
1034
676
  };
1035
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/clusters/{ClusterArn}/monitoring";
1036
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "ClusterArn", () => input.ClusterArn, "{ClusterArn}", false);
677
+ b.bp("/v1/clusters/{ClusterArn}/monitoring");
678
+ b.p("ClusterArn", () => input.ClusterArn, "{ClusterArn}", false);
1037
679
  let body;
1038
680
  body = JSON.stringify((0, smithy_client_1.take)(input, {
1039
681
  currentVersion: [, , `CurrentVersion`],
@@ -1041,25 +683,17 @@ const se_UpdateMonitoringCommand = async (input, context) => {
1041
683
  loggingInfo: [, (_) => se_LoggingInfo(_, context), `LoggingInfo`],
1042
684
  openMonitoring: [, (_) => se_OpenMonitoringInfo(_, context), `OpenMonitoring`],
1043
685
  }));
1044
- return new protocol_http_1.HttpRequest({
1045
- protocol,
1046
- hostname,
1047
- port,
1048
- method: "PUT",
1049
- headers,
1050
- path: resolvedPath,
1051
- body,
1052
- });
686
+ b.m("PUT").h(headers).b(body);
687
+ return b.build();
1053
688
  };
1054
689
  exports.se_UpdateMonitoringCommand = se_UpdateMonitoringCommand;
1055
690
  const se_UpdateReplicationInfoCommand = async (input, context) => {
1056
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
691
+ const b = (0, core_1.requestBuilder)(input, context);
1057
692
  const headers = {
1058
693
  "content-type": "application/json",
1059
694
  };
1060
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1061
- "/replication/v1/replicators/{ReplicatorArn}/replication-info";
1062
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "ReplicatorArn", () => input.ReplicatorArn, "{ReplicatorArn}", false);
695
+ b.bp("/replication/v1/replicators/{ReplicatorArn}/replication-info");
696
+ b.p("ReplicatorArn", () => input.ReplicatorArn, "{ReplicatorArn}", false);
1063
697
  let body;
1064
698
  body = JSON.stringify((0, smithy_client_1.take)(input, {
1065
699
  consumerGroupReplication: [, (_) => se_ConsumerGroupReplicationUpdate(_, context), `ConsumerGroupReplication`],
@@ -1068,48 +702,34 @@ const se_UpdateReplicationInfoCommand = async (input, context) => {
1068
702
  targetKafkaClusterArn: [, , `TargetKafkaClusterArn`],
1069
703
  topicReplication: [, (_) => se_TopicReplicationUpdate(_, context), `TopicReplication`],
1070
704
  }));
1071
- return new protocol_http_1.HttpRequest({
1072
- protocol,
1073
- hostname,
1074
- port,
1075
- method: "PUT",
1076
- headers,
1077
- path: resolvedPath,
1078
- body,
1079
- });
705
+ b.m("PUT").h(headers).b(body);
706
+ return b.build();
1080
707
  };
1081
708
  exports.se_UpdateReplicationInfoCommand = se_UpdateReplicationInfoCommand;
1082
709
  const se_UpdateSecurityCommand = async (input, context) => {
1083
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
710
+ const b = (0, core_1.requestBuilder)(input, context);
1084
711
  const headers = {
1085
712
  "content-type": "application/json",
1086
713
  };
1087
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/clusters/{ClusterArn}/security";
1088
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "ClusterArn", () => input.ClusterArn, "{ClusterArn}", false);
714
+ b.bp("/v1/clusters/{ClusterArn}/security");
715
+ b.p("ClusterArn", () => input.ClusterArn, "{ClusterArn}", false);
1089
716
  let body;
1090
717
  body = JSON.stringify((0, smithy_client_1.take)(input, {
1091
718
  clientAuthentication: [, (_) => se_ClientAuthentication(_, context), `ClientAuthentication`],
1092
719
  currentVersion: [, , `CurrentVersion`],
1093
720
  encryptionInfo: [, (_) => se_EncryptionInfo(_, context), `EncryptionInfo`],
1094
721
  }));
1095
- return new protocol_http_1.HttpRequest({
1096
- protocol,
1097
- hostname,
1098
- port,
1099
- method: "PATCH",
1100
- headers,
1101
- path: resolvedPath,
1102
- body,
1103
- });
722
+ b.m("PATCH").h(headers).b(body);
723
+ return b.build();
1104
724
  };
1105
725
  exports.se_UpdateSecurityCommand = se_UpdateSecurityCommand;
1106
726
  const se_UpdateStorageCommand = async (input, context) => {
1107
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
727
+ const b = (0, core_1.requestBuilder)(input, context);
1108
728
  const headers = {
1109
729
  "content-type": "application/json",
1110
730
  };
1111
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/clusters/{ClusterArn}/storage";
1112
- resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "ClusterArn", () => input.ClusterArn, "{ClusterArn}", false);
731
+ b.bp("/v1/clusters/{ClusterArn}/storage");
732
+ b.p("ClusterArn", () => input.ClusterArn, "{ClusterArn}", false);
1113
733
  let body;
1114
734
  body = JSON.stringify((0, smithy_client_1.take)(input, {
1115
735
  currentVersion: [, , `CurrentVersion`],
@@ -1117,15 +737,8 @@ const se_UpdateStorageCommand = async (input, context) => {
1117
737
  storageMode: [, , `StorageMode`],
1118
738
  volumeSizeGB: [, , `VolumeSizeGB`],
1119
739
  }));
1120
- return new protocol_http_1.HttpRequest({
1121
- protocol,
1122
- hostname,
1123
- port,
1124
- method: "PUT",
1125
- headers,
1126
- path: resolvedPath,
1127
- body,
1128
- });
740
+ b.m("PUT").h(headers).b(body);
741
+ return b.build();
1129
742
  };
1130
743
  exports.se_UpdateStorageCommand = se_UpdateStorageCommand;
1131
744
  const de_BatchAssociateScramSecretCommand = async (output, context) => {
@@ -4846,6 +4459,22 @@ const isSerializableHeaderValue = (value) => value !== undefined &&
4846
4459
  value !== "" &&
4847
4460
  (!Object.getOwnPropertyNames(value).includes("length") || value.length != 0) &&
4848
4461
  (!Object.getOwnPropertyNames(value).includes("size") || value.size != 0);
4462
+ const _CA = "ClusterArn";
4463
+ const _CNF = "ClusterNameFilter";
4464
+ const _CTF = "ClusterTypeFilter";
4465
+ const _CV = "CurrentVersion";
4466
+ const _MR = "MaxResults";
4467
+ const _NT = "NextToken";
4468
+ const _RNF = "ReplicatorNameFilter";
4469
+ const _TK = "TagKeys";
4470
+ const _cA = "clusterArn";
4471
+ const _cNF = "clusterNameFilter";
4472
+ const _cTF = "clusterTypeFilter";
4473
+ const _cV = "currentVersion";
4474
+ const _mR = "maxResults";
4475
+ const _nT = "nextToken";
4476
+ const _rNF = "replicatorNameFilter";
4477
+ const _tK = "tagKeys";
4849
4478
  const parseBody = (streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
4850
4479
  if (encoded.length) {
4851
4480
  return JSON.parse(encoded);