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