@aws-sdk/client-macie2 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 +377 -937
  2. package/dist-es/protocols/Aws_restJson1.js +378 -938
  3. package/package.json +5 -4
package/dist-es/protocols/Aws_restJson1.js CHANGED
@@ -1,56 +1,42 @@
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 { v4 as generateIdempotencyToken } from "uuid";
4
4
  import { Macie2ServiceException as __BaseException } from "../models/Macie2ServiceException";
5
5
  import { AccessDeniedException, ConflictException, InternalServerException, ResourceNotFoundException, ServiceQuotaExceededException, ThrottlingException, UnprocessableEntityException, ValidationException, } from "../models/models_0";
6
6
  export const se_AcceptInvitationCommand = async (input, context) => {
7
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
7
+ const b = rb(input, context);
8
8
  const headers = {
9
9
  "content-type": "application/json",
10
10
  };
11
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/invitations/accept";
11
+ b.bp("/invitations/accept");
12
12
  let body;
13
13
  body = JSON.stringify(take(input, {
14
14
  administratorAccountId: [, , `administratorAccountId`],
15
15
  invitationId: [, , `invitationId`],
16
16
  masterAccount: [, , `masterAccount`],
17
17
  }));
18
- return new __HttpRequest({
19
- protocol,
20
- hostname,
21
- port,
22
- method: "POST",
23
- headers,
24
- path: resolvedPath,
25
- body,
26
- });
18
+ b.m("POST").h(headers).b(body);
19
+ return b.build();
27
20
  };
28
21
  export const se_BatchGetCustomDataIdentifiersCommand = async (input, context) => {
29
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
22
+ const b = rb(input, context);
30
23
  const headers = {
31
24
  "content-type": "application/json",
32
25
  };
33
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/custom-data-identifiers/get";
26
+ b.bp("/custom-data-identifiers/get");
34
27
  let body;
35
28
  body = JSON.stringify(take(input, {
36
29
  ids: [, (_) => _json(_), `ids`],
37
30
  }));
38
- return new __HttpRequest({
39
- protocol,
40
- hostname,
41
- port,
42
- method: "POST",
43
- headers,
44
- path: resolvedPath,
45
- body,
46
- });
31
+ b.m("POST").h(headers).b(body);
32
+ return b.build();
47
33
  };
48
34
  export const se_CreateAllowListCommand = async (input, context) => {
49
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
35
+ const b = rb(input, context);
50
36
  const headers = {
51
37
  "content-type": "application/json",
52
38
  };
53
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/allow-lists";
39
+ b.bp("/allow-lists");
54
40
  let body;
55
41
  body = JSON.stringify(take(input, {
56
42
  clientToken: [true, (_) => _ ?? generateIdempotencyToken(), `clientToken`],
@@ -59,22 +45,15 @@ export const se_CreateAllowListCommand = async (input, context) => {
59
45
  name: [, , `name`],
60
46
  tags: [, (_) => _json(_), `tags`],
61
47
  }));
62
- return new __HttpRequest({
63
- protocol,
64
- hostname,
65
- port,
66
- method: "POST",
67
- headers,
68
- path: resolvedPath,
69
- body,
70
- });
48
+ b.m("POST").h(headers).b(body);
49
+ return b.build();
71
50
  };
72
51
  export const se_CreateClassificationJobCommand = async (input, context) => {
73
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
52
+ const b = rb(input, context);
74
53
  const headers = {
75
54
  "content-type": "application/json",
76
55
  };
77
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/jobs";
56
+ b.bp("/jobs");
78
57
  let body;
79
58
  body = JSON.stringify(take(input, {
80
59
  allowListIds: [, (_) => _json(_), `allowListIds`],
@@ -91,22 +70,15 @@ export const se_CreateClassificationJobCommand = async (input, context) => {
91
70
  scheduleFrequency: [, (_) => se_JobScheduleFrequency(_, context), `scheduleFrequency`],
92
71
  tags: [, (_) => _json(_), `tags`],
93
72
  }));
94
- return new __HttpRequest({
95
- protocol,
96
- hostname,
97
- port,
98
- method: "POST",
99
- headers,
100
- path: resolvedPath,
101
- body,
102
- });
73
+ b.m("POST").h(headers).b(body);
74
+ return b.build();
103
75
  };
104
76
  export const se_CreateCustomDataIdentifierCommand = async (input, context) => {
105
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
77
+ const b = rb(input, context);
106
78
  const headers = {
107
79
  "content-type": "application/json",
108
80
  };
109
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/custom-data-identifiers";
81
+ b.bp("/custom-data-identifiers");
110
82
  let body;
111
83
  body = JSON.stringify(take(input, {
112
84
  clientToken: [true, (_) => _ ?? generateIdempotencyToken(), `clientToken`],
@@ -119,22 +91,15 @@ export const se_CreateCustomDataIdentifierCommand = async (input, context) => {
119
91
  severityLevels: [, (_) => se_SeverityLevelList(_, context), `severityLevels`],
120
92
  tags: [, (_) => _json(_), `tags`],
121
93
  }));
122
- return new __HttpRequest({
123
- protocol,
124
- hostname,
125
- port,
126
- method: "POST",
127
- headers,
128
- path: resolvedPath,
129
- body,
130
- });
94
+ b.m("POST").h(headers).b(body);
95
+ return b.build();
131
96
  };
132
97
  export const se_CreateFindingsFilterCommand = async (input, context) => {
133
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
98
+ const b = rb(input, context);
134
99
  const headers = {
135
100
  "content-type": "application/json",
136
101
  };
137
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/findingsfilters";
102
+ b.bp("/findingsfilters");
138
103
  let body;
139
104
  body = JSON.stringify(take(input, {
140
105
  action: [, , `action`],
@@ -145,193 +110,122 @@ export const se_CreateFindingsFilterCommand = async (input, context) => {
145
110
  position: [, , `position`],
146
111
  tags: [, (_) => _json(_), `tags`],
147
112
  }));
148
- return new __HttpRequest({
149
- protocol,
150
- hostname,
151
- port,
152
- method: "POST",
153
- headers,
154
- path: resolvedPath,
155
- body,
156
- });
113
+ b.m("POST").h(headers).b(body);
114
+ return b.build();
157
115
  };
158
116
  export const se_CreateInvitationsCommand = async (input, context) => {
159
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
117
+ const b = rb(input, context);
160
118
  const headers = {
161
119
  "content-type": "application/json",
162
120
  };
163
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/invitations";
121
+ b.bp("/invitations");
164
122
  let body;
165
123
  body = JSON.stringify(take(input, {
166
124
  accountIds: [, (_) => _json(_), `accountIds`],
167
125
  disableEmailNotification: [, , `disableEmailNotification`],
168
126
  message: [, , `message`],
169
127
  }));
170
- return new __HttpRequest({
171
- protocol,
172
- hostname,
173
- port,
174
- method: "POST",
175
- headers,
176
- path: resolvedPath,
177
- body,
178
- });
128
+ b.m("POST").h(headers).b(body);
129
+ return b.build();
179
130
  };
180
131
  export const se_CreateMemberCommand = async (input, context) => {
181
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
132
+ const b = rb(input, context);
182
133
  const headers = {
183
134
  "content-type": "application/json",
184
135
  };
185
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/members";
136
+ b.bp("/members");
186
137
  let body;
187
138
  body = JSON.stringify(take(input, {
188
139
  account: [, (_) => se_AccountDetail(_, context), `account`],
189
140
  tags: [, (_) => _json(_), `tags`],
190
141
  }));
191
- return new __HttpRequest({
192
- protocol,
193
- hostname,
194
- port,
195
- method: "POST",
196
- headers,
197
- path: resolvedPath,
198
- body,
199
- });
142
+ b.m("POST").h(headers).b(body);
143
+ return b.build();
200
144
  };
201
145
  export const se_CreateSampleFindingsCommand = async (input, context) => {
202
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
146
+ const b = rb(input, context);
203
147
  const headers = {
204
148
  "content-type": "application/json",
205
149
  };
206
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/findings/sample";
150
+ b.bp("/findings/sample");
207
151
  let body;
208
152
  body = JSON.stringify(take(input, {
209
153
  findingTypes: [, (_) => _json(_), `findingTypes`],
210
154
  }));
211
- return new __HttpRequest({
212
- protocol,
213
- hostname,
214
- port,
215
- method: "POST",
216
- headers,
217
- path: resolvedPath,
218
- body,
219
- });
155
+ b.m("POST").h(headers).b(body);
156
+ return b.build();
220
157
  };
221
158
  export const se_DeclineInvitationsCommand = async (input, context) => {
222
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
159
+ const b = rb(input, context);
223
160
  const headers = {
224
161
  "content-type": "application/json",
225
162
  };
226
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/invitations/decline";
163
+ b.bp("/invitations/decline");
227
164
  let body;
228
165
  body = JSON.stringify(take(input, {
229
166
  accountIds: [, (_) => _json(_), `accountIds`],
230
167
  }));
231
- return new __HttpRequest({
232
- protocol,
233
- hostname,
234
- port,
235
- method: "POST",
236
- headers,
237
- path: resolvedPath,
238
- body,
239
- });
168
+ b.m("POST").h(headers).b(body);
169
+ return b.build();
240
170
  };
241
171
  export const se_DeleteAllowListCommand = async (input, context) => {
242
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
172
+ const b = rb(input, context);
243
173
  const headers = {};
244
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/allow-lists/{id}";
245
- resolvedPath = __resolvedPath(resolvedPath, input, "id", () => input.id, "{id}", false);
174
+ b.bp("/allow-lists/{id}");
175
+ b.p("id", () => input.id, "{id}", false);
246
176
  const query = map({
247
- ignoreJobChecks: [, input.ignoreJobChecks],
177
+ [_iJC]: [, input[_iJC]],
248
178
  });
249
179
  let body;
250
- return new __HttpRequest({
251
- protocol,
252
- hostname,
253
- port,
254
- method: "DELETE",
255
- headers,
256
- path: resolvedPath,
257
- query,
258
- body,
259
- });
180
+ b.m("DELETE").h(headers).q(query).b(body);
181
+ return b.build();
260
182
  };
261
183
  export const se_DeleteCustomDataIdentifierCommand = async (input, context) => {
262
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
184
+ const b = rb(input, context);
263
185
  const headers = {};
264
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/custom-data-identifiers/{id}";
265
- resolvedPath = __resolvedPath(resolvedPath, input, "id", () => input.id, "{id}", false);
186
+ b.bp("/custom-data-identifiers/{id}");
187
+ b.p("id", () => input.id, "{id}", false);
266
188
  let body;
267
- return new __HttpRequest({
268
- protocol,
269
- hostname,
270
- port,
271
- method: "DELETE",
272
- headers,
273
- path: resolvedPath,
274
- body,
275
- });
189
+ b.m("DELETE").h(headers).b(body);
190
+ return b.build();
276
191
  };
277
192
  export const se_DeleteFindingsFilterCommand = async (input, context) => {
278
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
193
+ const b = rb(input, context);
279
194
  const headers = {};
280
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/findingsfilters/{id}";
281
- resolvedPath = __resolvedPath(resolvedPath, input, "id", () => input.id, "{id}", false);
195
+ b.bp("/findingsfilters/{id}");
196
+ b.p("id", () => input.id, "{id}", false);
282
197
  let body;
283
- return new __HttpRequest({
284
- protocol,
285
- hostname,
286
- port,
287
- method: "DELETE",
288
- headers,
289
- path: resolvedPath,
290
- body,
291
- });
198
+ b.m("DELETE").h(headers).b(body);
199
+ return b.build();
292
200
  };
293
201
  export const se_DeleteInvitationsCommand = async (input, context) => {
294
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
202
+ const b = rb(input, context);
295
203
  const headers = {
296
204
  "content-type": "application/json",
297
205
  };
298
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/invitations/delete";
206
+ b.bp("/invitations/delete");
299
207
  let body;
300
208
  body = JSON.stringify(take(input, {
301
209
  accountIds: [, (_) => _json(_), `accountIds`],
302
210
  }));
303
- return new __HttpRequest({
304
- protocol,
305
- hostname,
306
- port,
307
- method: "POST",
308
- headers,
309
- path: resolvedPath,
310
- body,
311
- });
211
+ b.m("POST").h(headers).b(body);
212
+ return b.build();
312
213
  };
313
214
  export const se_DeleteMemberCommand = async (input, context) => {
314
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
215
+ const b = rb(input, context);
315
216
  const headers = {};
316
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/members/{id}";
317
- resolvedPath = __resolvedPath(resolvedPath, input, "id", () => input.id, "{id}", false);
217
+ b.bp("/members/{id}");
218
+ b.p("id", () => input.id, "{id}", false);
318
219
  let body;
319
- return new __HttpRequest({
320
- protocol,
321
- hostname,
322
- port,
323
- method: "DELETE",
324
- headers,
325
- path: resolvedPath,
326
- body,
327
- });
220
+ b.m("DELETE").h(headers).b(body);
221
+ return b.build();
328
222
  };
329
223
  export const se_DescribeBucketsCommand = async (input, context) => {
330
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
224
+ const b = rb(input, context);
331
225
  const headers = {
332
226
  "content-type": "application/json",
333
227
  };
334
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/datasources/s3";
228
+ b.bp("/datasources/s3");
335
229
  let body;
336
230
  body = JSON.stringify(take(input, {
337
231
  criteria: [, (_) => se_BucketCriteria(_, context), `criteria`],
@@ -339,365 +233,224 @@ export const se_DescribeBucketsCommand = async (input, context) => {
339
233
  nextToken: [, , `nextToken`],
340
234
  sortCriteria: [, (_) => se_BucketSortCriteria(_, context), `sortCriteria`],
341
235
  }));
342
- return new __HttpRequest({
343
- protocol,
344
- hostname,
345
- port,
346
- method: "POST",
347
- headers,
348
- path: resolvedPath,
349
- body,
350
- });
236
+ b.m("POST").h(headers).b(body);
237
+ return b.build();
351
238
  };
352
239
  export const se_DescribeClassificationJobCommand = async (input, context) => {
353
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
240
+ const b = rb(input, context);
354
241
  const headers = {};
355
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/jobs/{jobId}";
356
- resolvedPath = __resolvedPath(resolvedPath, input, "jobId", () => input.jobId, "{jobId}", false);
242
+ b.bp("/jobs/{jobId}");
243
+ b.p("jobId", () => input.jobId, "{jobId}", false);
357
244
  let body;
358
- return new __HttpRequest({
359
- protocol,
360
- hostname,
361
- port,
362
- method: "GET",
363
- headers,
364
- path: resolvedPath,
365
- body,
366
- });
245
+ b.m("GET").h(headers).b(body);
246
+ return b.build();
367
247
  };
368
248
  export const se_DescribeOrganizationConfigurationCommand = async (input, context) => {
369
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
249
+ const b = rb(input, context);
370
250
  const headers = {
371
251
  "content-type": "application/json",
372
252
  };
373
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/admin/configuration";
253
+ b.bp("/admin/configuration");
374
254
  let body;
375
255
  body = "";
376
- return new __HttpRequest({
377
- protocol,
378
- hostname,
379
- port,
380
- method: "GET",
381
- headers,
382
- path: resolvedPath,
383
- body,
384
- });
256
+ b.m("GET").h(headers).b(body);
257
+ return b.build();
385
258
  };
386
259
  export const se_DisableMacieCommand = async (input, context) => {
387
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
260
+ const b = rb(input, context);
388
261
  const headers = {
389
262
  "content-type": "application/json",
390
263
  };
391
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/macie";
264
+ b.bp("/macie");
392
265
  let body;
393
266
  body = "";
394
- return new __HttpRequest({
395
- protocol,
396
- hostname,
397
- port,
398
- method: "DELETE",
399
- headers,
400
- path: resolvedPath,
401
- body,
402
- });
267
+ b.m("DELETE").h(headers).b(body);
268
+ return b.build();
403
269
  };
404
270
  export const se_DisableOrganizationAdminAccountCommand = async (input, context) => {
405
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
271
+ const b = rb(input, context);
406
272
  const headers = {};
407
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/admin";
273
+ b.bp("/admin");
408
274
  const query = map({
409
- adminAccountId: [, __expectNonNull(input.adminAccountId, `adminAccountId`)],
275
+ [_aAI]: [, __expectNonNull(input[_aAI], `adminAccountId`)],
410
276
  });
411
277
  let body;
412
- return new __HttpRequest({
413
- protocol,
414
- hostname,
415
- port,
416
- method: "DELETE",
417
- headers,
418
- path: resolvedPath,
419
- query,
420
- body,
421
- });
278
+ b.m("DELETE").h(headers).q(query).b(body);
279
+ return b.build();
422
280
  };
423
281
  export const se_DisassociateFromAdministratorAccountCommand = async (input, context) => {
424
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
282
+ const b = rb(input, context);
425
283
  const headers = {
426
284
  "content-type": "application/json",
427
285
  };
428
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/administrator/disassociate";
286
+ b.bp("/administrator/disassociate");
429
287
  let body;
430
288
  body = "";
431
- return new __HttpRequest({
432
- protocol,
433
- hostname,
434
- port,
435
- method: "POST",
436
- headers,
437
- path: resolvedPath,
438
- body,
439
- });
289
+ b.m("POST").h(headers).b(body);
290
+ return b.build();
440
291
  };
441
292
  export const se_DisassociateFromMasterAccountCommand = async (input, context) => {
442
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
293
+ const b = rb(input, context);
443
294
  const headers = {
444
295
  "content-type": "application/json",
445
296
  };
446
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/master/disassociate";
297
+ b.bp("/master/disassociate");
447
298
  let body;
448
299
  body = "";
449
- return new __HttpRequest({
450
- protocol,
451
- hostname,
452
- port,
453
- method: "POST",
454
- headers,
455
- path: resolvedPath,
456
- body,
457
- });
300
+ b.m("POST").h(headers).b(body);
301
+ return b.build();
458
302
  };
459
303
  export const se_DisassociateMemberCommand = async (input, context) => {
460
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
304
+ const b = rb(input, context);
461
305
  const headers = {};
462
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/members/disassociate/{id}";
463
- resolvedPath = __resolvedPath(resolvedPath, input, "id", () => input.id, "{id}", false);
306
+ b.bp("/members/disassociate/{id}");
307
+ b.p("id", () => input.id, "{id}", false);
464
308
  let body;
465
- return new __HttpRequest({
466
- protocol,
467
- hostname,
468
- port,
469
- method: "POST",
470
- headers,
471
- path: resolvedPath,
472
- body,
473
- });
309
+ b.m("POST").h(headers).b(body);
310
+ return b.build();
474
311
  };
475
312
  export const se_EnableMacieCommand = async (input, context) => {
476
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
313
+ const b = rb(input, context);
477
314
  const headers = {
478
315
  "content-type": "application/json",
479
316
  };
480
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/macie";
317
+ b.bp("/macie");
481
318
  let body;
482
319
  body = JSON.stringify(take(input, {
483
320
  clientToken: [true, (_) => _ ?? generateIdempotencyToken(), `clientToken`],
484
321
  findingPublishingFrequency: [, , `findingPublishingFrequency`],
485
322
  status: [, , `status`],
486
323
  }));
487
- return new __HttpRequest({
488
- protocol,
489
- hostname,
490
- port,
491
- method: "POST",
492
- headers,
493
- path: resolvedPath,
494
- body,
495
- });
324
+ b.m("POST").h(headers).b(body);
325
+ return b.build();
496
326
  };
497
327
  export const se_EnableOrganizationAdminAccountCommand = async (input, context) => {
498
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
328
+ const b = rb(input, context);
499
329
  const headers = {
500
330
  "content-type": "application/json",
501
331
  };
502
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/admin";
332
+ b.bp("/admin");
503
333
  let body;
504
334
  body = JSON.stringify(take(input, {
505
335
  adminAccountId: [, , `adminAccountId`],
506
336
  clientToken: [true, (_) => _ ?? generateIdempotencyToken(), `clientToken`],
507
337
  }));
508
- return new __HttpRequest({
509
- protocol,
510
- hostname,
511
- port,
512
- method: "POST",
513
- headers,
514
- path: resolvedPath,
515
- body,
516
- });
338
+ b.m("POST").h(headers).b(body);
339
+ return b.build();
517
340
  };
518
341
  export const se_GetAdministratorAccountCommand = async (input, context) => {
519
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
342
+ const b = rb(input, context);
520
343
  const headers = {
521
344
  "content-type": "application/json",
522
345
  };
523
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/administrator";
346
+ b.bp("/administrator");
524
347
  let body;
525
348
  body = "";
526
- return new __HttpRequest({
527
- protocol,
528
- hostname,
529
- port,
530
- method: "GET",
531
- headers,
532
- path: resolvedPath,
533
- body,
534
- });
349
+ b.m("GET").h(headers).b(body);
350
+ return b.build();
535
351
  };
536
352
  export const se_GetAllowListCommand = async (input, context) => {
537
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
353
+ const b = rb(input, context);
538
354
  const headers = {};
539
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/allow-lists/{id}";
540
- resolvedPath = __resolvedPath(resolvedPath, input, "id", () => input.id, "{id}", false);
355
+ b.bp("/allow-lists/{id}");
356
+ b.p("id", () => input.id, "{id}", false);
541
357
  let body;
542
- return new __HttpRequest({
543
- protocol,
544
- hostname,
545
- port,
546
- method: "GET",
547
- headers,
548
- path: resolvedPath,
549
- body,
550
- });
358
+ b.m("GET").h(headers).b(body);
359
+ return b.build();
551
360
  };
552
361
  export const se_GetAutomatedDiscoveryConfigurationCommand = async (input, context) => {
553
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
362
+ const b = rb(input, context);
554
363
  const headers = {
555
364
  "content-type": "application/json",
556
365
  };
557
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/automated-discovery/configuration";
366
+ b.bp("/automated-discovery/configuration");
558
367
  let body;
559
368
  body = "";
560
- return new __HttpRequest({
561
- protocol,
562
- hostname,
563
- port,
564
- method: "GET",
565
- headers,
566
- path: resolvedPath,
567
- body,
568
- });
369
+ b.m("GET").h(headers).b(body);
370
+ return b.build();
569
371
  };
570
372
  export const se_GetBucketStatisticsCommand = async (input, context) => {
571
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
373
+ const b = rb(input, context);
572
374
  const headers = {
573
375
  "content-type": "application/json",
574
376
  };
575
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/datasources/s3/statistics";
377
+ b.bp("/datasources/s3/statistics");
576
378
  let body;
577
379
  body = JSON.stringify(take(input, {
578
380
  accountId: [, , `accountId`],
579
381
  }));
580
- return new __HttpRequest({
581
- protocol,
582
- hostname,
583
- port,
584
- method: "POST",
585
- headers,
586
- path: resolvedPath,
587
- body,
588
- });
382
+ b.m("POST").h(headers).b(body);
383
+ return b.build();
589
384
  };
590
385
  export const se_GetClassificationExportConfigurationCommand = async (input, context) => {
591
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
386
+ const b = rb(input, context);
592
387
  const headers = {
593
388
  "content-type": "application/json",
594
389
  };
595
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/classification-export-configuration";
390
+ b.bp("/classification-export-configuration");
596
391
  let body;
597
392
  body = "";
598
- return new __HttpRequest({
599
- protocol,
600
- hostname,
601
- port,
602
- method: "GET",
603
- headers,
604
- path: resolvedPath,
605
- body,
606
- });
393
+ b.m("GET").h(headers).b(body);
394
+ return b.build();
607
395
  };
608
396
  export const se_GetClassificationScopeCommand = async (input, context) => {
609
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
397
+ const b = rb(input, context);
610
398
  const headers = {};
611
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/classification-scopes/{id}";
612
- resolvedPath = __resolvedPath(resolvedPath, input, "id", () => input.id, "{id}", false);
399
+ b.bp("/classification-scopes/{id}");
400
+ b.p("id", () => input.id, "{id}", false);
613
401
  let body;
614
- return new __HttpRequest({
615
- protocol,
616
- hostname,
617
- port,
618
- method: "GET",
619
- headers,
620
- path: resolvedPath,
621
- body,
622
- });
402
+ b.m("GET").h(headers).b(body);
403
+ return b.build();
623
404
  };
624
405
  export const se_GetCustomDataIdentifierCommand = async (input, context) => {
625
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
406
+ const b = rb(input, context);
626
407
  const headers = {};
627
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/custom-data-identifiers/{id}";
628
- resolvedPath = __resolvedPath(resolvedPath, input, "id", () => input.id, "{id}", false);
408
+ b.bp("/custom-data-identifiers/{id}");
409
+ b.p("id", () => input.id, "{id}", false);
629
410
  let body;
630
- return new __HttpRequest({
631
- protocol,
632
- hostname,
633
- port,
634
- method: "GET",
635
- headers,
636
- path: resolvedPath,
637
- body,
638
- });
411
+ b.m("GET").h(headers).b(body);
412
+ return b.build();
639
413
  };
640
414
  export const se_GetFindingsCommand = async (input, context) => {
641
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
415
+ const b = rb(input, context);
642
416
  const headers = {
643
417
  "content-type": "application/json",
644
418
  };
645
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/findings/describe";
419
+ b.bp("/findings/describe");
646
420
  let body;
647
421
  body = JSON.stringify(take(input, {
648
422
  findingIds: [, (_) => _json(_), `findingIds`],
649
423
  sortCriteria: [, (_) => se_SortCriteria(_, context), `sortCriteria`],
650
424
  }));
651
- return new __HttpRequest({
652
- protocol,
653
- hostname,
654
- port,
655
- method: "POST",
656
- headers,
657
- path: resolvedPath,
658
- body,
659
- });
425
+ b.m("POST").h(headers).b(body);
426
+ return b.build();
660
427
  };
661
428
  export const se_GetFindingsFilterCommand = async (input, context) => {
662
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
429
+ const b = rb(input, context);
663
430
  const headers = {};
664
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/findingsfilters/{id}";
665
- resolvedPath = __resolvedPath(resolvedPath, input, "id", () => input.id, "{id}", false);
431
+ b.bp("/findingsfilters/{id}");
432
+ b.p("id", () => input.id, "{id}", false);
666
433
  let body;
667
- return new __HttpRequest({
668
- protocol,
669
- hostname,
670
- port,
671
- method: "GET",
672
- headers,
673
- path: resolvedPath,
674
- body,
675
- });
434
+ b.m("GET").h(headers).b(body);
435
+ return b.build();
676
436
  };
677
437
  export const se_GetFindingsPublicationConfigurationCommand = async (input, context) => {
678
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
438
+ const b = rb(input, context);
679
439
  const headers = {
680
440
  "content-type": "application/json",
681
441
  };
682
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/findings-publication-configuration";
442
+ b.bp("/findings-publication-configuration");
683
443
  let body;
684
444
  body = "";
685
- return new __HttpRequest({
686
- protocol,
687
- hostname,
688
- port,
689
- method: "GET",
690
- headers,
691
- path: resolvedPath,
692
- body,
693
- });
445
+ b.m("GET").h(headers).b(body);
446
+ return b.build();
694
447
  };
695
448
  export const se_GetFindingStatisticsCommand = async (input, context) => {
696
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
449
+ const b = rb(input, context);
697
450
  const headers = {
698
451
  "content-type": "application/json",
699
452
  };
700
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/findings/statistics";
453
+ b.bp("/findings/statistics");
701
454
  let body;
702
455
  body = JSON.stringify(take(input, {
703
456
  findingCriteria: [, (_) => se_FindingCriteria(_, context), `findingCriteria`],
@@ -705,177 +458,106 @@ export const se_GetFindingStatisticsCommand = async (input, context) => {
705
458
  size: [, , `size`],
706
459
  sortCriteria: [, (_) => se_FindingStatisticsSortCriteria(_, context), `sortCriteria`],
707
460
  }));
708
- return new __HttpRequest({
709
- protocol,
710
- hostname,
711
- port,
712
- method: "POST",
713
- headers,
714
- path: resolvedPath,
715
- body,
716
- });
461
+ b.m("POST").h(headers).b(body);
462
+ return b.build();
717
463
  };
718
464
  export const se_GetInvitationsCountCommand = async (input, context) => {
719
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
465
+ const b = rb(input, context);
720
466
  const headers = {
721
467
  "content-type": "application/json",
722
468
  };
723
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/invitations/count";
469
+ b.bp("/invitations/count");
724
470
  let body;
725
471
  body = "";
726
- return new __HttpRequest({
727
- protocol,
728
- hostname,
729
- port,
730
- method: "GET",
731
- headers,
732
- path: resolvedPath,
733
- body,
734
- });
472
+ b.m("GET").h(headers).b(body);
473
+ return b.build();
735
474
  };
736
475
  export const se_GetMacieSessionCommand = async (input, context) => {
737
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
476
+ const b = rb(input, context);
738
477
  const headers = {
739
478
  "content-type": "application/json",
740
479
  };
741
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/macie";
480
+ b.bp("/macie");
742
481
  let body;
743
482
  body = "";
744
- return new __HttpRequest({
745
- protocol,
746
- hostname,
747
- port,
748
- method: "GET",
749
- headers,
750
- path: resolvedPath,
751
- body,
752
- });
483
+ b.m("GET").h(headers).b(body);
484
+ return b.build();
753
485
  };
754
486
  export const se_GetMasterAccountCommand = async (input, context) => {
755
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
487
+ const b = rb(input, context);
756
488
  const headers = {
757
489
  "content-type": "application/json",
758
490
  };
759
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/master";
491
+ b.bp("/master");
760
492
  let body;
761
493
  body = "";
762
- return new __HttpRequest({
763
- protocol,
764
- hostname,
765
- port,
766
- method: "GET",
767
- headers,
768
- path: resolvedPath,
769
- body,
770
- });
494
+ b.m("GET").h(headers).b(body);
495
+ return b.build();
771
496
  };
772
497
  export const se_GetMemberCommand = async (input, context) => {
773
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
498
+ const b = rb(input, context);
774
499
  const headers = {};
775
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/members/{id}";
776
- resolvedPath = __resolvedPath(resolvedPath, input, "id", () => input.id, "{id}", false);
500
+ b.bp("/members/{id}");
501
+ b.p("id", () => input.id, "{id}", false);
777
502
  let body;
778
- return new __HttpRequest({
779
- protocol,
780
- hostname,
781
- port,
782
- method: "GET",
783
- headers,
784
- path: resolvedPath,
785
- body,
786
- });
503
+ b.m("GET").h(headers).b(body);
504
+ return b.build();
787
505
  };
788
506
  export const se_GetResourceProfileCommand = async (input, context) => {
789
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
507
+ const b = rb(input, context);
790
508
  const headers = {};
791
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/resource-profiles";
509
+ b.bp("/resource-profiles");
792
510
  const query = map({
793
- resourceArn: [, __expectNonNull(input.resourceArn, `resourceArn`)],
511
+ [_rA]: [, __expectNonNull(input[_rA], `resourceArn`)],
794
512
  });
795
513
  let body;
796
- return new __HttpRequest({
797
- protocol,
798
- hostname,
799
- port,
800
- method: "GET",
801
- headers,
802
- path: resolvedPath,
803
- query,
804
- body,
805
- });
514
+ b.m("GET").h(headers).q(query).b(body);
515
+ return b.build();
806
516
  };
807
517
  export const se_GetRevealConfigurationCommand = async (input, context) => {
808
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
518
+ const b = rb(input, context);
809
519
  const headers = {
810
520
  "content-type": "application/json",
811
521
  };
812
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/reveal-configuration";
522
+ b.bp("/reveal-configuration");
813
523
  let body;
814
524
  body = "";
815
- return new __HttpRequest({
816
- protocol,
817
- hostname,
818
- port,
819
- method: "GET",
820
- headers,
821
- path: resolvedPath,
822
- body,
823
- });
525
+ b.m("GET").h(headers).b(body);
526
+ return b.build();
824
527
  };
825
528
  export const se_GetSensitiveDataOccurrencesCommand = async (input, context) => {
826
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
529
+ const b = rb(input, context);
827
530
  const headers = {};
828
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/findings/{findingId}/reveal";
829
- resolvedPath = __resolvedPath(resolvedPath, input, "findingId", () => input.findingId, "{findingId}", false);
531
+ b.bp("/findings/{findingId}/reveal");
532
+ b.p("findingId", () => input.findingId, "{findingId}", false);
830
533
  let body;
831
- return new __HttpRequest({
832
- protocol,
833
- hostname,
834
- port,
835
- method: "GET",
836
- headers,
837
- path: resolvedPath,
838
- body,
839
- });
534
+ b.m("GET").h(headers).b(body);
535
+ return b.build();
840
536
  };
841
537
  export const se_GetSensitiveDataOccurrencesAvailabilityCommand = async (input, context) => {
842
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
538
+ const b = rb(input, context);
843
539
  const headers = {};
844
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/findings/{findingId}/reveal/availability";
845
- resolvedPath = __resolvedPath(resolvedPath, input, "findingId", () => input.findingId, "{findingId}", false);
540
+ b.bp("/findings/{findingId}/reveal/availability");
541
+ b.p("findingId", () => input.findingId, "{findingId}", false);
846
542
  let body;
847
- return new __HttpRequest({
848
- protocol,
849
- hostname,
850
- port,
851
- method: "GET",
852
- headers,
853
- path: resolvedPath,
854
- body,
855
- });
543
+ b.m("GET").h(headers).b(body);
544
+ return b.build();
856
545
  };
857
546
  export const se_GetSensitivityInspectionTemplateCommand = async (input, context) => {
858
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
547
+ const b = rb(input, context);
859
548
  const headers = {};
860
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/templates/sensitivity-inspections/{id}";
861
- resolvedPath = __resolvedPath(resolvedPath, input, "id", () => input.id, "{id}", false);
549
+ b.bp("/templates/sensitivity-inspections/{id}");
550
+ b.p("id", () => input.id, "{id}", false);
862
551
  let body;
863
- return new __HttpRequest({
864
- protocol,
865
- hostname,
866
- port,
867
- method: "GET",
868
- headers,
869
- path: resolvedPath,
870
- body,
871
- });
552
+ b.m("GET").h(headers).b(body);
553
+ return b.build();
872
554
  };
873
555
  export const se_GetUsageStatisticsCommand = async (input, context) => {
874
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
556
+ const b = rb(input, context);
875
557
  const headers = {
876
558
  "content-type": "application/json",
877
559
  };
878
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/usage/statistics";
560
+ b.bp("/usage/statistics");
879
561
  let body;
880
562
  body = JSON.stringify(take(input, {
881
563
  filterBy: [, (_) => se___listOfUsageStatisticsFilter(_, context), `filterBy`],
@@ -884,61 +566,38 @@ export const se_GetUsageStatisticsCommand = async (input, context) => {
884
566
  sortBy: [, (_) => se_UsageStatisticsSortBy(_, context), `sortBy`],
885
567
  timeRange: [, , `timeRange`],
886
568
  }));
887
- return new __HttpRequest({
888
- protocol,
889
- hostname,
890
- port,
891
- method: "POST",
892
- headers,
893
- path: resolvedPath,
894
- body,
895
- });
569
+ b.m("POST").h(headers).b(body);
570
+ return b.build();
896
571
  };
897
572
  export const se_GetUsageTotalsCommand = async (input, context) => {
898
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
573
+ const b = rb(input, context);
899
574
  const headers = {};
900
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/usage";
575
+ b.bp("/usage");
901
576
  const query = map({
902
- timeRange: [, input.timeRange],
577
+ [_tR]: [, input[_tR]],
903
578
  });
904
579
  let body;
905
- return new __HttpRequest({
906
- protocol,
907
- hostname,
908
- port,
909
- method: "GET",
910
- headers,
911
- path: resolvedPath,
912
- query,
913
- body,
914
- });
580
+ b.m("GET").h(headers).q(query).b(body);
581
+ return b.build();
915
582
  };
916
583
  export const se_ListAllowListsCommand = async (input, context) => {
917
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
584
+ const b = rb(input, context);
918
585
  const headers = {};
919
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/allow-lists";
586
+ b.bp("/allow-lists");
920
587
  const query = map({
921
- maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
922
- nextToken: [, input.nextToken],
588
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
589
+ [_nT]: [, input[_nT]],
923
590
  });
924
591
  let body;
925
- return new __HttpRequest({
926
- protocol,
927
- hostname,
928
- port,
929
- method: "GET",
930
- headers,
931
- path: resolvedPath,
932
- query,
933
- body,
934
- });
592
+ b.m("GET").h(headers).q(query).b(body);
593
+ return b.build();
935
594
  };
936
595
  export const se_ListClassificationJobsCommand = async (input, context) => {
937
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
596
+ const b = rb(input, context);
938
597
  const headers = {
939
598
  "content-type": "application/json",
940
599
  };
941
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/jobs/list";
600
+ b.bp("/jobs/list");
942
601
  let body;
943
602
  body = JSON.stringify(take(input, {
944
603
  filterCriteria: [, (_) => se_ListJobsFilterCriteria(_, context), `filterCriteria`],
@@ -946,63 +605,41 @@ export const se_ListClassificationJobsCommand = async (input, context) => {
946
605
  nextToken: [, , `nextToken`],
947
606
  sortCriteria: [, (_) => se_ListJobsSortCriteria(_, context), `sortCriteria`],
948
607
  }));
949
- return new __HttpRequest({
950
- protocol,
951
- hostname,
952
- port,
953
- method: "POST",
954
- headers,
955
- path: resolvedPath,
956
- body,
957
- });
608
+ b.m("POST").h(headers).b(body);
609
+ return b.build();
958
610
  };
959
611
  export const se_ListClassificationScopesCommand = async (input, context) => {
960
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
612
+ const b = rb(input, context);
961
613
  const headers = {};
962
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/classification-scopes";
614
+ b.bp("/classification-scopes");
963
615
  const query = map({
964
- name: [, input.name],
965
- nextToken: [, input.nextToken],
616
+ [_n]: [, input[_n]],
617
+ [_nT]: [, input[_nT]],
966
618
  });
967
619
  let body;
968
- return new __HttpRequest({
969
- protocol,
970
- hostname,
971
- port,
972
- method: "GET",
973
- headers,
974
- path: resolvedPath,
975
- query,
976
- body,
977
- });
620
+ b.m("GET").h(headers).q(query).b(body);
621
+ return b.build();
978
622
  };
979
623
  export const se_ListCustomDataIdentifiersCommand = async (input, context) => {
980
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
624
+ const b = rb(input, context);
981
625
  const headers = {
982
626
  "content-type": "application/json",
983
627
  };
984
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/custom-data-identifiers/list";
628
+ b.bp("/custom-data-identifiers/list");
985
629
  let body;
986
630
  body = JSON.stringify(take(input, {
987
631
  maxResults: [, , `maxResults`],
988
632
  nextToken: [, , `nextToken`],
989
633
  }));
990
- return new __HttpRequest({
991
- protocol,
992
- hostname,
993
- port,
994
- method: "POST",
995
- headers,
996
- path: resolvedPath,
997
- body,
998
- });
634
+ b.m("POST").h(headers).b(body);
635
+ return b.build();
999
636
  };
1000
637
  export const se_ListFindingsCommand = async (input, context) => {
1001
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
638
+ const b = rb(input, context);
1002
639
  const headers = {
1003
640
  "content-type": "application/json",
1004
641
  };
1005
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/findings";
642
+ b.bp("/findings");
1006
643
  let body;
1007
644
  body = JSON.stringify(take(input, {
1008
645
  findingCriteria: [, (_) => se_FindingCriteria(_, context), `findingCriteria`],
@@ -1010,241 +647,150 @@ export const se_ListFindingsCommand = async (input, context) => {
1010
647
  nextToken: [, , `nextToken`],
1011
648
  sortCriteria: [, (_) => se_SortCriteria(_, context), `sortCriteria`],
1012
649
  }));
1013
- return new __HttpRequest({
1014
- protocol,
1015
- hostname,
1016
- port,
1017
- method: "POST",
1018
- headers,
1019
- path: resolvedPath,
1020
- body,
1021
- });
650
+ b.m("POST").h(headers).b(body);
651
+ return b.build();
1022
652
  };
1023
653
  export const se_ListFindingsFiltersCommand = async (input, context) => {
1024
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
654
+ const b = rb(input, context);
1025
655
  const headers = {};
1026
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/findingsfilters";
656
+ b.bp("/findingsfilters");
1027
657
  const query = map({
1028
- maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
1029
- nextToken: [, input.nextToken],
658
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
659
+ [_nT]: [, input[_nT]],
1030
660
  });
1031
661
  let body;
1032
- return new __HttpRequest({
1033
- protocol,
1034
- hostname,
1035
- port,
1036
- method: "GET",
1037
- headers,
1038
- path: resolvedPath,
1039
- query,
1040
- body,
1041
- });
662
+ b.m("GET").h(headers).q(query).b(body);
663
+ return b.build();
1042
664
  };
1043
665
  export const se_ListInvitationsCommand = async (input, context) => {
1044
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
666
+ const b = rb(input, context);
1045
667
  const headers = {};
1046
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/invitations";
668
+ b.bp("/invitations");
1047
669
  const query = map({
1048
- maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
1049
- nextToken: [, input.nextToken],
670
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
671
+ [_nT]: [, input[_nT]],
1050
672
  });
1051
673
  let body;
1052
- return new __HttpRequest({
1053
- protocol,
1054
- hostname,
1055
- port,
1056
- method: "GET",
1057
- headers,
1058
- path: resolvedPath,
1059
- query,
1060
- body,
1061
- });
674
+ b.m("GET").h(headers).q(query).b(body);
675
+ return b.build();
1062
676
  };
1063
677
  export const se_ListManagedDataIdentifiersCommand = async (input, context) => {
1064
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
678
+ const b = rb(input, context);
1065
679
  const headers = {
1066
680
  "content-type": "application/json",
1067
681
  };
1068
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/managed-data-identifiers/list";
682
+ b.bp("/managed-data-identifiers/list");
1069
683
  let body;
1070
684
  body = JSON.stringify(take(input, {
1071
685
  nextToken: [, , `nextToken`],
1072
686
  }));
1073
- return new __HttpRequest({
1074
- protocol,
1075
- hostname,
1076
- port,
1077
- method: "POST",
1078
- headers,
1079
- path: resolvedPath,
1080
- body,
1081
- });
687
+ b.m("POST").h(headers).b(body);
688
+ return b.build();
1082
689
  };
1083
690
  export const se_ListMembersCommand = async (input, context) => {
1084
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
691
+ const b = rb(input, context);
1085
692
  const headers = {};
1086
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/members";
693
+ b.bp("/members");
1087
694
  const query = map({
1088
- maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
1089
- nextToken: [, input.nextToken],
1090
- onlyAssociated: [, input.onlyAssociated],
695
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
696
+ [_nT]: [, input[_nT]],
697
+ [_oA]: [, input[_oA]],
1091
698
  });
1092
699
  let body;
1093
- return new __HttpRequest({
1094
- protocol,
1095
- hostname,
1096
- port,
1097
- method: "GET",
1098
- headers,
1099
- path: resolvedPath,
1100
- query,
1101
- body,
1102
- });
700
+ b.m("GET").h(headers).q(query).b(body);
701
+ return b.build();
1103
702
  };
1104
703
  export const se_ListOrganizationAdminAccountsCommand = async (input, context) => {
1105
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
704
+ const b = rb(input, context);
1106
705
  const headers = {};
1107
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/admin";
706
+ b.bp("/admin");
1108
707
  const query = map({
1109
- maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
1110
- nextToken: [, input.nextToken],
708
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
709
+ [_nT]: [, input[_nT]],
1111
710
  });
1112
711
  let body;
1113
- return new __HttpRequest({
1114
- protocol,
1115
- hostname,
1116
- port,
1117
- method: "GET",
1118
- headers,
1119
- path: resolvedPath,
1120
- query,
1121
- body,
1122
- });
712
+ b.m("GET").h(headers).q(query).b(body);
713
+ return b.build();
1123
714
  };
1124
715
  export const se_ListResourceProfileArtifactsCommand = async (input, context) => {
1125
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
716
+ const b = rb(input, context);
1126
717
  const headers = {};
1127
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/resource-profiles/artifacts";
718
+ b.bp("/resource-profiles/artifacts");
1128
719
  const query = map({
1129
- nextToken: [, input.nextToken],
1130
- resourceArn: [, __expectNonNull(input.resourceArn, `resourceArn`)],
720
+ [_nT]: [, input[_nT]],
721
+ [_rA]: [, __expectNonNull(input[_rA], `resourceArn`)],
1131
722
  });
1132
723
  let body;
1133
- return new __HttpRequest({
1134
- protocol,
1135
- hostname,
1136
- port,
1137
- method: "GET",
1138
- headers,
1139
- path: resolvedPath,
1140
- query,
1141
- body,
1142
- });
724
+ b.m("GET").h(headers).q(query).b(body);
725
+ return b.build();
1143
726
  };
1144
727
  export const se_ListResourceProfileDetectionsCommand = async (input, context) => {
1145
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
728
+ const b = rb(input, context);
1146
729
  const headers = {};
1147
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/resource-profiles/detections";
730
+ b.bp("/resource-profiles/detections");
1148
731
  const query = map({
1149
- maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
1150
- nextToken: [, input.nextToken],
1151
- resourceArn: [, __expectNonNull(input.resourceArn, `resourceArn`)],
732
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
733
+ [_nT]: [, input[_nT]],
734
+ [_rA]: [, __expectNonNull(input[_rA], `resourceArn`)],
1152
735
  });
1153
736
  let body;
1154
- return new __HttpRequest({
1155
- protocol,
1156
- hostname,
1157
- port,
1158
- method: "GET",
1159
- headers,
1160
- path: resolvedPath,
1161
- query,
1162
- body,
1163
- });
737
+ b.m("GET").h(headers).q(query).b(body);
738
+ return b.build();
1164
739
  };
1165
740
  export const se_ListSensitivityInspectionTemplatesCommand = async (input, context) => {
1166
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
741
+ const b = rb(input, context);
1167
742
  const headers = {};
1168
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/templates/sensitivity-inspections";
743
+ b.bp("/templates/sensitivity-inspections");
1169
744
  const query = map({
1170
- maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
1171
- nextToken: [, input.nextToken],
745
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
746
+ [_nT]: [, input[_nT]],
1172
747
  });
1173
748
  let body;
1174
- return new __HttpRequest({
1175
- protocol,
1176
- hostname,
1177
- port,
1178
- method: "GET",
1179
- headers,
1180
- path: resolvedPath,
1181
- query,
1182
- body,
1183
- });
749
+ b.m("GET").h(headers).q(query).b(body);
750
+ return b.build();
1184
751
  };
1185
752
  export const se_ListTagsForResourceCommand = async (input, context) => {
1186
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
753
+ const b = rb(input, context);
1187
754
  const headers = {};
1188
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{resourceArn}";
1189
- resolvedPath = __resolvedPath(resolvedPath, input, "resourceArn", () => input.resourceArn, "{resourceArn}", false);
755
+ b.bp("/tags/{resourceArn}");
756
+ b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
1190
757
  let body;
1191
- return new __HttpRequest({
1192
- protocol,
1193
- hostname,
1194
- port,
1195
- method: "GET",
1196
- headers,
1197
- path: resolvedPath,
1198
- body,
1199
- });
758
+ b.m("GET").h(headers).b(body);
759
+ return b.build();
1200
760
  };
1201
761
  export const se_PutClassificationExportConfigurationCommand = async (input, context) => {
1202
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
762
+ const b = rb(input, context);
1203
763
  const headers = {
1204
764
  "content-type": "application/json",
1205
765
  };
1206
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/classification-export-configuration";
766
+ b.bp("/classification-export-configuration");
1207
767
  let body;
1208
768
  body = JSON.stringify(take(input, {
1209
769
  configuration: [, (_) => se_ClassificationExportConfiguration(_, context), `configuration`],
1210
770
  }));
1211
- return new __HttpRequest({
1212
- protocol,
1213
- hostname,
1214
- port,
1215
- method: "PUT",
1216
- headers,
1217
- path: resolvedPath,
1218
- body,
1219
- });
771
+ b.m("PUT").h(headers).b(body);
772
+ return b.build();
1220
773
  };
1221
774
  export const se_PutFindingsPublicationConfigurationCommand = async (input, context) => {
1222
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
775
+ const b = rb(input, context);
1223
776
  const headers = {
1224
777
  "content-type": "application/json",
1225
778
  };
1226
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/findings-publication-configuration";
779
+ b.bp("/findings-publication-configuration");
1227
780
  let body;
1228
781
  body = JSON.stringify(take(input, {
1229
782
  clientToken: [true, (_) => _ ?? generateIdempotencyToken(), `clientToken`],
1230
783
  securityHubConfiguration: [, (_) => se_SecurityHubConfiguration(_, context), `securityHubConfiguration`],
1231
784
  }));
1232
- return new __HttpRequest({
1233
- protocol,
1234
- hostname,
1235
- port,
1236
- method: "PUT",
1237
- headers,
1238
- path: resolvedPath,
1239
- body,
1240
- });
785
+ b.m("PUT").h(headers).b(body);
786
+ return b.build();
1241
787
  };
1242
788
  export const se_SearchResourcesCommand = async (input, context) => {
1243
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
789
+ const b = rb(input, context);
1244
790
  const headers = {
1245
791
  "content-type": "application/json",
1246
792
  };
1247
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/datasources/search-resources";
793
+ b.bp("/datasources/search-resources");
1248
794
  let body;
1249
795
  body = JSON.stringify(take(input, {
1250
796
  bucketCriteria: [, (_) => se_SearchResourcesBucketCriteria(_, context), `bucketCriteria`],
@@ -1252,43 +798,29 @@ export const se_SearchResourcesCommand = async (input, context) => {
1252
798
  nextToken: [, , `nextToken`],
1253
799
  sortCriteria: [, (_) => se_SearchResourcesSortCriteria(_, context), `sortCriteria`],
1254
800
  }));
1255
- return new __HttpRequest({
1256
- protocol,
1257
- hostname,
1258
- port,
1259
- method: "POST",
1260
- headers,
1261
- path: resolvedPath,
1262
- body,
1263
- });
801
+ b.m("POST").h(headers).b(body);
802
+ return b.build();
1264
803
  };
1265
804
  export const se_TagResourceCommand = async (input, context) => {
1266
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
805
+ const b = rb(input, context);
1267
806
  const headers = {
1268
807
  "content-type": "application/json",
1269
808
  };
1270
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{resourceArn}";
1271
- resolvedPath = __resolvedPath(resolvedPath, input, "resourceArn", () => input.resourceArn, "{resourceArn}", false);
809
+ b.bp("/tags/{resourceArn}");
810
+ b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
1272
811
  let body;
1273
812
  body = JSON.stringify(take(input, {
1274
813
  tags: [, (_) => _json(_), `tags`],
1275
814
  }));
1276
- return new __HttpRequest({
1277
- protocol,
1278
- hostname,
1279
- port,
1280
- method: "POST",
1281
- headers,
1282
- path: resolvedPath,
1283
- body,
1284
- });
815
+ b.m("POST").h(headers).b(body);
816
+ return b.build();
1285
817
  };
1286
818
  export const se_TestCustomDataIdentifierCommand = async (input, context) => {
1287
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
819
+ const b = rb(input, context);
1288
820
  const headers = {
1289
821
  "content-type": "application/json",
1290
822
  };
1291
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/custom-data-identifiers/test";
823
+ b.bp("/custom-data-identifiers/test");
1292
824
  let body;
1293
825
  body = JSON.stringify(take(input, {
1294
826
  ignoreWords: [, (_) => _json(_), `ignoreWords`],
@@ -1297,131 +829,88 @@ export const se_TestCustomDataIdentifierCommand = async (input, context) => {
1297
829
  regex: [, , `regex`],
1298
830
  sampleText: [, , `sampleText`],
1299
831
  }));
1300
- return new __HttpRequest({
1301
- protocol,
1302
- hostname,
1303
- port,
1304
- method: "POST",
1305
- headers,
1306
- path: resolvedPath,
1307
- body,
1308
- });
832
+ b.m("POST").h(headers).b(body);
833
+ return b.build();
1309
834
  };
1310
835
  export const se_UntagResourceCommand = async (input, context) => {
1311
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
836
+ const b = rb(input, context);
1312
837
  const headers = {};
1313
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{resourceArn}";
1314
- resolvedPath = __resolvedPath(resolvedPath, input, "resourceArn", () => input.resourceArn, "{resourceArn}", false);
838
+ b.bp("/tags/{resourceArn}");
839
+ b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
1315
840
  const query = map({
1316
- tagKeys: [
841
+ [_tK]: [
1317
842
  __expectNonNull(input.tagKeys, `tagKeys`) != null,
1318
- () => (input.tagKeys || []).map((_entry) => _entry),
843
+ () => (input[_tK] || []).map((_entry) => _entry),
1319
844
  ],
1320
845
  });
1321
846
  let body;
1322
- return new __HttpRequest({
1323
- protocol,
1324
- hostname,
1325
- port,
1326
- method: "DELETE",
1327
- headers,
1328
- path: resolvedPath,
1329
- query,
1330
- body,
1331
- });
847
+ b.m("DELETE").h(headers).q(query).b(body);
848
+ return b.build();
1332
849
  };
1333
850
  export const se_UpdateAllowListCommand = async (input, context) => {
1334
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
851
+ const b = rb(input, context);
1335
852
  const headers = {
1336
853
  "content-type": "application/json",
1337
854
  };
1338
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/allow-lists/{id}";
1339
- resolvedPath = __resolvedPath(resolvedPath, input, "id", () => input.id, "{id}", false);
855
+ b.bp("/allow-lists/{id}");
856
+ b.p("id", () => input.id, "{id}", false);
1340
857
  let body;
1341
858
  body = JSON.stringify(take(input, {
1342
859
  criteria: [, (_) => se_AllowListCriteria(_, context), `criteria`],
1343
860
  description: [, , `description`],
1344
861
  name: [, , `name`],
1345
862
  }));
1346
- return new __HttpRequest({
1347
- protocol,
1348
- hostname,
1349
- port,
1350
- method: "PUT",
1351
- headers,
1352
- path: resolvedPath,
1353
- body,
1354
- });
863
+ b.m("PUT").h(headers).b(body);
864
+ return b.build();
1355
865
  };
1356
866
  export const se_UpdateAutomatedDiscoveryConfigurationCommand = async (input, context) => {
1357
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
867
+ const b = rb(input, context);
1358
868
  const headers = {
1359
869
  "content-type": "application/json",
1360
870
  };
1361
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/automated-discovery/configuration";
871
+ b.bp("/automated-discovery/configuration");
1362
872
  let body;
1363
873
  body = JSON.stringify(take(input, {
1364
874
  status: [, , `status`],
1365
875
  }));
1366
- return new __HttpRequest({
1367
- protocol,
1368
- hostname,
1369
- port,
1370
- method: "PUT",
1371
- headers,
1372
- path: resolvedPath,
1373
- body,
1374
- });
876
+ b.m("PUT").h(headers).b(body);
877
+ return b.build();
1375
878
  };
1376
879
  export const se_UpdateClassificationJobCommand = async (input, context) => {
1377
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
880
+ const b = rb(input, context);
1378
881
  const headers = {
1379
882
  "content-type": "application/json",
1380
883
  };
1381
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/jobs/{jobId}";
1382
- resolvedPath = __resolvedPath(resolvedPath, input, "jobId", () => input.jobId, "{jobId}", false);
884
+ b.bp("/jobs/{jobId}");
885
+ b.p("jobId", () => input.jobId, "{jobId}", false);
1383
886
  let body;
1384
887
  body = JSON.stringify(take(input, {
1385
888
  jobStatus: [, , `jobStatus`],
1386
889
  }));
1387
- return new __HttpRequest({
1388
- protocol,
1389
- hostname,
1390
- port,
1391
- method: "PATCH",
1392
- headers,
1393
- path: resolvedPath,
1394
- body,
1395
- });
890
+ b.m("PATCH").h(headers).b(body);
891
+ return b.build();
1396
892
  };
1397
893
  export const se_UpdateClassificationScopeCommand = async (input, context) => {
1398
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
894
+ const b = rb(input, context);
1399
895
  const headers = {
1400
896
  "content-type": "application/json",
1401
897
  };
1402
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/classification-scopes/{id}";
1403
- resolvedPath = __resolvedPath(resolvedPath, input, "id", () => input.id, "{id}", false);
898
+ b.bp("/classification-scopes/{id}");
899
+ b.p("id", () => input.id, "{id}", false);
1404
900
  let body;
1405
901
  body = JSON.stringify(take(input, {
1406
902
  s3: [, (_) => se_S3ClassificationScopeUpdate(_, context), `s3`],
1407
903
  }));
1408
- return new __HttpRequest({
1409
- protocol,
1410
- hostname,
1411
- port,
1412
- method: "PATCH",
1413
- headers,
1414
- path: resolvedPath,
1415
- body,
1416
- });
904
+ b.m("PATCH").h(headers).b(body);
905
+ return b.build();
1417
906
  };
1418
907
  export const se_UpdateFindingsFilterCommand = async (input, context) => {
1419
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
908
+ const b = rb(input, context);
1420
909
  const headers = {
1421
910
  "content-type": "application/json",
1422
911
  };
1423
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/findingsfilters/{id}";
1424
- resolvedPath = __resolvedPath(resolvedPath, input, "id", () => input.id, "{id}", false);
912
+ b.bp("/findingsfilters/{id}");
913
+ b.p("id", () => input.id, "{id}", false);
1425
914
  let body;
1426
915
  body = JSON.stringify(take(input, {
1427
916
  action: [, , `action`],
@@ -1431,169 +920,111 @@ export const se_UpdateFindingsFilterCommand = async (input, context) => {
1431
920
  name: [, , `name`],
1432
921
  position: [, , `position`],
1433
922
  }));
1434
- return new __HttpRequest({
1435
- protocol,
1436
- hostname,
1437
- port,
1438
- method: "PATCH",
1439
- headers,
1440
- path: resolvedPath,
1441
- body,
1442
- });
923
+ b.m("PATCH").h(headers).b(body);
924
+ return b.build();
1443
925
  };
1444
926
  export const se_UpdateMacieSessionCommand = async (input, context) => {
1445
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
927
+ const b = rb(input, context);
1446
928
  const headers = {
1447
929
  "content-type": "application/json",
1448
930
  };
1449
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/macie";
931
+ b.bp("/macie");
1450
932
  let body;
1451
933
  body = JSON.stringify(take(input, {
1452
934
  findingPublishingFrequency: [, , `findingPublishingFrequency`],
1453
935
  status: [, , `status`],
1454
936
  }));
1455
- return new __HttpRequest({
1456
- protocol,
1457
- hostname,
1458
- port,
1459
- method: "PATCH",
1460
- headers,
1461
- path: resolvedPath,
1462
- body,
1463
- });
937
+ b.m("PATCH").h(headers).b(body);
938
+ return b.build();
1464
939
  };
1465
940
  export const se_UpdateMemberSessionCommand = async (input, context) => {
1466
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
941
+ const b = rb(input, context);
1467
942
  const headers = {
1468
943
  "content-type": "application/json",
1469
944
  };
1470
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/macie/members/{id}";
1471
- resolvedPath = __resolvedPath(resolvedPath, input, "id", () => input.id, "{id}", false);
945
+ b.bp("/macie/members/{id}");
946
+ b.p("id", () => input.id, "{id}", false);
1472
947
  let body;
1473
948
  body = JSON.stringify(take(input, {
1474
949
  status: [, , `status`],
1475
950
  }));
1476
- return new __HttpRequest({
1477
- protocol,
1478
- hostname,
1479
- port,
1480
- method: "PATCH",
1481
- headers,
1482
- path: resolvedPath,
1483
- body,
1484
- });
951
+ b.m("PATCH").h(headers).b(body);
952
+ return b.build();
1485
953
  };
1486
954
  export const se_UpdateOrganizationConfigurationCommand = async (input, context) => {
1487
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
955
+ const b = rb(input, context);
1488
956
  const headers = {
1489
957
  "content-type": "application/json",
1490
958
  };
1491
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/admin/configuration";
959
+ b.bp("/admin/configuration");
1492
960
  let body;
1493
961
  body = JSON.stringify(take(input, {
1494
962
  autoEnable: [, , `autoEnable`],
1495
963
  }));
1496
- return new __HttpRequest({
1497
- protocol,
1498
- hostname,
1499
- port,
1500
- method: "PATCH",
1501
- headers,
1502
- path: resolvedPath,
1503
- body,
1504
- });
964
+ b.m("PATCH").h(headers).b(body);
965
+ return b.build();
1505
966
  };
1506
967
  export const se_UpdateResourceProfileCommand = async (input, context) => {
1507
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
968
+ const b = rb(input, context);
1508
969
  const headers = {
1509
970
  "content-type": "application/json",
1510
971
  };
1511
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/resource-profiles";
972
+ b.bp("/resource-profiles");
1512
973
  const query = map({
1513
- resourceArn: [, __expectNonNull(input.resourceArn, `resourceArn`)],
974
+ [_rA]: [, __expectNonNull(input[_rA], `resourceArn`)],
1514
975
  });
1515
976
  let body;
1516
977
  body = JSON.stringify(take(input, {
1517
978
  sensitivityScoreOverride: [, , `sensitivityScoreOverride`],
1518
979
  }));
1519
- return new __HttpRequest({
1520
- protocol,
1521
- hostname,
1522
- port,
1523
- method: "PATCH",
1524
- headers,
1525
- path: resolvedPath,
1526
- query,
1527
- body,
1528
- });
980
+ b.m("PATCH").h(headers).q(query).b(body);
981
+ return b.build();
1529
982
  };
1530
983
  export const se_UpdateResourceProfileDetectionsCommand = async (input, context) => {
1531
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
984
+ const b = rb(input, context);
1532
985
  const headers = {
1533
986
  "content-type": "application/json",
1534
987
  };
1535
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/resource-profiles/detections";
988
+ b.bp("/resource-profiles/detections");
1536
989
  const query = map({
1537
- resourceArn: [, __expectNonNull(input.resourceArn, `resourceArn`)],
990
+ [_rA]: [, __expectNonNull(input[_rA], `resourceArn`)],
1538
991
  });
1539
992
  let body;
1540
993
  body = JSON.stringify(take(input, {
1541
994
  suppressDataIdentifiers: [, (_) => se___listOfSuppressDataIdentifier(_, context), `suppressDataIdentifiers`],
1542
995
  }));
1543
- return new __HttpRequest({
1544
- protocol,
1545
- hostname,
1546
- port,
1547
- method: "PATCH",
1548
- headers,
1549
- path: resolvedPath,
1550
- query,
1551
- body,
1552
- });
996
+ b.m("PATCH").h(headers).q(query).b(body);
997
+ return b.build();
1553
998
  };
1554
999
  export const se_UpdateRevealConfigurationCommand = async (input, context) => {
1555
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1000
+ const b = rb(input, context);
1556
1001
  const headers = {
1557
1002
  "content-type": "application/json",
1558
1003
  };
1559
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/reveal-configuration";
1004
+ b.bp("/reveal-configuration");
1560
1005
  let body;
1561
1006
  body = JSON.stringify(take(input, {
1562
1007
  configuration: [, (_) => se_RevealConfiguration(_, context), `configuration`],
1563
1008
  retrievalConfiguration: [, (_) => se_UpdateRetrievalConfiguration(_, context), `retrievalConfiguration`],
1564
1009
  }));
1565
- return new __HttpRequest({
1566
- protocol,
1567
- hostname,
1568
- port,
1569
- method: "PUT",
1570
- headers,
1571
- path: resolvedPath,
1572
- body,
1573
- });
1010
+ b.m("PUT").h(headers).b(body);
1011
+ return b.build();
1574
1012
  };
1575
1013
  export const se_UpdateSensitivityInspectionTemplateCommand = async (input, context) => {
1576
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1014
+ const b = rb(input, context);
1577
1015
  const headers = {
1578
1016
  "content-type": "application/json",
1579
1017
  };
1580
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/templates/sensitivity-inspections/{id}";
1581
- resolvedPath = __resolvedPath(resolvedPath, input, "id", () => input.id, "{id}", false);
1018
+ b.bp("/templates/sensitivity-inspections/{id}");
1019
+ b.p("id", () => input.id, "{id}", false);
1582
1020
  let body;
1583
1021
  body = JSON.stringify(take(input, {
1584
1022
  description: [, , `description`],
1585
1023
  excludes: [, (_) => se_SensitivityInspectionTemplateExcludes(_, context), `excludes`],
1586
1024
  includes: [, (_) => se_SensitivityInspectionTemplateIncludes(_, context), `includes`],
1587
1025
  }));
1588
- return new __HttpRequest({
1589
- protocol,
1590
- hostname,
1591
- port,
1592
- method: "PUT",
1593
- headers,
1594
- path: resolvedPath,
1595
- body,
1596
- });
1026
+ b.m("PUT").h(headers).b(body);
1027
+ return b.build();
1597
1028
  };
1598
1029
  export const de_AcceptInvitationCommand = async (output, context) => {
1599
1030
  if (output.statusCode !== 200 && output.statusCode >= 300) {
@@ -7178,6 +6609,15 @@ const isSerializableHeaderValue = (value) => value !== undefined &&
7178
6609
  value !== "" &&
7179
6610
  (!Object.getOwnPropertyNames(value).includes("length") || value.length != 0) &&
7180
6611
  (!Object.getOwnPropertyNames(value).includes("size") || value.size != 0);
6612
+ const _aAI = "adminAccountId";
6613
+ const _iJC = "ignoreJobChecks";
6614
+ const _mR = "maxResults";
6615
+ const _n = "name";
6616
+ const _nT = "nextToken";
6617
+ const _oA = "onlyAssociated";
6618
+ const _rA = "resourceArn";
6619
+ const _tK = "tagKeys";
6620
+ const _tR = "timeRange";
7181
6621
  const parseBody = (streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
7182
6622
  if (encoded.length) {
7183
6623
  return JSON.parse(encoded);