@aws-sdk/client-kafka 3.474.0 → 3.477.0

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