@aws-sdk/client-securityhub 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 +374 -938
  2. package/dist-es/protocols/Aws_restJson1.js +375 -939
  3. package/package.json +5 -4
package/dist-es/protocols/Aws_restJson1.js CHANGED
@@ -1,237 +1,160 @@
1
1
  import { awsExpectUnion as __expectUnion } from "@aws-sdk/core";
2
- import { HttpRequest as __HttpRequest } from "@smithy/protocol-http";
3
- 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, serializeFloat as __serializeFloat, take, withBaseException, } from "@smithy/smithy-client";
2
+ import { requestBuilder as rb } from "@smithy/core";
3
+ 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, serializeFloat as __serializeFloat, take, withBaseException, } from "@smithy/smithy-client";
4
4
  import { AccessDeniedException, InternalException, InvalidAccessException, InvalidInputException, LimitExceededException, ResourceNotFoundException, } from "../models/models_0";
5
5
  import { ParameterValue, Policy, ResourceConflictException, ResourceInUseException, } from "../models/models_2";
6
6
  import { SecurityHubServiceException as __BaseException } from "../models/SecurityHubServiceException";
7
7
  export const se_AcceptAdministratorInvitationCommand = async (input, context) => {
8
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
8
+ const b = rb(input, context);
9
9
  const headers = {
10
10
  "content-type": "application/json",
11
11
  };
12
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/administrator";
12
+ b.bp("/administrator");
13
13
  let body;
14
14
  body = JSON.stringify(take(input, {
15
15
  AdministratorId: [],
16
16
  InvitationId: [],
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_AcceptInvitationCommand = 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 || ""}` + "/master";
26
+ b.bp("/master");
34
27
  let body;
35
28
  body = JSON.stringify(take(input, {
36
29
  InvitationId: [],
37
30
  MasterId: [],
38
31
  }));
39
- return new __HttpRequest({
40
- protocol,
41
- hostname,
42
- port,
43
- method: "POST",
44
- headers,
45
- path: resolvedPath,
46
- body,
47
- });
32
+ b.m("POST").h(headers).b(body);
33
+ return b.build();
48
34
  };
49
35
  export const se_BatchDeleteAutomationRulesCommand = async (input, context) => {
50
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
36
+ const b = rb(input, context);
51
37
  const headers = {
52
38
  "content-type": "application/json",
53
39
  };
54
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/automationrules/delete";
40
+ b.bp("/automationrules/delete");
55
41
  let body;
56
42
  body = JSON.stringify(take(input, {
57
43
  AutomationRulesArns: (_) => _json(_),
58
44
  }));
59
- return new __HttpRequest({
60
- protocol,
61
- hostname,
62
- port,
63
- method: "POST",
64
- headers,
65
- path: resolvedPath,
66
- body,
67
- });
45
+ b.m("POST").h(headers).b(body);
46
+ return b.build();
68
47
  };
69
48
  export const se_BatchDisableStandardsCommand = async (input, context) => {
70
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
49
+ const b = rb(input, context);
71
50
  const headers = {
72
51
  "content-type": "application/json",
73
52
  };
74
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/standards/deregister";
53
+ b.bp("/standards/deregister");
75
54
  let body;
76
55
  body = JSON.stringify(take(input, {
77
56
  StandardsSubscriptionArns: (_) => _json(_),
78
57
  }));
79
- return new __HttpRequest({
80
- protocol,
81
- hostname,
82
- port,
83
- method: "POST",
84
- headers,
85
- path: resolvedPath,
86
- body,
87
- });
58
+ b.m("POST").h(headers).b(body);
59
+ return b.build();
88
60
  };
89
61
  export const se_BatchEnableStandardsCommand = async (input, context) => {
90
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
62
+ const b = rb(input, context);
91
63
  const headers = {
92
64
  "content-type": "application/json",
93
65
  };
94
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/standards/register";
66
+ b.bp("/standards/register");
95
67
  let body;
96
68
  body = JSON.stringify(take(input, {
97
69
  StandardsSubscriptionRequests: (_) => _json(_),
98
70
  }));
99
- return new __HttpRequest({
100
- protocol,
101
- hostname,
102
- port,
103
- method: "POST",
104
- headers,
105
- path: resolvedPath,
106
- body,
107
- });
71
+ b.m("POST").h(headers).b(body);
72
+ return b.build();
108
73
  };
109
74
  export const se_BatchGetAutomationRulesCommand = async (input, context) => {
110
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
75
+ const b = rb(input, context);
111
76
  const headers = {
112
77
  "content-type": "application/json",
113
78
  };
114
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/automationrules/get";
79
+ b.bp("/automationrules/get");
115
80
  let body;
116
81
  body = JSON.stringify(take(input, {
117
82
  AutomationRulesArns: (_) => _json(_),
118
83
  }));
119
- return new __HttpRequest({
120
- protocol,
121
- hostname,
122
- port,
123
- method: "POST",
124
- headers,
125
- path: resolvedPath,
126
- body,
127
- });
84
+ b.m("POST").h(headers).b(body);
85
+ return b.build();
128
86
  };
129
87
  export const se_BatchGetConfigurationPolicyAssociationsCommand = async (input, context) => {
130
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
88
+ const b = rb(input, context);
131
89
  const headers = {
132
90
  "content-type": "application/json",
133
91
  };
134
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/configurationPolicyAssociation/batchget";
92
+ b.bp("/configurationPolicyAssociation/batchget");
135
93
  let body;
136
94
  body = JSON.stringify(take(input, {
137
95
  ConfigurationPolicyAssociationIdentifiers: (_) => _json(_),
138
96
  }));
139
- return new __HttpRequest({
140
- protocol,
141
- hostname,
142
- port,
143
- method: "POST",
144
- headers,
145
- path: resolvedPath,
146
- body,
147
- });
97
+ b.m("POST").h(headers).b(body);
98
+ return b.build();
148
99
  };
149
100
  export const se_BatchGetSecurityControlsCommand = async (input, context) => {
150
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
101
+ const b = rb(input, context);
151
102
  const headers = {
152
103
  "content-type": "application/json",
153
104
  };
154
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/securityControls/batchGet";
105
+ b.bp("/securityControls/batchGet");
155
106
  let body;
156
107
  body = JSON.stringify(take(input, {
157
108
  SecurityControlIds: (_) => _json(_),
158
109
  }));
159
- return new __HttpRequest({
160
- protocol,
161
- hostname,
162
- port,
163
- method: "POST",
164
- headers,
165
- path: resolvedPath,
166
- body,
167
- });
110
+ b.m("POST").h(headers).b(body);
111
+ return b.build();
168
112
  };
169
113
  export const se_BatchGetStandardsControlAssociationsCommand = async (input, context) => {
170
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
114
+ const b = rb(input, context);
171
115
  const headers = {
172
116
  "content-type": "application/json",
173
117
  };
174
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/associations/batchGet";
118
+ b.bp("/associations/batchGet");
175
119
  let body;
176
120
  body = JSON.stringify(take(input, {
177
121
  StandardsControlAssociationIds: (_) => _json(_),
178
122
  }));
179
- return new __HttpRequest({
180
- protocol,
181
- hostname,
182
- port,
183
- method: "POST",
184
- headers,
185
- path: resolvedPath,
186
- body,
187
- });
123
+ b.m("POST").h(headers).b(body);
124
+ return b.build();
188
125
  };
189
126
  export const se_BatchImportFindingsCommand = async (input, context) => {
190
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
127
+ const b = rb(input, context);
191
128
  const headers = {
192
129
  "content-type": "application/json",
193
130
  };
194
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/findings/import";
131
+ b.bp("/findings/import");
195
132
  let body;
196
133
  body = JSON.stringify(take(input, {
197
134
  Findings: (_) => se_BatchImportFindingsRequestFindingList(_, context),
198
135
  }));
199
- return new __HttpRequest({
200
- protocol,
201
- hostname,
202
- port,
203
- method: "POST",
204
- headers,
205
- path: resolvedPath,
206
- body,
207
- });
136
+ b.m("POST").h(headers).b(body);
137
+ return b.build();
208
138
  };
209
139
  export const se_BatchUpdateAutomationRulesCommand = async (input, context) => {
210
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
140
+ const b = rb(input, context);
211
141
  const headers = {
212
142
  "content-type": "application/json",
213
143
  };
214
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/automationrules/update";
144
+ b.bp("/automationrules/update");
215
145
  let body;
216
146
  body = JSON.stringify(take(input, {
217
147
  UpdateAutomationRulesRequestItems: (_) => se_UpdateAutomationRulesRequestItemsList(_, context),
218
148
  }));
219
- return new __HttpRequest({
220
- protocol,
221
- hostname,
222
- port,
223
- method: "PATCH",
224
- headers,
225
- path: resolvedPath,
226
- body,
227
- });
149
+ b.m("PATCH").h(headers).b(body);
150
+ return b.build();
228
151
  };
229
152
  export const se_BatchUpdateFindingsCommand = async (input, context) => {
230
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
153
+ const b = rb(input, context);
231
154
  const headers = {
232
155
  "content-type": "application/json",
233
156
  };
234
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/findings/batchupdate";
157
+ b.bp("/findings/batchupdate");
235
158
  let body;
236
159
  body = JSON.stringify(take(input, {
237
160
  Confidence: [],
@@ -245,64 +168,43 @@ export const se_BatchUpdateFindingsCommand = async (input, context) => {
245
168
  VerificationState: [],
246
169
  Workflow: (_) => _json(_),
247
170
  }));
248
- return new __HttpRequest({
249
- protocol,
250
- hostname,
251
- port,
252
- method: "PATCH",
253
- headers,
254
- path: resolvedPath,
255
- body,
256
- });
171
+ b.m("PATCH").h(headers).b(body);
172
+ return b.build();
257
173
  };
258
174
  export const se_BatchUpdateStandardsControlAssociationsCommand = async (input, context) => {
259
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
175
+ const b = rb(input, context);
260
176
  const headers = {
261
177
  "content-type": "application/json",
262
178
  };
263
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/associations";
179
+ b.bp("/associations");
264
180
  let body;
265
181
  body = JSON.stringify(take(input, {
266
182
  StandardsControlAssociationUpdates: (_) => _json(_),
267
183
  }));
268
- return new __HttpRequest({
269
- protocol,
270
- hostname,
271
- port,
272
- method: "PATCH",
273
- headers,
274
- path: resolvedPath,
275
- body,
276
- });
184
+ b.m("PATCH").h(headers).b(body);
185
+ return b.build();
277
186
  };
278
187
  export const se_CreateActionTargetCommand = async (input, context) => {
279
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
188
+ const b = rb(input, context);
280
189
  const headers = {
281
190
  "content-type": "application/json",
282
191
  };
283
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/actionTargets";
192
+ b.bp("/actionTargets");
284
193
  let body;
285
194
  body = JSON.stringify(take(input, {
286
195
  Description: [],
287
196
  Id: [],
288
197
  Name: [],
289
198
  }));
290
- return new __HttpRequest({
291
- protocol,
292
- hostname,
293
- port,
294
- method: "POST",
295
- headers,
296
- path: resolvedPath,
297
- body,
298
- });
199
+ b.m("POST").h(headers).b(body);
200
+ return b.build();
299
201
  };
300
202
  export const se_CreateAutomationRuleCommand = async (input, context) => {
301
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
203
+ const b = rb(input, context);
302
204
  const headers = {
303
205
  "content-type": "application/json",
304
206
  };
305
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/automationrules/create";
207
+ b.bp("/automationrules/create");
306
208
  let body;
307
209
  body = JSON.stringify(take(input, {
308
210
  Actions: (_) => se_ActionList(_, context),
@@ -314,22 +216,15 @@ export const se_CreateAutomationRuleCommand = async (input, context) => {
314
216
  RuleStatus: [],
315
217
  Tags: (_) => _json(_),
316
218
  }));
317
- return new __HttpRequest({
318
- protocol,
319
- hostname,
320
- port,
321
- method: "POST",
322
- headers,
323
- path: resolvedPath,
324
- body,
325
- });
219
+ b.m("POST").h(headers).b(body);
220
+ return b.build();
326
221
  };
327
222
  export const se_CreateConfigurationPolicyCommand = async (input, context) => {
328
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
223
+ const b = rb(input, context);
329
224
  const headers = {
330
225
  "content-type": "application/json",
331
226
  };
332
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/configurationPolicy/create";
227
+ b.bp("/configurationPolicy/create");
333
228
  let body;
334
229
  body = JSON.stringify(take(input, {
335
230
  ConfigurationPolicy: (_) => se_Policy(_, context),
@@ -337,598 +232,373 @@ export const se_CreateConfigurationPolicyCommand = async (input, context) => {
337
232
  Name: [],
338
233
  Tags: (_) => _json(_),
339
234
  }));
340
- return new __HttpRequest({
341
- protocol,
342
- hostname,
343
- port,
344
- method: "POST",
345
- headers,
346
- path: resolvedPath,
347
- body,
348
- });
235
+ b.m("POST").h(headers).b(body);
236
+ return b.build();
349
237
  };
350
238
  export const se_CreateFindingAggregatorCommand = async (input, context) => {
351
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
239
+ const b = rb(input, context);
352
240
  const headers = {
353
241
  "content-type": "application/json",
354
242
  };
355
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/findingAggregator/create";
243
+ b.bp("/findingAggregator/create");
356
244
  let body;
357
245
  body = JSON.stringify(take(input, {
358
246
  RegionLinkingMode: [],
359
247
  Regions: (_) => _json(_),
360
248
  }));
361
- return new __HttpRequest({
362
- protocol,
363
- hostname,
364
- port,
365
- method: "POST",
366
- headers,
367
- path: resolvedPath,
368
- body,
369
- });
249
+ b.m("POST").h(headers).b(body);
250
+ return b.build();
370
251
  };
371
252
  export const se_CreateInsightCommand = async (input, context) => {
372
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
253
+ const b = rb(input, context);
373
254
  const headers = {
374
255
  "content-type": "application/json",
375
256
  };
376
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/insights";
257
+ b.bp("/insights");
377
258
  let body;
378
259
  body = JSON.stringify(take(input, {
379
260
  Filters: (_) => se_AwsSecurityFindingFilters(_, context),
380
261
  GroupByAttribute: [],
381
262
  Name: [],
382
263
  }));
383
- return new __HttpRequest({
384
- protocol,
385
- hostname,
386
- port,
387
- method: "POST",
388
- headers,
389
- path: resolvedPath,
390
- body,
391
- });
264
+ b.m("POST").h(headers).b(body);
265
+ return b.build();
392
266
  };
393
267
  export const se_CreateMembersCommand = async (input, context) => {
394
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
268
+ const b = rb(input, context);
395
269
  const headers = {
396
270
  "content-type": "application/json",
397
271
  };
398
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/members";
272
+ b.bp("/members");
399
273
  let body;
400
274
  body = JSON.stringify(take(input, {
401
275
  AccountDetails: (_) => _json(_),
402
276
  }));
403
- return new __HttpRequest({
404
- protocol,
405
- hostname,
406
- port,
407
- method: "POST",
408
- headers,
409
- path: resolvedPath,
410
- body,
411
- });
277
+ b.m("POST").h(headers).b(body);
278
+ return b.build();
412
279
  };
413
280
  export const se_DeclineInvitationsCommand = async (input, context) => {
414
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
281
+ const b = rb(input, context);
415
282
  const headers = {
416
283
  "content-type": "application/json",
417
284
  };
418
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/invitations/decline";
285
+ b.bp("/invitations/decline");
419
286
  let body;
420
287
  body = JSON.stringify(take(input, {
421
288
  AccountIds: (_) => _json(_),
422
289
  }));
423
- return new __HttpRequest({
424
- protocol,
425
- hostname,
426
- port,
427
- method: "POST",
428
- headers,
429
- path: resolvedPath,
430
- body,
431
- });
290
+ b.m("POST").h(headers).b(body);
291
+ return b.build();
432
292
  };
433
293
  export const se_DeleteActionTargetCommand = async (input, context) => {
434
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
294
+ const b = rb(input, context);
435
295
  const headers = {};
436
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/actionTargets/{ActionTargetArn+}";
437
- resolvedPath = __resolvedPath(resolvedPath, input, "ActionTargetArn", () => input.ActionTargetArn, "{ActionTargetArn+}", true);
296
+ b.bp("/actionTargets/{ActionTargetArn+}");
297
+ b.p("ActionTargetArn", () => input.ActionTargetArn, "{ActionTargetArn+}", true);
438
298
  let body;
439
- return new __HttpRequest({
440
- protocol,
441
- hostname,
442
- port,
443
- method: "DELETE",
444
- headers,
445
- path: resolvedPath,
446
- body,
447
- });
299
+ b.m("DELETE").h(headers).b(body);
300
+ return b.build();
448
301
  };
449
302
  export const se_DeleteConfigurationPolicyCommand = async (input, context) => {
450
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
303
+ const b = rb(input, context);
451
304
  const headers = {};
452
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/configurationPolicy/{Identifier}";
453
- resolvedPath = __resolvedPath(resolvedPath, input, "Identifier", () => input.Identifier, "{Identifier}", false);
305
+ b.bp("/configurationPolicy/{Identifier}");
306
+ b.p("Identifier", () => input.Identifier, "{Identifier}", false);
454
307
  let body;
455
- return new __HttpRequest({
456
- protocol,
457
- hostname,
458
- port,
459
- method: "DELETE",
460
- headers,
461
- path: resolvedPath,
462
- body,
463
- });
308
+ b.m("DELETE").h(headers).b(body);
309
+ return b.build();
464
310
  };
465
311
  export const se_DeleteFindingAggregatorCommand = async (input, context) => {
466
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
312
+ const b = rb(input, context);
467
313
  const headers = {};
468
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
469
- "/findingAggregator/delete/{FindingAggregatorArn+}";
470
- resolvedPath = __resolvedPath(resolvedPath, input, "FindingAggregatorArn", () => input.FindingAggregatorArn, "{FindingAggregatorArn+}", true);
314
+ b.bp("/findingAggregator/delete/{FindingAggregatorArn+}");
315
+ b.p("FindingAggregatorArn", () => input.FindingAggregatorArn, "{FindingAggregatorArn+}", true);
471
316
  let body;
472
- return new __HttpRequest({
473
- protocol,
474
- hostname,
475
- port,
476
- method: "DELETE",
477
- headers,
478
- path: resolvedPath,
479
- body,
480
- });
317
+ b.m("DELETE").h(headers).b(body);
318
+ return b.build();
481
319
  };
482
320
  export const se_DeleteInsightCommand = async (input, context) => {
483
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
321
+ const b = rb(input, context);
484
322
  const headers = {};
485
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/insights/{InsightArn+}";
486
- resolvedPath = __resolvedPath(resolvedPath, input, "InsightArn", () => input.InsightArn, "{InsightArn+}", true);
323
+ b.bp("/insights/{InsightArn+}");
324
+ b.p("InsightArn", () => input.InsightArn, "{InsightArn+}", true);
487
325
  let body;
488
- return new __HttpRequest({
489
- protocol,
490
- hostname,
491
- port,
492
- method: "DELETE",
493
- headers,
494
- path: resolvedPath,
495
- body,
496
- });
326
+ b.m("DELETE").h(headers).b(body);
327
+ return b.build();
497
328
  };
498
329
  export const se_DeleteInvitationsCommand = async (input, context) => {
499
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
330
+ const b = rb(input, context);
500
331
  const headers = {
501
332
  "content-type": "application/json",
502
333
  };
503
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/invitations/delete";
334
+ b.bp("/invitations/delete");
504
335
  let body;
505
336
  body = JSON.stringify(take(input, {
506
337
  AccountIds: (_) => _json(_),
507
338
  }));
508
- return new __HttpRequest({
509
- protocol,
510
- hostname,
511
- port,
512
- method: "POST",
513
- headers,
514
- path: resolvedPath,
515
- body,
516
- });
339
+ b.m("POST").h(headers).b(body);
340
+ return b.build();
517
341
  };
518
342
  export const se_DeleteMembersCommand = async (input, context) => {
519
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
343
+ const b = rb(input, context);
520
344
  const headers = {
521
345
  "content-type": "application/json",
522
346
  };
523
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/members/delete";
347
+ b.bp("/members/delete");
524
348
  let body;
525
349
  body = JSON.stringify(take(input, {
526
350
  AccountIds: (_) => _json(_),
527
351
  }));
528
- return new __HttpRequest({
529
- protocol,
530
- hostname,
531
- port,
532
- method: "POST",
533
- headers,
534
- path: resolvedPath,
535
- body,
536
- });
352
+ b.m("POST").h(headers).b(body);
353
+ return b.build();
537
354
  };
538
355
  export const se_DescribeActionTargetsCommand = async (input, context) => {
539
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
356
+ const b = rb(input, context);
540
357
  const headers = {
541
358
  "content-type": "application/json",
542
359
  };
543
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/actionTargets/get";
360
+ b.bp("/actionTargets/get");
544
361
  let body;
545
362
  body = JSON.stringify(take(input, {
546
363
  ActionTargetArns: (_) => _json(_),
547
364
  MaxResults: [],
548
365
  NextToken: [],
549
366
  }));
550
- return new __HttpRequest({
551
- protocol,
552
- hostname,
553
- port,
554
- method: "POST",
555
- headers,
556
- path: resolvedPath,
557
- body,
558
- });
367
+ b.m("POST").h(headers).b(body);
368
+ return b.build();
559
369
  };
560
370
  export const se_DescribeHubCommand = async (input, context) => {
561
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
371
+ const b = rb(input, context);
562
372
  const headers = {};
563
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/accounts";
373
+ b.bp("/accounts");
564
374
  const query = map({
565
- HubArn: [, input.HubArn],
375
+ [_HA]: [, input[_HA]],
566
376
  });
567
377
  let body;
568
- return new __HttpRequest({
569
- protocol,
570
- hostname,
571
- port,
572
- method: "GET",
573
- headers,
574
- path: resolvedPath,
575
- query,
576
- body,
577
- });
378
+ b.m("GET").h(headers).q(query).b(body);
379
+ return b.build();
578
380
  };
579
381
  export const se_DescribeOrganizationConfigurationCommand = async (input, context) => {
580
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
382
+ const b = rb(input, context);
581
383
  const headers = {
582
384
  "content-type": "application/json",
583
385
  };
584
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/organization/configuration";
386
+ b.bp("/organization/configuration");
585
387
  let body;
586
388
  body = "";
587
- return new __HttpRequest({
588
- protocol,
589
- hostname,
590
- port,
591
- method: "GET",
592
- headers,
593
- path: resolvedPath,
594
- body,
595
- });
389
+ b.m("GET").h(headers).b(body);
390
+ return b.build();
596
391
  };
597
392
  export const se_DescribeProductsCommand = async (input, context) => {
598
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
393
+ const b = rb(input, context);
599
394
  const headers = {};
600
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/products";
395
+ b.bp("/products");
601
396
  const query = map({
602
- NextToken: [, input.NextToken],
603
- MaxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
604
- ProductArn: [, input.ProductArn],
397
+ [_NT]: [, input[_NT]],
398
+ [_MR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
399
+ [_PA]: [, input[_PA]],
605
400
  });
606
401
  let body;
607
- return new __HttpRequest({
608
- protocol,
609
- hostname,
610
- port,
611
- method: "GET",
612
- headers,
613
- path: resolvedPath,
614
- query,
615
- body,
616
- });
402
+ b.m("GET").h(headers).q(query).b(body);
403
+ return b.build();
617
404
  };
618
405
  export const se_DescribeStandardsCommand = async (input, context) => {
619
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
406
+ const b = rb(input, context);
620
407
  const headers = {};
621
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/standards";
408
+ b.bp("/standards");
622
409
  const query = map({
623
- NextToken: [, input.NextToken],
624
- MaxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
410
+ [_NT]: [, input[_NT]],
411
+ [_MR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
625
412
  });
626
413
  let body;
627
- return new __HttpRequest({
628
- protocol,
629
- hostname,
630
- port,
631
- method: "GET",
632
- headers,
633
- path: resolvedPath,
634
- query,
635
- body,
636
- });
414
+ b.m("GET").h(headers).q(query).b(body);
415
+ return b.build();
637
416
  };
638
417
  export const se_DescribeStandardsControlsCommand = async (input, context) => {
639
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
418
+ const b = rb(input, context);
640
419
  const headers = {};
641
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
642
- "/standards/controls/{StandardsSubscriptionArn+}";
643
- resolvedPath = __resolvedPath(resolvedPath, input, "StandardsSubscriptionArn", () => input.StandardsSubscriptionArn, "{StandardsSubscriptionArn+}", true);
420
+ b.bp("/standards/controls/{StandardsSubscriptionArn+}");
421
+ b.p("StandardsSubscriptionArn", () => input.StandardsSubscriptionArn, "{StandardsSubscriptionArn+}", true);
644
422
  const query = map({
645
- NextToken: [, input.NextToken],
646
- MaxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
423
+ [_NT]: [, input[_NT]],
424
+ [_MR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
647
425
  });
648
426
  let body;
649
- return new __HttpRequest({
650
- protocol,
651
- hostname,
652
- port,
653
- method: "GET",
654
- headers,
655
- path: resolvedPath,
656
- query,
657
- body,
658
- });
427
+ b.m("GET").h(headers).q(query).b(body);
428
+ return b.build();
659
429
  };
660
430
  export const se_DisableImportFindingsForProductCommand = async (input, context) => {
661
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
431
+ const b = rb(input, context);
662
432
  const headers = {};
663
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
664
- "/productSubscriptions/{ProductSubscriptionArn+}";
665
- resolvedPath = __resolvedPath(resolvedPath, input, "ProductSubscriptionArn", () => input.ProductSubscriptionArn, "{ProductSubscriptionArn+}", true);
433
+ b.bp("/productSubscriptions/{ProductSubscriptionArn+}");
434
+ b.p("ProductSubscriptionArn", () => input.ProductSubscriptionArn, "{ProductSubscriptionArn+}", true);
666
435
  let body;
667
- return new __HttpRequest({
668
- protocol,
669
- hostname,
670
- port,
671
- method: "DELETE",
672
- headers,
673
- path: resolvedPath,
674
- body,
675
- });
436
+ b.m("DELETE").h(headers).b(body);
437
+ return b.build();
676
438
  };
677
439
  export const se_DisableOrganizationAdminAccountCommand = async (input, context) => {
678
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
440
+ const b = rb(input, context);
679
441
  const headers = {
680
442
  "content-type": "application/json",
681
443
  };
682
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/organization/admin/disable";
444
+ b.bp("/organization/admin/disable");
683
445
  let body;
684
446
  body = JSON.stringify(take(input, {
685
447
  AdminAccountId: [],
686
448
  }));
687
- return new __HttpRequest({
688
- protocol,
689
- hostname,
690
- port,
691
- method: "POST",
692
- headers,
693
- path: resolvedPath,
694
- body,
695
- });
449
+ b.m("POST").h(headers).b(body);
450
+ return b.build();
696
451
  };
697
452
  export const se_DisableSecurityHubCommand = async (input, context) => {
698
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
453
+ const b = rb(input, context);
699
454
  const headers = {
700
455
  "content-type": "application/json",
701
456
  };
702
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/accounts";
457
+ b.bp("/accounts");
703
458
  let body;
704
459
  body = "";
705
- return new __HttpRequest({
706
- protocol,
707
- hostname,
708
- port,
709
- method: "DELETE",
710
- headers,
711
- path: resolvedPath,
712
- body,
713
- });
460
+ b.m("DELETE").h(headers).b(body);
461
+ return b.build();
714
462
  };
715
463
  export const se_DisassociateFromAdministratorAccountCommand = async (input, context) => {
716
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
464
+ const b = rb(input, context);
717
465
  const headers = {
718
466
  "content-type": "application/json",
719
467
  };
720
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/administrator/disassociate";
468
+ b.bp("/administrator/disassociate");
721
469
  let body;
722
470
  body = "";
723
- return new __HttpRequest({
724
- protocol,
725
- hostname,
726
- port,
727
- method: "POST",
728
- headers,
729
- path: resolvedPath,
730
- body,
731
- });
471
+ b.m("POST").h(headers).b(body);
472
+ return b.build();
732
473
  };
733
474
  export const se_DisassociateFromMasterAccountCommand = async (input, context) => {
734
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
475
+ const b = rb(input, context);
735
476
  const headers = {
736
477
  "content-type": "application/json",
737
478
  };
738
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/master/disassociate";
479
+ b.bp("/master/disassociate");
739
480
  let body;
740
481
  body = "";
741
- return new __HttpRequest({
742
- protocol,
743
- hostname,
744
- port,
745
- method: "POST",
746
- headers,
747
- path: resolvedPath,
748
- body,
749
- });
482
+ b.m("POST").h(headers).b(body);
483
+ return b.build();
750
484
  };
751
485
  export const se_DisassociateMembersCommand = async (input, context) => {
752
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
486
+ const b = rb(input, context);
753
487
  const headers = {
754
488
  "content-type": "application/json",
755
489
  };
756
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/members/disassociate";
490
+ b.bp("/members/disassociate");
757
491
  let body;
758
492
  body = JSON.stringify(take(input, {
759
493
  AccountIds: (_) => _json(_),
760
494
  }));
761
- return new __HttpRequest({
762
- protocol,
763
- hostname,
764
- port,
765
- method: "POST",
766
- headers,
767
- path: resolvedPath,
768
- body,
769
- });
495
+ b.m("POST").h(headers).b(body);
496
+ return b.build();
770
497
  };
771
498
  export const se_EnableImportFindingsForProductCommand = async (input, context) => {
772
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
499
+ const b = rb(input, context);
773
500
  const headers = {
774
501
  "content-type": "application/json",
775
502
  };
776
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/productSubscriptions";
503
+ b.bp("/productSubscriptions");
777
504
  let body;
778
505
  body = JSON.stringify(take(input, {
779
506
  ProductArn: [],
780
507
  }));
781
- return new __HttpRequest({
782
- protocol,
783
- hostname,
784
- port,
785
- method: "POST",
786
- headers,
787
- path: resolvedPath,
788
- body,
789
- });
508
+ b.m("POST").h(headers).b(body);
509
+ return b.build();
790
510
  };
791
511
  export const se_EnableOrganizationAdminAccountCommand = async (input, context) => {
792
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
512
+ const b = rb(input, context);
793
513
  const headers = {
794
514
  "content-type": "application/json",
795
515
  };
796
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/organization/admin/enable";
516
+ b.bp("/organization/admin/enable");
797
517
  let body;
798
518
  body = JSON.stringify(take(input, {
799
519
  AdminAccountId: [],
800
520
  }));
801
- return new __HttpRequest({
802
- protocol,
803
- hostname,
804
- port,
805
- method: "POST",
806
- headers,
807
- path: resolvedPath,
808
- body,
809
- });
521
+ b.m("POST").h(headers).b(body);
522
+ return b.build();
810
523
  };
811
524
  export const se_EnableSecurityHubCommand = async (input, context) => {
812
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
525
+ const b = rb(input, context);
813
526
  const headers = {
814
527
  "content-type": "application/json",
815
528
  };
816
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/accounts";
529
+ b.bp("/accounts");
817
530
  let body;
818
531
  body = JSON.stringify(take(input, {
819
532
  ControlFindingGenerator: [],
820
533
  EnableDefaultStandards: [],
821
534
  Tags: (_) => _json(_),
822
535
  }));
823
- return new __HttpRequest({
824
- protocol,
825
- hostname,
826
- port,
827
- method: "POST",
828
- headers,
829
- path: resolvedPath,
830
- body,
831
- });
536
+ b.m("POST").h(headers).b(body);
537
+ return b.build();
832
538
  };
833
539
  export const se_GetAdministratorAccountCommand = async (input, context) => {
834
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
540
+ const b = rb(input, context);
835
541
  const headers = {
836
542
  "content-type": "application/json",
837
543
  };
838
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/administrator";
544
+ b.bp("/administrator");
839
545
  let body;
840
546
  body = "";
841
- return new __HttpRequest({
842
- protocol,
843
- hostname,
844
- port,
845
- method: "GET",
846
- headers,
847
- path: resolvedPath,
848
- body,
849
- });
547
+ b.m("GET").h(headers).b(body);
548
+ return b.build();
850
549
  };
851
550
  export const se_GetConfigurationPolicyCommand = async (input, context) => {
852
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
551
+ const b = rb(input, context);
853
552
  const headers = {};
854
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/configurationPolicy/get/{Identifier}";
855
- resolvedPath = __resolvedPath(resolvedPath, input, "Identifier", () => input.Identifier, "{Identifier}", false);
553
+ b.bp("/configurationPolicy/get/{Identifier}");
554
+ b.p("Identifier", () => input.Identifier, "{Identifier}", false);
856
555
  let body;
857
- return new __HttpRequest({
858
- protocol,
859
- hostname,
860
- port,
861
- method: "GET",
862
- headers,
863
- path: resolvedPath,
864
- body,
865
- });
556
+ b.m("GET").h(headers).b(body);
557
+ return b.build();
866
558
  };
867
559
  export const se_GetConfigurationPolicyAssociationCommand = async (input, context) => {
868
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
560
+ const b = rb(input, context);
869
561
  const headers = {
870
562
  "content-type": "application/json",
871
563
  };
872
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/configurationPolicyAssociation/get";
564
+ b.bp("/configurationPolicyAssociation/get");
873
565
  let body;
874
566
  body = JSON.stringify(take(input, {
875
567
  Target: (_) => _json(_),
876
568
  }));
877
- return new __HttpRequest({
878
- protocol,
879
- hostname,
880
- port,
881
- method: "POST",
882
- headers,
883
- path: resolvedPath,
884
- body,
885
- });
569
+ b.m("POST").h(headers).b(body);
570
+ return b.build();
886
571
  };
887
572
  export const se_GetEnabledStandardsCommand = async (input, context) => {
888
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
573
+ const b = rb(input, context);
889
574
  const headers = {
890
575
  "content-type": "application/json",
891
576
  };
892
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/standards/get";
577
+ b.bp("/standards/get");
893
578
  let body;
894
579
  body = JSON.stringify(take(input, {
895
580
  MaxResults: [],
896
581
  NextToken: [],
897
582
  StandardsSubscriptionArns: (_) => _json(_),
898
583
  }));
899
- return new __HttpRequest({
900
- protocol,
901
- hostname,
902
- port,
903
- method: "POST",
904
- headers,
905
- path: resolvedPath,
906
- body,
907
- });
584
+ b.m("POST").h(headers).b(body);
585
+ return b.build();
908
586
  };
909
587
  export const se_GetFindingAggregatorCommand = async (input, context) => {
910
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
588
+ const b = rb(input, context);
911
589
  const headers = {};
912
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
913
- "/findingAggregator/get/{FindingAggregatorArn+}";
914
- resolvedPath = __resolvedPath(resolvedPath, input, "FindingAggregatorArn", () => input.FindingAggregatorArn, "{FindingAggregatorArn+}", true);
590
+ b.bp("/findingAggregator/get/{FindingAggregatorArn+}");
591
+ b.p("FindingAggregatorArn", () => input.FindingAggregatorArn, "{FindingAggregatorArn+}", true);
915
592
  let body;
916
- return new __HttpRequest({
917
- protocol,
918
- hostname,
919
- port,
920
- method: "GET",
921
- headers,
922
- path: resolvedPath,
923
- body,
924
- });
593
+ b.m("GET").h(headers).b(body);
594
+ return b.build();
925
595
  };
926
596
  export const se_GetFindingHistoryCommand = async (input, context) => {
927
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
597
+ const b = rb(input, context);
928
598
  const headers = {
929
599
  "content-type": "application/json",
930
600
  };
931
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/findingHistory/get";
601
+ b.bp("/findingHistory/get");
932
602
  let body;
933
603
  body = JSON.stringify(take(input, {
934
604
  EndTime: (_) => _.toISOString().split(".")[0] + "Z",
@@ -937,22 +607,15 @@ export const se_GetFindingHistoryCommand = async (input, context) => {
937
607
  NextToken: [],
938
608
  StartTime: (_) => _.toISOString().split(".")[0] + "Z",
939
609
  }));
940
- return new __HttpRequest({
941
- protocol,
942
- hostname,
943
- port,
944
- method: "POST",
945
- headers,
946
- path: resolvedPath,
947
- body,
948
- });
610
+ b.m("POST").h(headers).b(body);
611
+ return b.build();
949
612
  };
950
613
  export const se_GetFindingsCommand = async (input, context) => {
951
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
614
+ const b = rb(input, context);
952
615
  const headers = {
953
616
  "content-type": "application/json",
954
617
  };
955
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/findings";
618
+ b.bp("/findings");
956
619
  let body;
957
620
  body = JSON.stringify(take(input, {
958
621
  Filters: (_) => se_AwsSecurityFindingFilters(_, context),
@@ -960,486 +623,306 @@ export const se_GetFindingsCommand = async (input, context) => {
960
623
  NextToken: [],
961
624
  SortCriteria: (_) => _json(_),
962
625
  }));
963
- return new __HttpRequest({
964
- protocol,
965
- hostname,
966
- port,
967
- method: "POST",
968
- headers,
969
- path: resolvedPath,
970
- body,
971
- });
626
+ b.m("POST").h(headers).b(body);
627
+ return b.build();
972
628
  };
973
629
  export const se_GetInsightResultsCommand = async (input, context) => {
974
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
630
+ const b = rb(input, context);
975
631
  const headers = {};
976
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/insights/results/{InsightArn+}";
977
- resolvedPath = __resolvedPath(resolvedPath, input, "InsightArn", () => input.InsightArn, "{InsightArn+}", true);
632
+ b.bp("/insights/results/{InsightArn+}");
633
+ b.p("InsightArn", () => input.InsightArn, "{InsightArn+}", true);
978
634
  let body;
979
- return new __HttpRequest({
980
- protocol,
981
- hostname,
982
- port,
983
- method: "GET",
984
- headers,
985
- path: resolvedPath,
986
- body,
987
- });
635
+ b.m("GET").h(headers).b(body);
636
+ return b.build();
988
637
  };
989
638
  export const se_GetInsightsCommand = async (input, context) => {
990
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
639
+ const b = rb(input, context);
991
640
  const headers = {
992
641
  "content-type": "application/json",
993
642
  };
994
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/insights/get";
643
+ b.bp("/insights/get");
995
644
  let body;
996
645
  body = JSON.stringify(take(input, {
997
646
  InsightArns: (_) => _json(_),
998
647
  MaxResults: [],
999
648
  NextToken: [],
1000
649
  }));
1001
- return new __HttpRequest({
1002
- protocol,
1003
- hostname,
1004
- port,
1005
- method: "POST",
1006
- headers,
1007
- path: resolvedPath,
1008
- body,
1009
- });
650
+ b.m("POST").h(headers).b(body);
651
+ return b.build();
1010
652
  };
1011
653
  export const se_GetInvitationsCountCommand = async (input, context) => {
1012
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
654
+ const b = rb(input, context);
1013
655
  const headers = {
1014
656
  "content-type": "application/json",
1015
657
  };
1016
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/invitations/count";
658
+ b.bp("/invitations/count");
1017
659
  let body;
1018
660
  body = "";
1019
- return new __HttpRequest({
1020
- protocol,
1021
- hostname,
1022
- port,
1023
- method: "GET",
1024
- headers,
1025
- path: resolvedPath,
1026
- body,
1027
- });
661
+ b.m("GET").h(headers).b(body);
662
+ return b.build();
1028
663
  };
1029
664
  export const se_GetMasterAccountCommand = async (input, context) => {
1030
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
665
+ const b = rb(input, context);
1031
666
  const headers = {
1032
667
  "content-type": "application/json",
1033
668
  };
1034
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/master";
669
+ b.bp("/master");
1035
670
  let body;
1036
671
  body = "";
1037
- return new __HttpRequest({
1038
- protocol,
1039
- hostname,
1040
- port,
1041
- method: "GET",
1042
- headers,
1043
- path: resolvedPath,
1044
- body,
1045
- });
672
+ b.m("GET").h(headers).b(body);
673
+ return b.build();
1046
674
  };
1047
675
  export const se_GetMembersCommand = async (input, context) => {
1048
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
676
+ const b = rb(input, context);
1049
677
  const headers = {
1050
678
  "content-type": "application/json",
1051
679
  };
1052
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/members/get";
680
+ b.bp("/members/get");
1053
681
  let body;
1054
682
  body = JSON.stringify(take(input, {
1055
683
  AccountIds: (_) => _json(_),
1056
684
  }));
1057
- return new __HttpRequest({
1058
- protocol,
1059
- hostname,
1060
- port,
1061
- method: "POST",
1062
- headers,
1063
- path: resolvedPath,
1064
- body,
1065
- });
685
+ b.m("POST").h(headers).b(body);
686
+ return b.build();
1066
687
  };
1067
688
  export const se_GetSecurityControlDefinitionCommand = async (input, context) => {
1068
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
689
+ const b = rb(input, context);
1069
690
  const headers = {};
1070
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/securityControl/definition";
691
+ b.bp("/securityControl/definition");
1071
692
  const query = map({
1072
- SecurityControlId: [, __expectNonNull(input.SecurityControlId, `SecurityControlId`)],
693
+ [_SCI]: [, __expectNonNull(input[_SCI], `SecurityControlId`)],
1073
694
  });
1074
695
  let body;
1075
- return new __HttpRequest({
1076
- protocol,
1077
- hostname,
1078
- port,
1079
- method: "GET",
1080
- headers,
1081
- path: resolvedPath,
1082
- query,
1083
- body,
1084
- });
696
+ b.m("GET").h(headers).q(query).b(body);
697
+ return b.build();
1085
698
  };
1086
699
  export const se_InviteMembersCommand = async (input, context) => {
1087
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
700
+ const b = rb(input, context);
1088
701
  const headers = {
1089
702
  "content-type": "application/json",
1090
703
  };
1091
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/members/invite";
704
+ b.bp("/members/invite");
1092
705
  let body;
1093
706
  body = JSON.stringify(take(input, {
1094
707
  AccountIds: (_) => _json(_),
1095
708
  }));
1096
- return new __HttpRequest({
1097
- protocol,
1098
- hostname,
1099
- port,
1100
- method: "POST",
1101
- headers,
1102
- path: resolvedPath,
1103
- body,
1104
- });
709
+ b.m("POST").h(headers).b(body);
710
+ return b.build();
1105
711
  };
1106
712
  export const se_ListAutomationRulesCommand = async (input, context) => {
1107
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
713
+ const b = rb(input, context);
1108
714
  const headers = {};
1109
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/automationrules/list";
715
+ b.bp("/automationrules/list");
1110
716
  const query = map({
1111
- NextToken: [, input.NextToken],
1112
- MaxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
717
+ [_NT]: [, input[_NT]],
718
+ [_MR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
1113
719
  });
1114
720
  let body;
1115
- return new __HttpRequest({
1116
- protocol,
1117
- hostname,
1118
- port,
1119
- method: "GET",
1120
- headers,
1121
- path: resolvedPath,
1122
- query,
1123
- body,
1124
- });
721
+ b.m("GET").h(headers).q(query).b(body);
722
+ return b.build();
1125
723
  };
1126
724
  export const se_ListConfigurationPoliciesCommand = async (input, context) => {
1127
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
725
+ const b = rb(input, context);
1128
726
  const headers = {};
1129
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/configurationPolicy/list";
727
+ b.bp("/configurationPolicy/list");
1130
728
  const query = map({
1131
- NextToken: [, input.NextToken],
1132
- MaxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
729
+ [_NT]: [, input[_NT]],
730
+ [_MR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
1133
731
  });
1134
732
  let body;
1135
- return new __HttpRequest({
1136
- protocol,
1137
- hostname,
1138
- port,
1139
- method: "GET",
1140
- headers,
1141
- path: resolvedPath,
1142
- query,
1143
- body,
1144
- });
733
+ b.m("GET").h(headers).q(query).b(body);
734
+ return b.build();
1145
735
  };
1146
736
  export const se_ListConfigurationPolicyAssociationsCommand = async (input, context) => {
1147
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
737
+ const b = rb(input, context);
1148
738
  const headers = {
1149
739
  "content-type": "application/json",
1150
740
  };
1151
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/configurationPolicyAssociation/list";
741
+ b.bp("/configurationPolicyAssociation/list");
1152
742
  let body;
1153
743
  body = JSON.stringify(take(input, {
1154
744
  Filters: (_) => _json(_),
1155
745
  MaxResults: [],
1156
746
  NextToken: [],
1157
747
  }));
1158
- return new __HttpRequest({
1159
- protocol,
1160
- hostname,
1161
- port,
1162
- method: "POST",
1163
- headers,
1164
- path: resolvedPath,
1165
- body,
1166
- });
748
+ b.m("POST").h(headers).b(body);
749
+ return b.build();
1167
750
  };
1168
751
  export const se_ListEnabledProductsForImportCommand = async (input, context) => {
1169
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
752
+ const b = rb(input, context);
1170
753
  const headers = {};
1171
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/productSubscriptions";
754
+ b.bp("/productSubscriptions");
1172
755
  const query = map({
1173
- NextToken: [, input.NextToken],
1174
- MaxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
756
+ [_NT]: [, input[_NT]],
757
+ [_MR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
1175
758
  });
1176
759
  let body;
1177
- return new __HttpRequest({
1178
- protocol,
1179
- hostname,
1180
- port,
1181
- method: "GET",
1182
- headers,
1183
- path: resolvedPath,
1184
- query,
1185
- body,
1186
- });
760
+ b.m("GET").h(headers).q(query).b(body);
761
+ return b.build();
1187
762
  };
1188
763
  export const se_ListFindingAggregatorsCommand = async (input, context) => {
1189
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
764
+ const b = rb(input, context);
1190
765
  const headers = {};
1191
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/findingAggregator/list";
766
+ b.bp("/findingAggregator/list");
1192
767
  const query = map({
1193
- NextToken: [, input.NextToken],
1194
- MaxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
768
+ [_NT]: [, input[_NT]],
769
+ [_MR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
1195
770
  });
1196
771
  let body;
1197
- return new __HttpRequest({
1198
- protocol,
1199
- hostname,
1200
- port,
1201
- method: "GET",
1202
- headers,
1203
- path: resolvedPath,
1204
- query,
1205
- body,
1206
- });
772
+ b.m("GET").h(headers).q(query).b(body);
773
+ return b.build();
1207
774
  };
1208
775
  export const se_ListInvitationsCommand = async (input, context) => {
1209
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
776
+ const b = rb(input, context);
1210
777
  const headers = {};
1211
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/invitations";
778
+ b.bp("/invitations");
1212
779
  const query = map({
1213
- MaxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
1214
- NextToken: [, input.NextToken],
780
+ [_MR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
781
+ [_NT]: [, input[_NT]],
1215
782
  });
1216
783
  let body;
1217
- return new __HttpRequest({
1218
- protocol,
1219
- hostname,
1220
- port,
1221
- method: "GET",
1222
- headers,
1223
- path: resolvedPath,
1224
- query,
1225
- body,
1226
- });
784
+ b.m("GET").h(headers).q(query).b(body);
785
+ return b.build();
1227
786
  };
1228
787
  export const se_ListMembersCommand = async (input, context) => {
1229
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
788
+ const b = rb(input, context);
1230
789
  const headers = {};
1231
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/members";
790
+ b.bp("/members");
1232
791
  const query = map({
1233
- OnlyAssociated: [() => input.OnlyAssociated !== void 0, () => input.OnlyAssociated.toString()],
1234
- MaxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
1235
- NextToken: [, input.NextToken],
792
+ [_OA]: [() => input.OnlyAssociated !== void 0, () => input[_OA].toString()],
793
+ [_MR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
794
+ [_NT]: [, input[_NT]],
1236
795
  });
1237
796
  let body;
1238
- return new __HttpRequest({
1239
- protocol,
1240
- hostname,
1241
- port,
1242
- method: "GET",
1243
- headers,
1244
- path: resolvedPath,
1245
- query,
1246
- body,
1247
- });
797
+ b.m("GET").h(headers).q(query).b(body);
798
+ return b.build();
1248
799
  };
1249
800
  export const se_ListOrganizationAdminAccountsCommand = async (input, context) => {
1250
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
801
+ const b = rb(input, context);
1251
802
  const headers = {};
1252
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/organization/admin";
803
+ b.bp("/organization/admin");
1253
804
  const query = map({
1254
- MaxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
1255
- NextToken: [, input.NextToken],
805
+ [_MR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
806
+ [_NT]: [, input[_NT]],
1256
807
  });
1257
808
  let body;
1258
- return new __HttpRequest({
1259
- protocol,
1260
- hostname,
1261
- port,
1262
- method: "GET",
1263
- headers,
1264
- path: resolvedPath,
1265
- query,
1266
- body,
1267
- });
809
+ b.m("GET").h(headers).q(query).b(body);
810
+ return b.build();
1268
811
  };
1269
812
  export const se_ListSecurityControlDefinitionsCommand = async (input, context) => {
1270
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
813
+ const b = rb(input, context);
1271
814
  const headers = {};
1272
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/securityControls/definitions";
815
+ b.bp("/securityControls/definitions");
1273
816
  const query = map({
1274
- StandardsArn: [, input.StandardsArn],
1275
- NextToken: [, input.NextToken],
1276
- MaxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
817
+ [_SA]: [, input[_SA]],
818
+ [_NT]: [, input[_NT]],
819
+ [_MR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
1277
820
  });
1278
821
  let body;
1279
- return new __HttpRequest({
1280
- protocol,
1281
- hostname,
1282
- port,
1283
- method: "GET",
1284
- headers,
1285
- path: resolvedPath,
1286
- query,
1287
- body,
1288
- });
822
+ b.m("GET").h(headers).q(query).b(body);
823
+ return b.build();
1289
824
  };
1290
825
  export const se_ListStandardsControlAssociationsCommand = async (input, context) => {
1291
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
826
+ const b = rb(input, context);
1292
827
  const headers = {};
1293
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/associations";
828
+ b.bp("/associations");
1294
829
  const query = map({
1295
- SecurityControlId: [, __expectNonNull(input.SecurityControlId, `SecurityControlId`)],
1296
- NextToken: [, input.NextToken],
1297
- MaxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
830
+ [_SCI]: [, __expectNonNull(input[_SCI], `SecurityControlId`)],
831
+ [_NT]: [, input[_NT]],
832
+ [_MR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
1298
833
  });
1299
834
  let body;
1300
- return new __HttpRequest({
1301
- protocol,
1302
- hostname,
1303
- port,
1304
- method: "GET",
1305
- headers,
1306
- path: resolvedPath,
1307
- query,
1308
- body,
1309
- });
835
+ b.m("GET").h(headers).q(query).b(body);
836
+ return b.build();
1310
837
  };
1311
838
  export const se_ListTagsForResourceCommand = async (input, context) => {
1312
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
839
+ const b = rb(input, context);
1313
840
  const headers = {};
1314
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{ResourceArn}";
1315
- resolvedPath = __resolvedPath(resolvedPath, input, "ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
841
+ b.bp("/tags/{ResourceArn}");
842
+ b.p("ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
1316
843
  let body;
1317
- return new __HttpRequest({
1318
- protocol,
1319
- hostname,
1320
- port,
1321
- method: "GET",
1322
- headers,
1323
- path: resolvedPath,
1324
- body,
1325
- });
844
+ b.m("GET").h(headers).b(body);
845
+ return b.build();
1326
846
  };
1327
847
  export const se_StartConfigurationPolicyAssociationCommand = async (input, context) => {
1328
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
848
+ const b = rb(input, context);
1329
849
  const headers = {
1330
850
  "content-type": "application/json",
1331
851
  };
1332
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/configurationPolicyAssociation/associate";
852
+ b.bp("/configurationPolicyAssociation/associate");
1333
853
  let body;
1334
854
  body = JSON.stringify(take(input, {
1335
855
  ConfigurationPolicyIdentifier: [],
1336
856
  Target: (_) => _json(_),
1337
857
  }));
1338
- return new __HttpRequest({
1339
- protocol,
1340
- hostname,
1341
- port,
1342
- method: "POST",
1343
- headers,
1344
- path: resolvedPath,
1345
- body,
1346
- });
858
+ b.m("POST").h(headers).b(body);
859
+ return b.build();
1347
860
  };
1348
861
  export const se_StartConfigurationPolicyDisassociationCommand = async (input, context) => {
1349
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
862
+ const b = rb(input, context);
1350
863
  const headers = {
1351
864
  "content-type": "application/json",
1352
865
  };
1353
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1354
- "/configurationPolicyAssociation/disassociate";
866
+ b.bp("/configurationPolicyAssociation/disassociate");
1355
867
  let body;
1356
868
  body = JSON.stringify(take(input, {
1357
869
  ConfigurationPolicyIdentifier: [],
1358
870
  Target: (_) => _json(_),
1359
871
  }));
1360
- return new __HttpRequest({
1361
- protocol,
1362
- hostname,
1363
- port,
1364
- method: "POST",
1365
- headers,
1366
- path: resolvedPath,
1367
- body,
1368
- });
872
+ b.m("POST").h(headers).b(body);
873
+ return b.build();
1369
874
  };
1370
875
  export const se_TagResourceCommand = async (input, context) => {
1371
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
876
+ const b = rb(input, context);
1372
877
  const headers = {
1373
878
  "content-type": "application/json",
1374
879
  };
1375
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{ResourceArn}";
1376
- resolvedPath = __resolvedPath(resolvedPath, input, "ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
880
+ b.bp("/tags/{ResourceArn}");
881
+ b.p("ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
1377
882
  let body;
1378
883
  body = JSON.stringify(take(input, {
1379
884
  Tags: (_) => _json(_),
1380
885
  }));
1381
- return new __HttpRequest({
1382
- protocol,
1383
- hostname,
1384
- port,
1385
- method: "POST",
1386
- headers,
1387
- path: resolvedPath,
1388
- body,
1389
- });
886
+ b.m("POST").h(headers).b(body);
887
+ return b.build();
1390
888
  };
1391
889
  export const se_UntagResourceCommand = async (input, context) => {
1392
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
890
+ const b = rb(input, context);
1393
891
  const headers = {};
1394
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{ResourceArn}";
1395
- resolvedPath = __resolvedPath(resolvedPath, input, "ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
892
+ b.bp("/tags/{ResourceArn}");
893
+ b.p("ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
1396
894
  const query = map({
1397
- tagKeys: [
895
+ [_tK]: [
1398
896
  __expectNonNull(input.TagKeys, `TagKeys`) != null,
1399
- () => (input.TagKeys || []).map((_entry) => _entry),
897
+ () => (input[_TK] || []).map((_entry) => _entry),
1400
898
  ],
1401
899
  });
1402
900
  let body;
1403
- return new __HttpRequest({
1404
- protocol,
1405
- hostname,
1406
- port,
1407
- method: "DELETE",
1408
- headers,
1409
- path: resolvedPath,
1410
- query,
1411
- body,
1412
- });
901
+ b.m("DELETE").h(headers).q(query).b(body);
902
+ return b.build();
1413
903
  };
1414
904
  export const se_UpdateActionTargetCommand = async (input, context) => {
1415
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
905
+ const b = rb(input, context);
1416
906
  const headers = {
1417
907
  "content-type": "application/json",
1418
908
  };
1419
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/actionTargets/{ActionTargetArn+}";
1420
- resolvedPath = __resolvedPath(resolvedPath, input, "ActionTargetArn", () => input.ActionTargetArn, "{ActionTargetArn+}", true);
909
+ b.bp("/actionTargets/{ActionTargetArn+}");
910
+ b.p("ActionTargetArn", () => input.ActionTargetArn, "{ActionTargetArn+}", true);
1421
911
  let body;
1422
912
  body = JSON.stringify(take(input, {
1423
913
  Description: [],
1424
914
  Name: [],
1425
915
  }));
1426
- return new __HttpRequest({
1427
- protocol,
1428
- hostname,
1429
- port,
1430
- method: "PATCH",
1431
- headers,
1432
- path: resolvedPath,
1433
- body,
1434
- });
916
+ b.m("PATCH").h(headers).b(body);
917
+ return b.build();
1435
918
  };
1436
919
  export const se_UpdateConfigurationPolicyCommand = async (input, context) => {
1437
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
920
+ const b = rb(input, context);
1438
921
  const headers = {
1439
922
  "content-type": "application/json",
1440
923
  };
1441
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/configurationPolicy/{Identifier}";
1442
- resolvedPath = __resolvedPath(resolvedPath, input, "Identifier", () => input.Identifier, "{Identifier}", false);
924
+ b.bp("/configurationPolicy/{Identifier}");
925
+ b.p("Identifier", () => input.Identifier, "{Identifier}", false);
1443
926
  let body;
1444
927
  body = JSON.stringify(take(input, {
1445
928
  ConfigurationPolicy: (_) => se_Policy(_, context),
@@ -1447,169 +930,113 @@ export const se_UpdateConfigurationPolicyCommand = async (input, context) => {
1447
930
  Name: [],
1448
931
  UpdatedReason: [],
1449
932
  }));
1450
- return new __HttpRequest({
1451
- protocol,
1452
- hostname,
1453
- port,
1454
- method: "PATCH",
1455
- headers,
1456
- path: resolvedPath,
1457
- body,
1458
- });
933
+ b.m("PATCH").h(headers).b(body);
934
+ return b.build();
1459
935
  };
1460
936
  export const se_UpdateFindingAggregatorCommand = async (input, context) => {
1461
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
937
+ const b = rb(input, context);
1462
938
  const headers = {
1463
939
  "content-type": "application/json",
1464
940
  };
1465
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/findingAggregator/update";
941
+ b.bp("/findingAggregator/update");
1466
942
  let body;
1467
943
  body = JSON.stringify(take(input, {
1468
944
  FindingAggregatorArn: [],
1469
945
  RegionLinkingMode: [],
1470
946
  Regions: (_) => _json(_),
1471
947
  }));
1472
- return new __HttpRequest({
1473
- protocol,
1474
- hostname,
1475
- port,
1476
- method: "PATCH",
1477
- headers,
1478
- path: resolvedPath,
1479
- body,
1480
- });
948
+ b.m("PATCH").h(headers).b(body);
949
+ return b.build();
1481
950
  };
1482
951
  export const se_UpdateFindingsCommand = async (input, context) => {
1483
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
952
+ const b = rb(input, context);
1484
953
  const headers = {
1485
954
  "content-type": "application/json",
1486
955
  };
1487
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/findings";
956
+ b.bp("/findings");
1488
957
  let body;
1489
958
  body = JSON.stringify(take(input, {
1490
959
  Filters: (_) => se_AwsSecurityFindingFilters(_, context),
1491
960
  Note: (_) => _json(_),
1492
961
  RecordState: [],
1493
962
  }));
1494
- return new __HttpRequest({
1495
- protocol,
1496
- hostname,
1497
- port,
1498
- method: "PATCH",
1499
- headers,
1500
- path: resolvedPath,
1501
- body,
1502
- });
963
+ b.m("PATCH").h(headers).b(body);
964
+ return b.build();
1503
965
  };
1504
966
  export const se_UpdateInsightCommand = async (input, context) => {
1505
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
967
+ const b = rb(input, context);
1506
968
  const headers = {
1507
969
  "content-type": "application/json",
1508
970
  };
1509
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/insights/{InsightArn+}";
1510
- resolvedPath = __resolvedPath(resolvedPath, input, "InsightArn", () => input.InsightArn, "{InsightArn+}", true);
971
+ b.bp("/insights/{InsightArn+}");
972
+ b.p("InsightArn", () => input.InsightArn, "{InsightArn+}", true);
1511
973
  let body;
1512
974
  body = JSON.stringify(take(input, {
1513
975
  Filters: (_) => se_AwsSecurityFindingFilters(_, context),
1514
976
  GroupByAttribute: [],
1515
977
  Name: [],
1516
978
  }));
1517
- return new __HttpRequest({
1518
- protocol,
1519
- hostname,
1520
- port,
1521
- method: "PATCH",
1522
- headers,
1523
- path: resolvedPath,
1524
- body,
1525
- });
979
+ b.m("PATCH").h(headers).b(body);
980
+ return b.build();
1526
981
  };
1527
982
  export const se_UpdateOrganizationConfigurationCommand = async (input, context) => {
1528
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
983
+ const b = rb(input, context);
1529
984
  const headers = {
1530
985
  "content-type": "application/json",
1531
986
  };
1532
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/organization/configuration";
987
+ b.bp("/organization/configuration");
1533
988
  let body;
1534
989
  body = JSON.stringify(take(input, {
1535
990
  AutoEnable: [],
1536
991
  AutoEnableStandards: [],
1537
992
  OrganizationConfiguration: (_) => _json(_),
1538
993
  }));
1539
- return new __HttpRequest({
1540
- protocol,
1541
- hostname,
1542
- port,
1543
- method: "POST",
1544
- headers,
1545
- path: resolvedPath,
1546
- body,
1547
- });
994
+ b.m("POST").h(headers).b(body);
995
+ return b.build();
1548
996
  };
1549
997
  export const se_UpdateSecurityControlCommand = async (input, context) => {
1550
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
998
+ const b = rb(input, context);
1551
999
  const headers = {
1552
1000
  "content-type": "application/json",
1553
1001
  };
1554
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/securityControl/update";
1002
+ b.bp("/securityControl/update");
1555
1003
  let body;
1556
1004
  body = JSON.stringify(take(input, {
1557
1005
  LastUpdateReason: [],
1558
1006
  Parameters: (_) => se_Parameters(_, context),
1559
1007
  SecurityControlId: [],
1560
1008
  }));
1561
- return new __HttpRequest({
1562
- protocol,
1563
- hostname,
1564
- port,
1565
- method: "PATCH",
1566
- headers,
1567
- path: resolvedPath,
1568
- body,
1569
- });
1009
+ b.m("PATCH").h(headers).b(body);
1010
+ return b.build();
1570
1011
  };
1571
1012
  export const se_UpdateSecurityHubConfigurationCommand = async (input, context) => {
1572
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1013
+ const b = rb(input, context);
1573
1014
  const headers = {
1574
1015
  "content-type": "application/json",
1575
1016
  };
1576
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/accounts";
1017
+ b.bp("/accounts");
1577
1018
  let body;
1578
1019
  body = JSON.stringify(take(input, {
1579
1020
  AutoEnableControls: [],
1580
1021
  ControlFindingGenerator: [],
1581
1022
  }));
1582
- return new __HttpRequest({
1583
- protocol,
1584
- hostname,
1585
- port,
1586
- method: "PATCH",
1587
- headers,
1588
- path: resolvedPath,
1589
- body,
1590
- });
1023
+ b.m("PATCH").h(headers).b(body);
1024
+ return b.build();
1591
1025
  };
1592
1026
  export const se_UpdateStandardsControlCommand = async (input, context) => {
1593
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1027
+ const b = rb(input, context);
1594
1028
  const headers = {
1595
1029
  "content-type": "application/json",
1596
1030
  };
1597
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/standards/control/{StandardsControlArn+}";
1598
- resolvedPath = __resolvedPath(resolvedPath, input, "StandardsControlArn", () => input.StandardsControlArn, "{StandardsControlArn+}", true);
1031
+ b.bp("/standards/control/{StandardsControlArn+}");
1032
+ b.p("StandardsControlArn", () => input.StandardsControlArn, "{StandardsControlArn+}", true);
1599
1033
  let body;
1600
1034
  body = JSON.stringify(take(input, {
1601
1035
  ControlStatus: [],
1602
1036
  DisabledReason: [],
1603
1037
  }));
1604
- return new __HttpRequest({
1605
- protocol,
1606
- hostname,
1607
- port,
1608
- method: "PATCH",
1609
- headers,
1610
- path: resolvedPath,
1611
- body,
1612
- });
1038
+ b.m("PATCH").h(headers).b(body);
1039
+ return b.build();
1613
1040
  };
1614
1041
  export const de_AcceptAdministratorInvitationCommand = async (output, context) => {
1615
1042
  if (output.statusCode !== 200 && output.statusCode >= 300) {
@@ -7257,6 +6684,15 @@ const isSerializableHeaderValue = (value) => value !== undefined &&
7257
6684
  value !== "" &&
7258
6685
  (!Object.getOwnPropertyNames(value).includes("length") || value.length != 0) &&
7259
6686
  (!Object.getOwnPropertyNames(value).includes("size") || value.size != 0);
6687
+ const _HA = "HubArn";
6688
+ const _MR = "MaxResults";
6689
+ const _NT = "NextToken";
6690
+ const _OA = "OnlyAssociated";
6691
+ const _PA = "ProductArn";
6692
+ const _SA = "StandardsArn";
6693
+ const _SCI = "SecurityControlId";
6694
+ const _TK = "TagKeys";
6695
+ const _tK = "tagKeys";
7260
6696
  const parseBody = (streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
7261
6697
  if (encoded.length) {
7262
6698
  return JSON.parse(encoded);