@aws-sdk/client-guardduty 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 +372 -871
  2. package/dist-es/protocols/Aws_restJson1.js +373 -872
  3. package/package.json +5 -4
package/dist-es/protocols/Aws_restJson1.js CHANGED
@@ -1,79 +1,58 @@
1
- import { HttpRequest as __HttpRequest } from "@smithy/protocol-http";
2
- import { _json, collectBody, decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectInt32 as __expectInt32, expectLong as __expectLong, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectObject as __expectObject, expectString as __expectString, limitedParseDouble as __limitedParseDouble, map, parseEpochTimestamp as __parseEpochTimestamp, resolvedPath as __resolvedPath, take, withBaseException, } from "@smithy/smithy-client";
1
+ import { requestBuilder as rb } from "@smithy/core";
2
+ import { _json, collectBody, decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectInt32 as __expectInt32, expectLong as __expectLong, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectObject as __expectObject, expectString as __expectString, limitedParseDouble as __limitedParseDouble, map, parseEpochTimestamp as __parseEpochTimestamp, take, withBaseException, } from "@smithy/smithy-client";
3
3
  import { v4 as generateIdempotencyToken } from "uuid";
4
4
  import { GuardDutyServiceException as __BaseException } from "../models/GuardDutyServiceException";
5
5
  import { AccessDeniedException, BadRequestException, ConflictException, InternalServerErrorException, } from "../models/models_0";
6
6
  export const se_AcceptAdministratorInvitationCommand = async (input, context) => {
7
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
7
+ const b = rb(input, context);
8
8
  const headers = {
9
9
  "content-type": "application/json",
10
10
  };
11
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/detector/{DetectorId}/administrator";
12
- resolvedPath = __resolvedPath(resolvedPath, input, "DetectorId", () => input.DetectorId, "{DetectorId}", false);
11
+ b.bp("/detector/{DetectorId}/administrator");
12
+ b.p("DetectorId", () => input.DetectorId, "{DetectorId}", false);
13
13
  let body;
14
14
  body = JSON.stringify(take(input, {
15
15
  administratorId: [, , `AdministratorId`],
16
16
  invitationId: [, , `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
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/detector/{DetectorId}/master";
34
- resolvedPath = __resolvedPath(resolvedPath, input, "DetectorId", () => input.DetectorId, "{DetectorId}", false);
26
+ b.bp("/detector/{DetectorId}/master");
27
+ b.p("DetectorId", () => input.DetectorId, "{DetectorId}", false);
35
28
  let body;
36
29
  body = JSON.stringify(take(input, {
37
30
  invitationId: [, , `InvitationId`],
38
31
  masterId: [, , `MasterId`],
39
32
  }));
40
- return new __HttpRequest({
41
- protocol,
42
- hostname,
43
- port,
44
- method: "POST",
45
- headers,
46
- path: resolvedPath,
47
- body,
48
- });
33
+ b.m("POST").h(headers).b(body);
34
+ return b.build();
49
35
  };
50
36
  export const se_ArchiveFindingsCommand = async (input, context) => {
51
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
37
+ const b = rb(input, context);
52
38
  const headers = {
53
39
  "content-type": "application/json",
54
40
  };
55
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/detector/{DetectorId}/findings/archive";
56
- resolvedPath = __resolvedPath(resolvedPath, input, "DetectorId", () => input.DetectorId, "{DetectorId}", false);
41
+ b.bp("/detector/{DetectorId}/findings/archive");
42
+ b.p("DetectorId", () => input.DetectorId, "{DetectorId}", false);
57
43
  let body;
58
44
  body = JSON.stringify(take(input, {
59
45
  findingIds: [, (_) => _json(_), `FindingIds`],
60
46
  }));
61
- return new __HttpRequest({
62
- protocol,
63
- hostname,
64
- port,
65
- method: "POST",
66
- headers,
67
- path: resolvedPath,
68
- body,
69
- });
47
+ b.m("POST").h(headers).b(body);
48
+ return b.build();
70
49
  };
71
50
  export const se_CreateDetectorCommand = async (input, context) => {
72
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
51
+ const b = rb(input, context);
73
52
  const headers = {
74
53
  "content-type": "application/json",
75
54
  };
76
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/detector";
55
+ b.bp("/detector");
77
56
  let body;
78
57
  body = JSON.stringify(take(input, {
79
58
  clientToken: [true, (_) => _ ?? generateIdempotencyToken(), `ClientToken`],
@@ -83,23 +62,16 @@ export const se_CreateDetectorCommand = async (input, context) => {
83
62
  findingPublishingFrequency: [, , `FindingPublishingFrequency`],
84
63
  tags: [, (_) => _json(_), `Tags`],
85
64
  }));
86
- return new __HttpRequest({
87
- protocol,
88
- hostname,
89
- port,
90
- method: "POST",
91
- headers,
92
- path: resolvedPath,
93
- body,
94
- });
65
+ b.m("POST").h(headers).b(body);
66
+ return b.build();
95
67
  };
96
68
  export const se_CreateFilterCommand = async (input, context) => {
97
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
69
+ const b = rb(input, context);
98
70
  const headers = {
99
71
  "content-type": "application/json",
100
72
  };
101
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/detector/{DetectorId}/filter";
102
- resolvedPath = __resolvedPath(resolvedPath, input, "DetectorId", () => input.DetectorId, "{DetectorId}", false);
73
+ b.bp("/detector/{DetectorId}/filter");
74
+ b.p("DetectorId", () => input.DetectorId, "{DetectorId}", false);
103
75
  let body;
104
76
  body = JSON.stringify(take(input, {
105
77
  action: [, , `Action`],
@@ -110,23 +82,16 @@ export const se_CreateFilterCommand = async (input, context) => {
110
82
  rank: [, , `Rank`],
111
83
  tags: [, (_) => _json(_), `Tags`],
112
84
  }));
113
- return new __HttpRequest({
114
- protocol,
115
- hostname,
116
- port,
117
- method: "POST",
118
- headers,
119
- path: resolvedPath,
120
- body,
121
- });
85
+ b.m("POST").h(headers).b(body);
86
+ return b.build();
122
87
  };
123
88
  export const se_CreateIPSetCommand = async (input, context) => {
124
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
89
+ const b = rb(input, context);
125
90
  const headers = {
126
91
  "content-type": "application/json",
127
92
  };
128
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/detector/{DetectorId}/ipset";
129
- resolvedPath = __resolvedPath(resolvedPath, input, "DetectorId", () => input.DetectorId, "{DetectorId}", false);
93
+ b.bp("/detector/{DetectorId}/ipset");
94
+ b.p("DetectorId", () => input.DetectorId, "{DetectorId}", false);
130
95
  let body;
131
96
  body = JSON.stringify(take(input, {
132
97
  activate: [, , `Activate`],
@@ -136,89 +101,60 @@ export const se_CreateIPSetCommand = async (input, context) => {
136
101
  name: [, , `Name`],
137
102
  tags: [, (_) => _json(_), `Tags`],
138
103
  }));
139
- return new __HttpRequest({
140
- protocol,
141
- hostname,
142
- port,
143
- method: "POST",
144
- headers,
145
- path: resolvedPath,
146
- body,
147
- });
104
+ b.m("POST").h(headers).b(body);
105
+ return b.build();
148
106
  };
149
107
  export const se_CreateMembersCommand = async (input, context) => {
150
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
108
+ const b = rb(input, context);
151
109
  const headers = {
152
110
  "content-type": "application/json",
153
111
  };
154
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/detector/{DetectorId}/member";
155
- resolvedPath = __resolvedPath(resolvedPath, input, "DetectorId", () => input.DetectorId, "{DetectorId}", false);
112
+ b.bp("/detector/{DetectorId}/member");
113
+ b.p("DetectorId", () => input.DetectorId, "{DetectorId}", false);
156
114
  let body;
157
115
  body = JSON.stringify(take(input, {
158
116
  accountDetails: [, (_) => se_AccountDetails(_, context), `AccountDetails`],
159
117
  }));
160
- return new __HttpRequest({
161
- protocol,
162
- hostname,
163
- port,
164
- method: "POST",
165
- headers,
166
- path: resolvedPath,
167
- body,
168
- });
118
+ b.m("POST").h(headers).b(body);
119
+ return b.build();
169
120
  };
170
121
  export const se_CreatePublishingDestinationCommand = async (input, context) => {
171
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
122
+ const b = rb(input, context);
172
123
  const headers = {
173
124
  "content-type": "application/json",
174
125
  };
175
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
176
- "/detector/{DetectorId}/publishingDestination";
177
- resolvedPath = __resolvedPath(resolvedPath, input, "DetectorId", () => input.DetectorId, "{DetectorId}", false);
126
+ b.bp("/detector/{DetectorId}/publishingDestination");
127
+ b.p("DetectorId", () => input.DetectorId, "{DetectorId}", false);
178
128
  let body;
179
129
  body = JSON.stringify(take(input, {
180
130
  clientToken: [true, (_) => _ ?? generateIdempotencyToken(), `ClientToken`],
181
131
  destinationProperties: [, (_) => se_DestinationProperties(_, context), `DestinationProperties`],
182
132
  destinationType: [, , `DestinationType`],
183
133
  }));
184
- return new __HttpRequest({
185
- protocol,
186
- hostname,
187
- port,
188
- method: "POST",
189
- headers,
190
- path: resolvedPath,
191
- body,
192
- });
134
+ b.m("POST").h(headers).b(body);
135
+ return b.build();
193
136
  };
194
137
  export const se_CreateSampleFindingsCommand = async (input, context) => {
195
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
138
+ const b = rb(input, context);
196
139
  const headers = {
197
140
  "content-type": "application/json",
198
141
  };
199
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/detector/{DetectorId}/findings/create";
200
- resolvedPath = __resolvedPath(resolvedPath, input, "DetectorId", () => input.DetectorId, "{DetectorId}", false);
142
+ b.bp("/detector/{DetectorId}/findings/create");
143
+ b.p("DetectorId", () => input.DetectorId, "{DetectorId}", false);
201
144
  let body;
202
145
  body = JSON.stringify(take(input, {
203
146
  findingTypes: [, (_) => _json(_), `FindingTypes`],
204
147
  }));
205
- return new __HttpRequest({
206
- protocol,
207
- hostname,
208
- port,
209
- method: "POST",
210
- headers,
211
- path: resolvedPath,
212
- body,
213
- });
148
+ b.m("POST").h(headers).b(body);
149
+ return b.build();
214
150
  };
215
151
  export const se_CreateThreatIntelSetCommand = async (input, context) => {
216
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
152
+ const b = rb(input, context);
217
153
  const headers = {
218
154
  "content-type": "application/json",
219
155
  };
220
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/detector/{DetectorId}/threatintelset";
221
- resolvedPath = __resolvedPath(resolvedPath, input, "DetectorId", () => input.DetectorId, "{DetectorId}", false);
156
+ b.bp("/detector/{DetectorId}/threatintelset");
157
+ b.p("DetectorId", () => input.DetectorId, "{DetectorId}", false);
222
158
  let body;
223
159
  body = JSON.stringify(take(input, {
224
160
  activate: [, , `Activate`],
@@ -228,171 +164,105 @@ export const se_CreateThreatIntelSetCommand = async (input, context) => {
228
164
  name: [, , `Name`],
229
165
  tags: [, (_) => _json(_), `Tags`],
230
166
  }));
231
- return new __HttpRequest({
232
- protocol,
233
- hostname,
234
- port,
235
- method: "POST",
236
- headers,
237
- path: resolvedPath,
238
- body,
239
- });
167
+ b.m("POST").h(headers).b(body);
168
+ return b.build();
240
169
  };
241
170
  export const se_DeclineInvitationsCommand = async (input, context) => {
242
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
171
+ const b = rb(input, context);
243
172
  const headers = {
244
173
  "content-type": "application/json",
245
174
  };
246
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/invitation/decline";
175
+ b.bp("/invitation/decline");
247
176
  let body;
248
177
  body = JSON.stringify(take(input, {
249
178
  accountIds: [, (_) => _json(_), `AccountIds`],
250
179
  }));
251
- return new __HttpRequest({
252
- protocol,
253
- hostname,
254
- port,
255
- method: "POST",
256
- headers,
257
- path: resolvedPath,
258
- body,
259
- });
180
+ b.m("POST").h(headers).b(body);
181
+ return b.build();
260
182
  };
261
183
  export const se_DeleteDetectorCommand = async (input, context) => {
262
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
184
+ const b = rb(input, context);
263
185
  const headers = {};
264
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/detector/{DetectorId}";
265
- resolvedPath = __resolvedPath(resolvedPath, input, "DetectorId", () => input.DetectorId, "{DetectorId}", false);
186
+ b.bp("/detector/{DetectorId}");
187
+ b.p("DetectorId", () => input.DetectorId, "{DetectorId}", false);
266
188
  let body;
267
- return new __HttpRequest({
268
- protocol,
269
- hostname,
270
- port,
271
- method: "DELETE",
272
- headers,
273
- path: resolvedPath,
274
- body,
275
- });
189
+ b.m("DELETE").h(headers).b(body);
190
+ return b.build();
276
191
  };
277
192
  export const se_DeleteFilterCommand = async (input, context) => {
278
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
193
+ const b = rb(input, context);
279
194
  const headers = {};
280
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
281
- "/detector/{DetectorId}/filter/{FilterName}";
282
- resolvedPath = __resolvedPath(resolvedPath, input, "DetectorId", () => input.DetectorId, "{DetectorId}", false);
283
- resolvedPath = __resolvedPath(resolvedPath, input, "FilterName", () => input.FilterName, "{FilterName}", false);
195
+ b.bp("/detector/{DetectorId}/filter/{FilterName}");
196
+ b.p("DetectorId", () => input.DetectorId, "{DetectorId}", false);
197
+ b.p("FilterName", () => input.FilterName, "{FilterName}", false);
284
198
  let body;
285
- return new __HttpRequest({
286
- protocol,
287
- hostname,
288
- port,
289
- method: "DELETE",
290
- headers,
291
- path: resolvedPath,
292
- body,
293
- });
199
+ b.m("DELETE").h(headers).b(body);
200
+ return b.build();
294
201
  };
295
202
  export const se_DeleteInvitationsCommand = async (input, context) => {
296
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
203
+ const b = rb(input, context);
297
204
  const headers = {
298
205
  "content-type": "application/json",
299
206
  };
300
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/invitation/delete";
207
+ b.bp("/invitation/delete");
301
208
  let body;
302
209
  body = JSON.stringify(take(input, {
303
210
  accountIds: [, (_) => _json(_), `AccountIds`],
304
211
  }));
305
- return new __HttpRequest({
306
- protocol,
307
- hostname,
308
- port,
309
- method: "POST",
310
- headers,
311
- path: resolvedPath,
312
- body,
313
- });
212
+ b.m("POST").h(headers).b(body);
213
+ return b.build();
314
214
  };
315
215
  export const se_DeleteIPSetCommand = async (input, context) => {
316
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
216
+ const b = rb(input, context);
317
217
  const headers = {};
318
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/detector/{DetectorId}/ipset/{IpSetId}";
319
- resolvedPath = __resolvedPath(resolvedPath, input, "DetectorId", () => input.DetectorId, "{DetectorId}", false);
320
- resolvedPath = __resolvedPath(resolvedPath, input, "IpSetId", () => input.IpSetId, "{IpSetId}", false);
218
+ b.bp("/detector/{DetectorId}/ipset/{IpSetId}");
219
+ b.p("DetectorId", () => input.DetectorId, "{DetectorId}", false);
220
+ b.p("IpSetId", () => input.IpSetId, "{IpSetId}", false);
321
221
  let body;
322
- return new __HttpRequest({
323
- protocol,
324
- hostname,
325
- port,
326
- method: "DELETE",
327
- headers,
328
- path: resolvedPath,
329
- body,
330
- });
222
+ b.m("DELETE").h(headers).b(body);
223
+ return b.build();
331
224
  };
332
225
  export const se_DeleteMembersCommand = async (input, context) => {
333
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
226
+ const b = rb(input, context);
334
227
  const headers = {
335
228
  "content-type": "application/json",
336
229
  };
337
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/detector/{DetectorId}/member/delete";
338
- resolvedPath = __resolvedPath(resolvedPath, input, "DetectorId", () => input.DetectorId, "{DetectorId}", false);
230
+ b.bp("/detector/{DetectorId}/member/delete");
231
+ b.p("DetectorId", () => input.DetectorId, "{DetectorId}", false);
339
232
  let body;
340
233
  body = JSON.stringify(take(input, {
341
234
  accountIds: [, (_) => _json(_), `AccountIds`],
342
235
  }));
343
- return new __HttpRequest({
344
- protocol,
345
- hostname,
346
- port,
347
- method: "POST",
348
- headers,
349
- path: resolvedPath,
350
- body,
351
- });
236
+ b.m("POST").h(headers).b(body);
237
+ return b.build();
352
238
  };
353
239
  export const se_DeletePublishingDestinationCommand = async (input, context) => {
354
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
240
+ const b = rb(input, context);
355
241
  const headers = {};
356
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
357
- "/detector/{DetectorId}/publishingDestination/{DestinationId}";
358
- resolvedPath = __resolvedPath(resolvedPath, input, "DetectorId", () => input.DetectorId, "{DetectorId}", false);
359
- resolvedPath = __resolvedPath(resolvedPath, input, "DestinationId", () => input.DestinationId, "{DestinationId}", false);
242
+ b.bp("/detector/{DetectorId}/publishingDestination/{DestinationId}");
243
+ b.p("DetectorId", () => input.DetectorId, "{DetectorId}", false);
244
+ b.p("DestinationId", () => input.DestinationId, "{DestinationId}", false);
360
245
  let body;
361
- return new __HttpRequest({
362
- protocol,
363
- hostname,
364
- port,
365
- method: "DELETE",
366
- headers,
367
- path: resolvedPath,
368
- body,
369
- });
246
+ b.m("DELETE").h(headers).b(body);
247
+ return b.build();
370
248
  };
371
249
  export const se_DeleteThreatIntelSetCommand = async (input, context) => {
372
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
250
+ const b = rb(input, context);
373
251
  const headers = {};
374
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
375
- "/detector/{DetectorId}/threatintelset/{ThreatIntelSetId}";
376
- resolvedPath = __resolvedPath(resolvedPath, input, "DetectorId", () => input.DetectorId, "{DetectorId}", false);
377
- resolvedPath = __resolvedPath(resolvedPath, input, "ThreatIntelSetId", () => input.ThreatIntelSetId, "{ThreatIntelSetId}", false);
252
+ b.bp("/detector/{DetectorId}/threatintelset/{ThreatIntelSetId}");
253
+ b.p("DetectorId", () => input.DetectorId, "{DetectorId}", false);
254
+ b.p("ThreatIntelSetId", () => input.ThreatIntelSetId, "{ThreatIntelSetId}", false);
378
255
  let body;
379
- return new __HttpRequest({
380
- protocol,
381
- hostname,
382
- port,
383
- method: "DELETE",
384
- headers,
385
- path: resolvedPath,
386
- body,
387
- });
256
+ b.m("DELETE").h(headers).b(body);
257
+ return b.build();
388
258
  };
389
259
  export const se_DescribeMalwareScansCommand = async (input, context) => {
390
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
260
+ const b = rb(input, context);
391
261
  const headers = {
392
262
  "content-type": "application/json",
393
263
  };
394
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/detector/{DetectorId}/malware-scans";
395
- resolvedPath = __resolvedPath(resolvedPath, input, "DetectorId", () => input.DetectorId, "{DetectorId}", false);
264
+ b.bp("/detector/{DetectorId}/malware-scans");
265
+ b.p("DetectorId", () => input.DetectorId, "{DetectorId}", false);
396
266
  let body;
397
267
  body = JSON.stringify(take(input, {
398
268
  filterCriteria: [, (_) => se_FilterCriteria(_, context), `FilterCriteria`],
@@ -400,427 +270,261 @@ export const se_DescribeMalwareScansCommand = async (input, context) => {
400
270
  nextToken: [, , `NextToken`],
401
271
  sortCriteria: [, (_) => se_SortCriteria(_, context), `SortCriteria`],
402
272
  }));
403
- return new __HttpRequest({
404
- protocol,
405
- hostname,
406
- port,
407
- method: "POST",
408
- headers,
409
- path: resolvedPath,
410
- body,
411
- });
273
+ b.m("POST").h(headers).b(body);
274
+ return b.build();
412
275
  };
413
276
  export const se_DescribeOrganizationConfigurationCommand = async (input, context) => {
414
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
277
+ const b = rb(input, context);
415
278
  const headers = {};
416
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/detector/{DetectorId}/admin";
417
- resolvedPath = __resolvedPath(resolvedPath, input, "DetectorId", () => input.DetectorId, "{DetectorId}", false);
279
+ b.bp("/detector/{DetectorId}/admin");
280
+ b.p("DetectorId", () => input.DetectorId, "{DetectorId}", false);
418
281
  const query = map({
419
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
420
- nextToken: [, input.NextToken],
282
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
283
+ [_nT]: [, input[_NT]],
421
284
  });
422
285
  let body;
423
- return new __HttpRequest({
424
- protocol,
425
- hostname,
426
- port,
427
- method: "GET",
428
- headers,
429
- path: resolvedPath,
430
- query,
431
- body,
432
- });
286
+ b.m("GET").h(headers).q(query).b(body);
287
+ return b.build();
433
288
  };
434
289
  export const se_DescribePublishingDestinationCommand = async (input, context) => {
435
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
290
+ const b = rb(input, context);
436
291
  const headers = {};
437
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
438
- "/detector/{DetectorId}/publishingDestination/{DestinationId}";
439
- resolvedPath = __resolvedPath(resolvedPath, input, "DetectorId", () => input.DetectorId, "{DetectorId}", false);
440
- resolvedPath = __resolvedPath(resolvedPath, input, "DestinationId", () => input.DestinationId, "{DestinationId}", false);
292
+ b.bp("/detector/{DetectorId}/publishingDestination/{DestinationId}");
293
+ b.p("DetectorId", () => input.DetectorId, "{DetectorId}", false);
294
+ b.p("DestinationId", () => input.DestinationId, "{DestinationId}", false);
441
295
  let body;
442
- return new __HttpRequest({
443
- protocol,
444
- hostname,
445
- port,
446
- method: "GET",
447
- headers,
448
- path: resolvedPath,
449
- body,
450
- });
296
+ b.m("GET").h(headers).b(body);
297
+ return b.build();
451
298
  };
452
299
  export const se_DisableOrganizationAdminAccountCommand = async (input, context) => {
453
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
300
+ const b = rb(input, context);
454
301
  const headers = {
455
302
  "content-type": "application/json",
456
303
  };
457
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/admin/disable";
304
+ b.bp("/admin/disable");
458
305
  let body;
459
306
  body = JSON.stringify(take(input, {
460
307
  adminAccountId: [, , `AdminAccountId`],
461
308
  }));
462
- return new __HttpRequest({
463
- protocol,
464
- hostname,
465
- port,
466
- method: "POST",
467
- headers,
468
- path: resolvedPath,
469
- body,
470
- });
309
+ b.m("POST").h(headers).b(body);
310
+ return b.build();
471
311
  };
472
312
  export const se_DisassociateFromAdministratorAccountCommand = async (input, context) => {
473
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
313
+ const b = rb(input, context);
474
314
  const headers = {};
475
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
476
- "/detector/{DetectorId}/administrator/disassociate";
477
- resolvedPath = __resolvedPath(resolvedPath, input, "DetectorId", () => input.DetectorId, "{DetectorId}", false);
315
+ b.bp("/detector/{DetectorId}/administrator/disassociate");
316
+ b.p("DetectorId", () => input.DetectorId, "{DetectorId}", false);
478
317
  let body;
479
- return new __HttpRequest({
480
- protocol,
481
- hostname,
482
- port,
483
- method: "POST",
484
- headers,
485
- path: resolvedPath,
486
- body,
487
- });
318
+ b.m("POST").h(headers).b(body);
319
+ return b.build();
488
320
  };
489
321
  export const se_DisassociateFromMasterAccountCommand = async (input, context) => {
490
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
322
+ const b = rb(input, context);
491
323
  const headers = {};
492
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
493
- "/detector/{DetectorId}/master/disassociate";
494
- resolvedPath = __resolvedPath(resolvedPath, input, "DetectorId", () => input.DetectorId, "{DetectorId}", false);
324
+ b.bp("/detector/{DetectorId}/master/disassociate");
325
+ b.p("DetectorId", () => input.DetectorId, "{DetectorId}", false);
495
326
  let body;
496
- return new __HttpRequest({
497
- protocol,
498
- hostname,
499
- port,
500
- method: "POST",
501
- headers,
502
- path: resolvedPath,
503
- body,
504
- });
327
+ b.m("POST").h(headers).b(body);
328
+ return b.build();
505
329
  };
506
330
  export const se_DisassociateMembersCommand = async (input, context) => {
507
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
331
+ const b = rb(input, context);
508
332
  const headers = {
509
333
  "content-type": "application/json",
510
334
  };
511
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
512
- "/detector/{DetectorId}/member/disassociate";
513
- resolvedPath = __resolvedPath(resolvedPath, input, "DetectorId", () => input.DetectorId, "{DetectorId}", false);
335
+ b.bp("/detector/{DetectorId}/member/disassociate");
336
+ b.p("DetectorId", () => input.DetectorId, "{DetectorId}", false);
514
337
  let body;
515
338
  body = JSON.stringify(take(input, {
516
339
  accountIds: [, (_) => _json(_), `AccountIds`],
517
340
  }));
518
- return new __HttpRequest({
519
- protocol,
520
- hostname,
521
- port,
522
- method: "POST",
523
- headers,
524
- path: resolvedPath,
525
- body,
526
- });
341
+ b.m("POST").h(headers).b(body);
342
+ return b.build();
527
343
  };
528
344
  export const se_EnableOrganizationAdminAccountCommand = async (input, context) => {
529
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
345
+ const b = rb(input, context);
530
346
  const headers = {
531
347
  "content-type": "application/json",
532
348
  };
533
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/admin/enable";
349
+ b.bp("/admin/enable");
534
350
  let body;
535
351
  body = JSON.stringify(take(input, {
536
352
  adminAccountId: [, , `AdminAccountId`],
537
353
  }));
538
- return new __HttpRequest({
539
- protocol,
540
- hostname,
541
- port,
542
- method: "POST",
543
- headers,
544
- path: resolvedPath,
545
- body,
546
- });
354
+ b.m("POST").h(headers).b(body);
355
+ return b.build();
547
356
  };
548
357
  export const se_GetAdministratorAccountCommand = async (input, context) => {
549
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
358
+ const b = rb(input, context);
550
359
  const headers = {};
551
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/detector/{DetectorId}/administrator";
552
- resolvedPath = __resolvedPath(resolvedPath, input, "DetectorId", () => input.DetectorId, "{DetectorId}", false);
360
+ b.bp("/detector/{DetectorId}/administrator");
361
+ b.p("DetectorId", () => input.DetectorId, "{DetectorId}", false);
553
362
  let body;
554
- return new __HttpRequest({
555
- protocol,
556
- hostname,
557
- port,
558
- method: "GET",
559
- headers,
560
- path: resolvedPath,
561
- body,
562
- });
363
+ b.m("GET").h(headers).b(body);
364
+ return b.build();
563
365
  };
564
366
  export const se_GetCoverageStatisticsCommand = async (input, context) => {
565
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
367
+ const b = rb(input, context);
566
368
  const headers = {
567
369
  "content-type": "application/json",
568
370
  };
569
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
570
- "/detector/{DetectorId}/coverage/statistics";
571
- resolvedPath = __resolvedPath(resolvedPath, input, "DetectorId", () => input.DetectorId, "{DetectorId}", false);
371
+ b.bp("/detector/{DetectorId}/coverage/statistics");
372
+ b.p("DetectorId", () => input.DetectorId, "{DetectorId}", false);
572
373
  let body;
573
374
  body = JSON.stringify(take(input, {
574
375
  filterCriteria: [, (_) => se_CoverageFilterCriteria(_, context), `FilterCriteria`],
575
376
  statisticsType: [, (_) => _json(_), `StatisticsType`],
576
377
  }));
577
- return new __HttpRequest({
578
- protocol,
579
- hostname,
580
- port,
581
- method: "POST",
582
- headers,
583
- path: resolvedPath,
584
- body,
585
- });
378
+ b.m("POST").h(headers).b(body);
379
+ return b.build();
586
380
  };
587
381
  export const se_GetDetectorCommand = async (input, context) => {
588
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
382
+ const b = rb(input, context);
589
383
  const headers = {};
590
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/detector/{DetectorId}";
591
- resolvedPath = __resolvedPath(resolvedPath, input, "DetectorId", () => input.DetectorId, "{DetectorId}", false);
384
+ b.bp("/detector/{DetectorId}");
385
+ b.p("DetectorId", () => input.DetectorId, "{DetectorId}", false);
592
386
  let body;
593
- return new __HttpRequest({
594
- protocol,
595
- hostname,
596
- port,
597
- method: "GET",
598
- headers,
599
- path: resolvedPath,
600
- body,
601
- });
387
+ b.m("GET").h(headers).b(body);
388
+ return b.build();
602
389
  };
603
390
  export const se_GetFilterCommand = async (input, context) => {
604
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
391
+ const b = rb(input, context);
605
392
  const headers = {};
606
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
607
- "/detector/{DetectorId}/filter/{FilterName}";
608
- resolvedPath = __resolvedPath(resolvedPath, input, "DetectorId", () => input.DetectorId, "{DetectorId}", false);
609
- resolvedPath = __resolvedPath(resolvedPath, input, "FilterName", () => input.FilterName, "{FilterName}", false);
393
+ b.bp("/detector/{DetectorId}/filter/{FilterName}");
394
+ b.p("DetectorId", () => input.DetectorId, "{DetectorId}", false);
395
+ b.p("FilterName", () => input.FilterName, "{FilterName}", false);
610
396
  let body;
611
- return new __HttpRequest({
612
- protocol,
613
- hostname,
614
- port,
615
- method: "GET",
616
- headers,
617
- path: resolvedPath,
618
- body,
619
- });
397
+ b.m("GET").h(headers).b(body);
398
+ return b.build();
620
399
  };
621
400
  export const se_GetFindingsCommand = async (input, context) => {
622
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
401
+ const b = rb(input, context);
623
402
  const headers = {
624
403
  "content-type": "application/json",
625
404
  };
626
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/detector/{DetectorId}/findings/get";
627
- resolvedPath = __resolvedPath(resolvedPath, input, "DetectorId", () => input.DetectorId, "{DetectorId}", false);
405
+ b.bp("/detector/{DetectorId}/findings/get");
406
+ b.p("DetectorId", () => input.DetectorId, "{DetectorId}", false);
628
407
  let body;
629
408
  body = JSON.stringify(take(input, {
630
409
  findingIds: [, (_) => _json(_), `FindingIds`],
631
410
  sortCriteria: [, (_) => se_SortCriteria(_, context), `SortCriteria`],
632
411
  }));
633
- return new __HttpRequest({
634
- protocol,
635
- hostname,
636
- port,
637
- method: "POST",
638
- headers,
639
- path: resolvedPath,
640
- body,
641
- });
412
+ b.m("POST").h(headers).b(body);
413
+ return b.build();
642
414
  };
643
415
  export const se_GetFindingsStatisticsCommand = async (input, context) => {
644
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
416
+ const b = rb(input, context);
645
417
  const headers = {
646
418
  "content-type": "application/json",
647
419
  };
648
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
649
- "/detector/{DetectorId}/findings/statistics";
650
- resolvedPath = __resolvedPath(resolvedPath, input, "DetectorId", () => input.DetectorId, "{DetectorId}", false);
420
+ b.bp("/detector/{DetectorId}/findings/statistics");
421
+ b.p("DetectorId", () => input.DetectorId, "{DetectorId}", false);
651
422
  let body;
652
423
  body = JSON.stringify(take(input, {
653
424
  findingCriteria: [, (_) => se_FindingCriteria(_, context), `FindingCriteria`],
654
425
  findingStatisticTypes: [, (_) => _json(_), `FindingStatisticTypes`],
655
426
  }));
656
- return new __HttpRequest({
657
- protocol,
658
- hostname,
659
- port,
660
- method: "POST",
661
- headers,
662
- path: resolvedPath,
663
- body,
664
- });
427
+ b.m("POST").h(headers).b(body);
428
+ return b.build();
665
429
  };
666
430
  export const se_GetInvitationsCountCommand = async (input, context) => {
667
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
431
+ const b = rb(input, context);
668
432
  const headers = {
669
433
  "content-type": "application/json",
670
434
  };
671
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/invitation/count";
435
+ b.bp("/invitation/count");
672
436
  let body;
673
437
  body = "";
674
- return new __HttpRequest({
675
- protocol,
676
- hostname,
677
- port,
678
- method: "GET",
679
- headers,
680
- path: resolvedPath,
681
- body,
682
- });
438
+ b.m("GET").h(headers).b(body);
439
+ return b.build();
683
440
  };
684
441
  export const se_GetIPSetCommand = async (input, context) => {
685
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
442
+ const b = rb(input, context);
686
443
  const headers = {};
687
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/detector/{DetectorId}/ipset/{IpSetId}";
688
- resolvedPath = __resolvedPath(resolvedPath, input, "DetectorId", () => input.DetectorId, "{DetectorId}", false);
689
- resolvedPath = __resolvedPath(resolvedPath, input, "IpSetId", () => input.IpSetId, "{IpSetId}", false);
444
+ b.bp("/detector/{DetectorId}/ipset/{IpSetId}");
445
+ b.p("DetectorId", () => input.DetectorId, "{DetectorId}", false);
446
+ b.p("IpSetId", () => input.IpSetId, "{IpSetId}", false);
690
447
  let body;
691
- return new __HttpRequest({
692
- protocol,
693
- hostname,
694
- port,
695
- method: "GET",
696
- headers,
697
- path: resolvedPath,
698
- body,
699
- });
448
+ b.m("GET").h(headers).b(body);
449
+ return b.build();
700
450
  };
701
451
  export const se_GetMalwareScanSettingsCommand = async (input, context) => {
702
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
452
+ const b = rb(input, context);
703
453
  const headers = {};
704
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
705
- "/detector/{DetectorId}/malware-scan-settings";
706
- resolvedPath = __resolvedPath(resolvedPath, input, "DetectorId", () => input.DetectorId, "{DetectorId}", false);
454
+ b.bp("/detector/{DetectorId}/malware-scan-settings");
455
+ b.p("DetectorId", () => input.DetectorId, "{DetectorId}", false);
707
456
  let body;
708
- return new __HttpRequest({
709
- protocol,
710
- hostname,
711
- port,
712
- method: "GET",
713
- headers,
714
- path: resolvedPath,
715
- body,
716
- });
457
+ b.m("GET").h(headers).b(body);
458
+ return b.build();
717
459
  };
718
460
  export const se_GetMasterAccountCommand = async (input, context) => {
719
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
461
+ const b = rb(input, context);
720
462
  const headers = {};
721
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/detector/{DetectorId}/master";
722
- resolvedPath = __resolvedPath(resolvedPath, input, "DetectorId", () => input.DetectorId, "{DetectorId}", false);
463
+ b.bp("/detector/{DetectorId}/master");
464
+ b.p("DetectorId", () => input.DetectorId, "{DetectorId}", false);
723
465
  let body;
724
- return new __HttpRequest({
725
- protocol,
726
- hostname,
727
- port,
728
- method: "GET",
729
- headers,
730
- path: resolvedPath,
731
- body,
732
- });
466
+ b.m("GET").h(headers).b(body);
467
+ return b.build();
733
468
  };
734
469
  export const se_GetMemberDetectorsCommand = async (input, context) => {
735
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
470
+ const b = rb(input, context);
736
471
  const headers = {
737
472
  "content-type": "application/json",
738
473
  };
739
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
740
- "/detector/{DetectorId}/member/detector/get";
741
- resolvedPath = __resolvedPath(resolvedPath, input, "DetectorId", () => input.DetectorId, "{DetectorId}", false);
474
+ b.bp("/detector/{DetectorId}/member/detector/get");
475
+ b.p("DetectorId", () => input.DetectorId, "{DetectorId}", false);
742
476
  let body;
743
477
  body = JSON.stringify(take(input, {
744
478
  accountIds: [, (_) => _json(_), `AccountIds`],
745
479
  }));
746
- return new __HttpRequest({
747
- protocol,
748
- hostname,
749
- port,
750
- method: "POST",
751
- headers,
752
- path: resolvedPath,
753
- body,
754
- });
480
+ b.m("POST").h(headers).b(body);
481
+ return b.build();
755
482
  };
756
483
  export const se_GetMembersCommand = async (input, context) => {
757
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
484
+ const b = rb(input, context);
758
485
  const headers = {
759
486
  "content-type": "application/json",
760
487
  };
761
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/detector/{DetectorId}/member/get";
762
- resolvedPath = __resolvedPath(resolvedPath, input, "DetectorId", () => input.DetectorId, "{DetectorId}", false);
488
+ b.bp("/detector/{DetectorId}/member/get");
489
+ b.p("DetectorId", () => input.DetectorId, "{DetectorId}", false);
763
490
  let body;
764
491
  body = JSON.stringify(take(input, {
765
492
  accountIds: [, (_) => _json(_), `AccountIds`],
766
493
  }));
767
- return new __HttpRequest({
768
- protocol,
769
- hostname,
770
- port,
771
- method: "POST",
772
- headers,
773
- path: resolvedPath,
774
- body,
775
- });
494
+ b.m("POST").h(headers).b(body);
495
+ return b.build();
776
496
  };
777
497
  export const se_GetRemainingFreeTrialDaysCommand = async (input, context) => {
778
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
498
+ const b = rb(input, context);
779
499
  const headers = {
780
500
  "content-type": "application/json",
781
501
  };
782
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
783
- "/detector/{DetectorId}/freeTrial/daysRemaining";
784
- resolvedPath = __resolvedPath(resolvedPath, input, "DetectorId", () => input.DetectorId, "{DetectorId}", false);
502
+ b.bp("/detector/{DetectorId}/freeTrial/daysRemaining");
503
+ b.p("DetectorId", () => input.DetectorId, "{DetectorId}", false);
785
504
  let body;
786
505
  body = JSON.stringify(take(input, {
787
506
  accountIds: [, (_) => _json(_), `AccountIds`],
788
507
  }));
789
- return new __HttpRequest({
790
- protocol,
791
- hostname,
792
- port,
793
- method: "POST",
794
- headers,
795
- path: resolvedPath,
796
- body,
797
- });
508
+ b.m("POST").h(headers).b(body);
509
+ return b.build();
798
510
  };
799
511
  export const se_GetThreatIntelSetCommand = async (input, context) => {
800
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
512
+ const b = rb(input, context);
801
513
  const headers = {};
802
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
803
- "/detector/{DetectorId}/threatintelset/{ThreatIntelSetId}";
804
- resolvedPath = __resolvedPath(resolvedPath, input, "DetectorId", () => input.DetectorId, "{DetectorId}", false);
805
- resolvedPath = __resolvedPath(resolvedPath, input, "ThreatIntelSetId", () => input.ThreatIntelSetId, "{ThreatIntelSetId}", false);
514
+ b.bp("/detector/{DetectorId}/threatintelset/{ThreatIntelSetId}");
515
+ b.p("DetectorId", () => input.DetectorId, "{DetectorId}", false);
516
+ b.p("ThreatIntelSetId", () => input.ThreatIntelSetId, "{ThreatIntelSetId}", false);
806
517
  let body;
807
- return new __HttpRequest({
808
- protocol,
809
- hostname,
810
- port,
811
- method: "GET",
812
- headers,
813
- path: resolvedPath,
814
- body,
815
- });
518
+ b.m("GET").h(headers).b(body);
519
+ return b.build();
816
520
  };
817
521
  export const se_GetUsageStatisticsCommand = async (input, context) => {
818
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
522
+ const b = rb(input, context);
819
523
  const headers = {
820
524
  "content-type": "application/json",
821
525
  };
822
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/detector/{DetectorId}/usage/statistics";
823
- resolvedPath = __resolvedPath(resolvedPath, input, "DetectorId", () => input.DetectorId, "{DetectorId}", false);
526
+ b.bp("/detector/{DetectorId}/usage/statistics");
527
+ b.p("DetectorId", () => input.DetectorId, "{DetectorId}", false);
824
528
  let body;
825
529
  body = JSON.stringify(take(input, {
826
530
  maxResults: [, , `MaxResults`],
@@ -829,46 +533,32 @@ export const se_GetUsageStatisticsCommand = async (input, context) => {
829
533
  usageCriteria: [, (_) => se_UsageCriteria(_, context), `UsageCriteria`],
830
534
  usageStatisticsType: [, , `UsageStatisticType`],
831
535
  }));
832
- return new __HttpRequest({
833
- protocol,
834
- hostname,
835
- port,
836
- method: "POST",
837
- headers,
838
- path: resolvedPath,
839
- body,
840
- });
536
+ b.m("POST").h(headers).b(body);
537
+ return b.build();
841
538
  };
842
539
  export const se_InviteMembersCommand = async (input, context) => {
843
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
540
+ const b = rb(input, context);
844
541
  const headers = {
845
542
  "content-type": "application/json",
846
543
  };
847
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/detector/{DetectorId}/member/invite";
848
- resolvedPath = __resolvedPath(resolvedPath, input, "DetectorId", () => input.DetectorId, "{DetectorId}", false);
544
+ b.bp("/detector/{DetectorId}/member/invite");
545
+ b.p("DetectorId", () => input.DetectorId, "{DetectorId}", false);
849
546
  let body;
850
547
  body = JSON.stringify(take(input, {
851
548
  accountIds: [, (_) => _json(_), `AccountIds`],
852
549
  disableEmailNotification: [, , `DisableEmailNotification`],
853
550
  message: [, , `Message`],
854
551
  }));
855
- return new __HttpRequest({
856
- protocol,
857
- hostname,
858
- port,
859
- method: "POST",
860
- headers,
861
- path: resolvedPath,
862
- body,
863
- });
552
+ b.m("POST").h(headers).b(body);
553
+ return b.build();
864
554
  };
865
555
  export const se_ListCoverageCommand = async (input, context) => {
866
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
556
+ const b = rb(input, context);
867
557
  const headers = {
868
558
  "content-type": "application/json",
869
559
  };
870
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/detector/{DetectorId}/coverage";
871
- resolvedPath = __resolvedPath(resolvedPath, input, "DetectorId", () => input.DetectorId, "{DetectorId}", false);
560
+ b.bp("/detector/{DetectorId}/coverage");
561
+ b.p("DetectorId", () => input.DetectorId, "{DetectorId}", false);
872
562
  let body;
873
563
  body = JSON.stringify(take(input, {
874
564
  filterCriteria: [, (_) => se_CoverageFilterCriteria(_, context), `FilterCriteria`],
@@ -876,64 +566,41 @@ export const se_ListCoverageCommand = async (input, context) => {
876
566
  nextToken: [, , `NextToken`],
877
567
  sortCriteria: [, (_) => se_CoverageSortCriteria(_, context), `SortCriteria`],
878
568
  }));
879
- return new __HttpRequest({
880
- protocol,
881
- hostname,
882
- port,
883
- method: "POST",
884
- headers,
885
- path: resolvedPath,
886
- body,
887
- });
569
+ b.m("POST").h(headers).b(body);
570
+ return b.build();
888
571
  };
889
572
  export const se_ListDetectorsCommand = async (input, context) => {
890
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
573
+ const b = rb(input, context);
891
574
  const headers = {};
892
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/detector";
575
+ b.bp("/detector");
893
576
  const query = map({
894
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
895
- nextToken: [, input.NextToken],
577
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
578
+ [_nT]: [, input[_NT]],
896
579
  });
897
580
  let body;
898
- return new __HttpRequest({
899
- protocol,
900
- hostname,
901
- port,
902
- method: "GET",
903
- headers,
904
- path: resolvedPath,
905
- query,
906
- body,
907
- });
581
+ b.m("GET").h(headers).q(query).b(body);
582
+ return b.build();
908
583
  };
909
584
  export const se_ListFiltersCommand = async (input, context) => {
910
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
585
+ const b = rb(input, context);
911
586
  const headers = {};
912
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/detector/{DetectorId}/filter";
913
- resolvedPath = __resolvedPath(resolvedPath, input, "DetectorId", () => input.DetectorId, "{DetectorId}", false);
587
+ b.bp("/detector/{DetectorId}/filter");
588
+ b.p("DetectorId", () => input.DetectorId, "{DetectorId}", false);
914
589
  const query = map({
915
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
916
- nextToken: [, input.NextToken],
590
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
591
+ [_nT]: [, input[_NT]],
917
592
  });
918
593
  let body;
919
- return new __HttpRequest({
920
- protocol,
921
- hostname,
922
- port,
923
- method: "GET",
924
- headers,
925
- path: resolvedPath,
926
- query,
927
- body,
928
- });
594
+ b.m("GET").h(headers).q(query).b(body);
595
+ return b.build();
929
596
  };
930
597
  export const se_ListFindingsCommand = async (input, context) => {
931
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
598
+ const b = rb(input, context);
932
599
  const headers = {
933
600
  "content-type": "application/json",
934
601
  };
935
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/detector/{DetectorId}/findings";
936
- resolvedPath = __resolvedPath(resolvedPath, input, "DetectorId", () => input.DetectorId, "{DetectorId}", false);
602
+ b.bp("/detector/{DetectorId}/findings");
603
+ b.p("DetectorId", () => input.DetectorId, "{DetectorId}", false);
937
604
  let body;
938
605
  body = JSON.stringify(take(input, {
939
606
  findingCriteria: [, (_) => se_FindingCriteria(_, context), `FindingCriteria`],
@@ -941,292 +608,186 @@ export const se_ListFindingsCommand = async (input, context) => {
941
608
  nextToken: [, , `NextToken`],
942
609
  sortCriteria: [, (_) => se_SortCriteria(_, context), `SortCriteria`],
943
610
  }));
944
- return new __HttpRequest({
945
- protocol,
946
- hostname,
947
- port,
948
- method: "POST",
949
- headers,
950
- path: resolvedPath,
951
- body,
952
- });
611
+ b.m("POST").h(headers).b(body);
612
+ return b.build();
953
613
  };
954
614
  export const se_ListInvitationsCommand = async (input, context) => {
955
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
615
+ const b = rb(input, context);
956
616
  const headers = {};
957
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/invitation";
617
+ b.bp("/invitation");
958
618
  const query = map({
959
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
960
- nextToken: [, input.NextToken],
619
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
620
+ [_nT]: [, input[_NT]],
961
621
  });
962
622
  let body;
963
- return new __HttpRequest({
964
- protocol,
965
- hostname,
966
- port,
967
- method: "GET",
968
- headers,
969
- path: resolvedPath,
970
- query,
971
- body,
972
- });
623
+ b.m("GET").h(headers).q(query).b(body);
624
+ return b.build();
973
625
  };
974
626
  export const se_ListIPSetsCommand = async (input, context) => {
975
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
627
+ const b = rb(input, context);
976
628
  const headers = {};
977
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/detector/{DetectorId}/ipset";
978
- resolvedPath = __resolvedPath(resolvedPath, input, "DetectorId", () => input.DetectorId, "{DetectorId}", false);
629
+ b.bp("/detector/{DetectorId}/ipset");
630
+ b.p("DetectorId", () => input.DetectorId, "{DetectorId}", false);
979
631
  const query = map({
980
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
981
- nextToken: [, input.NextToken],
632
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
633
+ [_nT]: [, input[_NT]],
982
634
  });
983
635
  let body;
984
- return new __HttpRequest({
985
- protocol,
986
- hostname,
987
- port,
988
- method: "GET",
989
- headers,
990
- path: resolvedPath,
991
- query,
992
- body,
993
- });
636
+ b.m("GET").h(headers).q(query).b(body);
637
+ return b.build();
994
638
  };
995
639
  export const se_ListMembersCommand = async (input, context) => {
996
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
640
+ const b = rb(input, context);
997
641
  const headers = {};
998
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/detector/{DetectorId}/member";
999
- resolvedPath = __resolvedPath(resolvedPath, input, "DetectorId", () => input.DetectorId, "{DetectorId}", false);
642
+ b.bp("/detector/{DetectorId}/member");
643
+ b.p("DetectorId", () => input.DetectorId, "{DetectorId}", false);
1000
644
  const query = map({
1001
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
1002
- nextToken: [, input.NextToken],
1003
- onlyAssociated: [, input.OnlyAssociated],
645
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
646
+ [_nT]: [, input[_NT]],
647
+ [_oA]: [, input[_OA]],
1004
648
  });
1005
649
  let body;
1006
- return new __HttpRequest({
1007
- protocol,
1008
- hostname,
1009
- port,
1010
- method: "GET",
1011
- headers,
1012
- path: resolvedPath,
1013
- query,
1014
- body,
1015
- });
650
+ b.m("GET").h(headers).q(query).b(body);
651
+ return b.build();
1016
652
  };
1017
653
  export const se_ListOrganizationAdminAccountsCommand = async (input, context) => {
1018
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
654
+ const b = rb(input, context);
1019
655
  const headers = {};
1020
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/admin";
656
+ b.bp("/admin");
1021
657
  const query = map({
1022
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
1023
- nextToken: [, input.NextToken],
658
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
659
+ [_nT]: [, input[_NT]],
1024
660
  });
1025
661
  let body;
1026
- return new __HttpRequest({
1027
- protocol,
1028
- hostname,
1029
- port,
1030
- method: "GET",
1031
- headers,
1032
- path: resolvedPath,
1033
- query,
1034
- body,
1035
- });
662
+ b.m("GET").h(headers).q(query).b(body);
663
+ return b.build();
1036
664
  };
1037
665
  export const se_ListPublishingDestinationsCommand = async (input, context) => {
1038
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
666
+ const b = rb(input, context);
1039
667
  const headers = {};
1040
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1041
- "/detector/{DetectorId}/publishingDestination";
1042
- resolvedPath = __resolvedPath(resolvedPath, input, "DetectorId", () => input.DetectorId, "{DetectorId}", false);
668
+ b.bp("/detector/{DetectorId}/publishingDestination");
669
+ b.p("DetectorId", () => input.DetectorId, "{DetectorId}", false);
1043
670
  const query = map({
1044
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
1045
- nextToken: [, input.NextToken],
671
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
672
+ [_nT]: [, input[_NT]],
1046
673
  });
1047
674
  let body;
1048
- return new __HttpRequest({
1049
- protocol,
1050
- hostname,
1051
- port,
1052
- method: "GET",
1053
- headers,
1054
- path: resolvedPath,
1055
- query,
1056
- body,
1057
- });
675
+ b.m("GET").h(headers).q(query).b(body);
676
+ return b.build();
1058
677
  };
1059
678
  export const se_ListTagsForResourceCommand = async (input, context) => {
1060
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
679
+ const b = rb(input, context);
1061
680
  const headers = {};
1062
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{ResourceArn}";
1063
- resolvedPath = __resolvedPath(resolvedPath, input, "ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
681
+ b.bp("/tags/{ResourceArn}");
682
+ b.p("ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
1064
683
  let body;
1065
- return new __HttpRequest({
1066
- protocol,
1067
- hostname,
1068
- port,
1069
- method: "GET",
1070
- headers,
1071
- path: resolvedPath,
1072
- body,
1073
- });
684
+ b.m("GET").h(headers).b(body);
685
+ return b.build();
1074
686
  };
1075
687
  export const se_ListThreatIntelSetsCommand = async (input, context) => {
1076
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
688
+ const b = rb(input, context);
1077
689
  const headers = {};
1078
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/detector/{DetectorId}/threatintelset";
1079
- resolvedPath = __resolvedPath(resolvedPath, input, "DetectorId", () => input.DetectorId, "{DetectorId}", false);
690
+ b.bp("/detector/{DetectorId}/threatintelset");
691
+ b.p("DetectorId", () => input.DetectorId, "{DetectorId}", false);
1080
692
  const query = map({
1081
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
1082
- nextToken: [, input.NextToken],
693
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
694
+ [_nT]: [, input[_NT]],
1083
695
  });
1084
696
  let body;
1085
- return new __HttpRequest({
1086
- protocol,
1087
- hostname,
1088
- port,
1089
- method: "GET",
1090
- headers,
1091
- path: resolvedPath,
1092
- query,
1093
- body,
1094
- });
697
+ b.m("GET").h(headers).q(query).b(body);
698
+ return b.build();
1095
699
  };
1096
700
  export const se_StartMalwareScanCommand = async (input, context) => {
1097
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
701
+ const b = rb(input, context);
1098
702
  const headers = {
1099
703
  "content-type": "application/json",
1100
704
  };
1101
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/malware-scan/start";
705
+ b.bp("/malware-scan/start");
1102
706
  let body;
1103
707
  body = JSON.stringify(take(input, {
1104
708
  resourceArn: [, , `ResourceArn`],
1105
709
  }));
1106
- return new __HttpRequest({
1107
- protocol,
1108
- hostname,
1109
- port,
1110
- method: "POST",
1111
- headers,
1112
- path: resolvedPath,
1113
- body,
1114
- });
710
+ b.m("POST").h(headers).b(body);
711
+ return b.build();
1115
712
  };
1116
713
  export const se_StartMonitoringMembersCommand = async (input, context) => {
1117
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
714
+ const b = rb(input, context);
1118
715
  const headers = {
1119
716
  "content-type": "application/json",
1120
717
  };
1121
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/detector/{DetectorId}/member/start";
1122
- resolvedPath = __resolvedPath(resolvedPath, input, "DetectorId", () => input.DetectorId, "{DetectorId}", false);
718
+ b.bp("/detector/{DetectorId}/member/start");
719
+ b.p("DetectorId", () => input.DetectorId, "{DetectorId}", false);
1123
720
  let body;
1124
721
  body = JSON.stringify(take(input, {
1125
722
  accountIds: [, (_) => _json(_), `AccountIds`],
1126
723
  }));
1127
- return new __HttpRequest({
1128
- protocol,
1129
- hostname,
1130
- port,
1131
- method: "POST",
1132
- headers,
1133
- path: resolvedPath,
1134
- body,
1135
- });
724
+ b.m("POST").h(headers).b(body);
725
+ return b.build();
1136
726
  };
1137
727
  export const se_StopMonitoringMembersCommand = async (input, context) => {
1138
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
728
+ const b = rb(input, context);
1139
729
  const headers = {
1140
730
  "content-type": "application/json",
1141
731
  };
1142
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/detector/{DetectorId}/member/stop";
1143
- resolvedPath = __resolvedPath(resolvedPath, input, "DetectorId", () => input.DetectorId, "{DetectorId}", false);
732
+ b.bp("/detector/{DetectorId}/member/stop");
733
+ b.p("DetectorId", () => input.DetectorId, "{DetectorId}", false);
1144
734
  let body;
1145
735
  body = JSON.stringify(take(input, {
1146
736
  accountIds: [, (_) => _json(_), `AccountIds`],
1147
737
  }));
1148
- return new __HttpRequest({
1149
- protocol,
1150
- hostname,
1151
- port,
1152
- method: "POST",
1153
- headers,
1154
- path: resolvedPath,
1155
- body,
1156
- });
738
+ b.m("POST").h(headers).b(body);
739
+ return b.build();
1157
740
  };
1158
741
  export const se_TagResourceCommand = async (input, context) => {
1159
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
742
+ const b = rb(input, context);
1160
743
  const headers = {
1161
744
  "content-type": "application/json",
1162
745
  };
1163
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{ResourceArn}";
1164
- resolvedPath = __resolvedPath(resolvedPath, input, "ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
746
+ b.bp("/tags/{ResourceArn}");
747
+ b.p("ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
1165
748
  let body;
1166
749
  body = JSON.stringify(take(input, {
1167
750
  tags: [, (_) => _json(_), `Tags`],
1168
751
  }));
1169
- return new __HttpRequest({
1170
- protocol,
1171
- hostname,
1172
- port,
1173
- method: "POST",
1174
- headers,
1175
- path: resolvedPath,
1176
- body,
1177
- });
752
+ b.m("POST").h(headers).b(body);
753
+ return b.build();
1178
754
  };
1179
755
  export const se_UnarchiveFindingsCommand = async (input, context) => {
1180
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
756
+ const b = rb(input, context);
1181
757
  const headers = {
1182
758
  "content-type": "application/json",
1183
759
  };
1184
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/detector/{DetectorId}/findings/unarchive";
1185
- resolvedPath = __resolvedPath(resolvedPath, input, "DetectorId", () => input.DetectorId, "{DetectorId}", false);
760
+ b.bp("/detector/{DetectorId}/findings/unarchive");
761
+ b.p("DetectorId", () => input.DetectorId, "{DetectorId}", false);
1186
762
  let body;
1187
763
  body = JSON.stringify(take(input, {
1188
764
  findingIds: [, (_) => _json(_), `FindingIds`],
1189
765
  }));
1190
- return new __HttpRequest({
1191
- protocol,
1192
- hostname,
1193
- port,
1194
- method: "POST",
1195
- headers,
1196
- path: resolvedPath,
1197
- body,
1198
- });
766
+ b.m("POST").h(headers).b(body);
767
+ return b.build();
1199
768
  };
1200
769
  export const se_UntagResourceCommand = async (input, context) => {
1201
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
770
+ const b = rb(input, context);
1202
771
  const headers = {};
1203
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{ResourceArn}";
1204
- resolvedPath = __resolvedPath(resolvedPath, input, "ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
772
+ b.bp("/tags/{ResourceArn}");
773
+ b.p("ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
1205
774
  const query = map({
1206
- tagKeys: [
775
+ [_tK]: [
1207
776
  __expectNonNull(input.TagKeys, `TagKeys`) != null,
1208
- () => (input.TagKeys || []).map((_entry) => _entry),
777
+ () => (input[_TK] || []).map((_entry) => _entry),
1209
778
  ],
1210
779
  });
1211
780
  let body;
1212
- return new __HttpRequest({
1213
- protocol,
1214
- hostname,
1215
- port,
1216
- method: "DELETE",
1217
- headers,
1218
- path: resolvedPath,
1219
- query,
1220
- body,
1221
- });
781
+ b.m("DELETE").h(headers).q(query).b(body);
782
+ return b.build();
1222
783
  };
1223
784
  export const se_UpdateDetectorCommand = async (input, context) => {
1224
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
785
+ const b = rb(input, context);
1225
786
  const headers = {
1226
787
  "content-type": "application/json",
1227
788
  };
1228
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/detector/{DetectorId}";
1229
- resolvedPath = __resolvedPath(resolvedPath, input, "DetectorId", () => input.DetectorId, "{DetectorId}", false);
789
+ b.bp("/detector/{DetectorId}");
790
+ b.p("DetectorId", () => input.DetectorId, "{DetectorId}", false);
1230
791
  let body;
1231
792
  body = JSON.stringify(take(input, {
1232
793
  dataSources: [, (_) => se_DataSourceConfigurations(_, context), `DataSources`],
@@ -1234,25 +795,17 @@ export const se_UpdateDetectorCommand = async (input, context) => {
1234
795
  features: [, (_) => se_DetectorFeatureConfigurations(_, context), `Features`],
1235
796
  findingPublishingFrequency: [, , `FindingPublishingFrequency`],
1236
797
  }));
1237
- return new __HttpRequest({
1238
- protocol,
1239
- hostname,
1240
- port,
1241
- method: "POST",
1242
- headers,
1243
- path: resolvedPath,
1244
- body,
1245
- });
798
+ b.m("POST").h(headers).b(body);
799
+ return b.build();
1246
800
  };
1247
801
  export const se_UpdateFilterCommand = async (input, context) => {
1248
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
802
+ const b = rb(input, context);
1249
803
  const headers = {
1250
804
  "content-type": "application/json",
1251
805
  };
1252
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1253
- "/detector/{DetectorId}/filter/{FilterName}";
1254
- resolvedPath = __resolvedPath(resolvedPath, input, "DetectorId", () => input.DetectorId, "{DetectorId}", false);
1255
- resolvedPath = __resolvedPath(resolvedPath, input, "FilterName", () => input.FilterName, "{FilterName}", false);
806
+ b.bp("/detector/{DetectorId}/filter/{FilterName}");
807
+ b.p("DetectorId", () => input.DetectorId, "{DetectorId}", false);
808
+ b.p("FilterName", () => input.FilterName, "{FilterName}", false);
1256
809
  let body;
1257
810
  body = JSON.stringify(take(input, {
1258
811
  action: [, , `Action`],
@@ -1260,117 +813,80 @@ export const se_UpdateFilterCommand = async (input, context) => {
1260
813
  findingCriteria: [, (_) => se_FindingCriteria(_, context), `FindingCriteria`],
1261
814
  rank: [, , `Rank`],
1262
815
  }));
1263
- return new __HttpRequest({
1264
- protocol,
1265
- hostname,
1266
- port,
1267
- method: "POST",
1268
- headers,
1269
- path: resolvedPath,
1270
- body,
1271
- });
816
+ b.m("POST").h(headers).b(body);
817
+ return b.build();
1272
818
  };
1273
819
  export const se_UpdateFindingsFeedbackCommand = async (input, context) => {
1274
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
820
+ const b = rb(input, context);
1275
821
  const headers = {
1276
822
  "content-type": "application/json",
1277
823
  };
1278
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/detector/{DetectorId}/findings/feedback";
1279
- resolvedPath = __resolvedPath(resolvedPath, input, "DetectorId", () => input.DetectorId, "{DetectorId}", false);
824
+ b.bp("/detector/{DetectorId}/findings/feedback");
825
+ b.p("DetectorId", () => input.DetectorId, "{DetectorId}", false);
1280
826
  let body;
1281
827
  body = JSON.stringify(take(input, {
1282
828
  comments: [, , `Comments`],
1283
829
  feedback: [, , `Feedback`],
1284
830
  findingIds: [, (_) => _json(_), `FindingIds`],
1285
831
  }));
1286
- return new __HttpRequest({
1287
- protocol,
1288
- hostname,
1289
- port,
1290
- method: "POST",
1291
- headers,
1292
- path: resolvedPath,
1293
- body,
1294
- });
832
+ b.m("POST").h(headers).b(body);
833
+ return b.build();
1295
834
  };
1296
835
  export const se_UpdateIPSetCommand = async (input, context) => {
1297
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
836
+ const b = rb(input, context);
1298
837
  const headers = {
1299
838
  "content-type": "application/json",
1300
839
  };
1301
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/detector/{DetectorId}/ipset/{IpSetId}";
1302
- resolvedPath = __resolvedPath(resolvedPath, input, "DetectorId", () => input.DetectorId, "{DetectorId}", false);
1303
- resolvedPath = __resolvedPath(resolvedPath, input, "IpSetId", () => input.IpSetId, "{IpSetId}", false);
840
+ b.bp("/detector/{DetectorId}/ipset/{IpSetId}");
841
+ b.p("DetectorId", () => input.DetectorId, "{DetectorId}", false);
842
+ b.p("IpSetId", () => input.IpSetId, "{IpSetId}", false);
1304
843
  let body;
1305
844
  body = JSON.stringify(take(input, {
1306
845
  activate: [, , `Activate`],
1307
846
  location: [, , `Location`],
1308
847
  name: [, , `Name`],
1309
848
  }));
1310
- return new __HttpRequest({
1311
- protocol,
1312
- hostname,
1313
- port,
1314
- method: "POST",
1315
- headers,
1316
- path: resolvedPath,
1317
- body,
1318
- });
849
+ b.m("POST").h(headers).b(body);
850
+ return b.build();
1319
851
  };
1320
852
  export const se_UpdateMalwareScanSettingsCommand = async (input, context) => {
1321
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
853
+ const b = rb(input, context);
1322
854
  const headers = {
1323
855
  "content-type": "application/json",
1324
856
  };
1325
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1326
- "/detector/{DetectorId}/malware-scan-settings";
1327
- resolvedPath = __resolvedPath(resolvedPath, input, "DetectorId", () => input.DetectorId, "{DetectorId}", false);
857
+ b.bp("/detector/{DetectorId}/malware-scan-settings");
858
+ b.p("DetectorId", () => input.DetectorId, "{DetectorId}", false);
1328
859
  let body;
1329
860
  body = JSON.stringify(take(input, {
1330
861
  ebsSnapshotPreservation: [, , `EbsSnapshotPreservation`],
1331
862
  scanResourceCriteria: [, (_) => se_ScanResourceCriteria(_, context), `ScanResourceCriteria`],
1332
863
  }));
1333
- return new __HttpRequest({
1334
- protocol,
1335
- hostname,
1336
- port,
1337
- method: "POST",
1338
- headers,
1339
- path: resolvedPath,
1340
- body,
1341
- });
864
+ b.m("POST").h(headers).b(body);
865
+ return b.build();
1342
866
  };
1343
867
  export const se_UpdateMemberDetectorsCommand = async (input, context) => {
1344
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
868
+ const b = rb(input, context);
1345
869
  const headers = {
1346
870
  "content-type": "application/json",
1347
871
  };
1348
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1349
- "/detector/{DetectorId}/member/detector/update";
1350
- resolvedPath = __resolvedPath(resolvedPath, input, "DetectorId", () => input.DetectorId, "{DetectorId}", false);
872
+ b.bp("/detector/{DetectorId}/member/detector/update");
873
+ b.p("DetectorId", () => input.DetectorId, "{DetectorId}", false);
1351
874
  let body;
1352
875
  body = JSON.stringify(take(input, {
1353
876
  accountIds: [, (_) => _json(_), `AccountIds`],
1354
877
  dataSources: [, (_) => se_DataSourceConfigurations(_, context), `DataSources`],
1355
878
  features: [, (_) => se_MemberFeaturesConfigurations(_, context), `Features`],
1356
879
  }));
1357
- return new __HttpRequest({
1358
- protocol,
1359
- hostname,
1360
- port,
1361
- method: "POST",
1362
- headers,
1363
- path: resolvedPath,
1364
- body,
1365
- });
880
+ b.m("POST").h(headers).b(body);
881
+ return b.build();
1366
882
  };
1367
883
  export const se_UpdateOrganizationConfigurationCommand = async (input, context) => {
1368
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
884
+ const b = rb(input, context);
1369
885
  const headers = {
1370
886
  "content-type": "application/json",
1371
887
  };
1372
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/detector/{DetectorId}/admin";
1373
- resolvedPath = __resolvedPath(resolvedPath, input, "DetectorId", () => input.DetectorId, "{DetectorId}", false);
888
+ b.bp("/detector/{DetectorId}/admin");
889
+ b.p("DetectorId", () => input.DetectorId, "{DetectorId}", false);
1374
890
  let body;
1375
891
  body = JSON.stringify(take(input, {
1376
892
  autoEnable: [, , `AutoEnable`],
@@ -1378,63 +894,40 @@ export const se_UpdateOrganizationConfigurationCommand = async (input, context)
1378
894
  dataSources: [, (_) => se_OrganizationDataSourceConfigurations(_, context), `DataSources`],
1379
895
  features: [, (_) => se_OrganizationFeaturesConfigurations(_, context), `Features`],
1380
896
  }));
1381
- return new __HttpRequest({
1382
- protocol,
1383
- hostname,
1384
- port,
1385
- method: "POST",
1386
- headers,
1387
- path: resolvedPath,
1388
- body,
1389
- });
897
+ b.m("POST").h(headers).b(body);
898
+ return b.build();
1390
899
  };
1391
900
  export const se_UpdatePublishingDestinationCommand = async (input, context) => {
1392
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
901
+ const b = rb(input, context);
1393
902
  const headers = {
1394
903
  "content-type": "application/json",
1395
904
  };
1396
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1397
- "/detector/{DetectorId}/publishingDestination/{DestinationId}";
1398
- resolvedPath = __resolvedPath(resolvedPath, input, "DetectorId", () => input.DetectorId, "{DetectorId}", false);
1399
- resolvedPath = __resolvedPath(resolvedPath, input, "DestinationId", () => input.DestinationId, "{DestinationId}", false);
905
+ b.bp("/detector/{DetectorId}/publishingDestination/{DestinationId}");
906
+ b.p("DetectorId", () => input.DetectorId, "{DetectorId}", false);
907
+ b.p("DestinationId", () => input.DestinationId, "{DestinationId}", false);
1400
908
  let body;
1401
909
  body = JSON.stringify(take(input, {
1402
910
  destinationProperties: [, (_) => se_DestinationProperties(_, context), `DestinationProperties`],
1403
911
  }));
1404
- return new __HttpRequest({
1405
- protocol,
1406
- hostname,
1407
- port,
1408
- method: "POST",
1409
- headers,
1410
- path: resolvedPath,
1411
- body,
1412
- });
912
+ b.m("POST").h(headers).b(body);
913
+ return b.build();
1413
914
  };
1414
915
  export const se_UpdateThreatIntelSetCommand = async (input, context) => {
1415
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
916
+ const b = rb(input, context);
1416
917
  const headers = {
1417
918
  "content-type": "application/json",
1418
919
  };
1419
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1420
- "/detector/{DetectorId}/threatintelset/{ThreatIntelSetId}";
1421
- resolvedPath = __resolvedPath(resolvedPath, input, "DetectorId", () => input.DetectorId, "{DetectorId}", false);
1422
- resolvedPath = __resolvedPath(resolvedPath, input, "ThreatIntelSetId", () => input.ThreatIntelSetId, "{ThreatIntelSetId}", false);
920
+ b.bp("/detector/{DetectorId}/threatintelset/{ThreatIntelSetId}");
921
+ b.p("DetectorId", () => input.DetectorId, "{DetectorId}", false);
922
+ b.p("ThreatIntelSetId", () => input.ThreatIntelSetId, "{ThreatIntelSetId}", false);
1423
923
  let body;
1424
924
  body = JSON.stringify(take(input, {
1425
925
  activate: [, , `Activate`],
1426
926
  location: [, , `Location`],
1427
927
  name: [, , `Name`],
1428
928
  }));
1429
- return new __HttpRequest({
1430
- protocol,
1431
- hostname,
1432
- port,
1433
- method: "POST",
1434
- headers,
1435
- path: resolvedPath,
1436
- body,
1437
- });
929
+ b.m("POST").h(headers).b(body);
930
+ return b.build();
1438
931
  };
1439
932
  export const de_AcceptAdministratorInvitationCommand = async (output, context) => {
1440
933
  if (output.statusCode !== 200 && output.statusCode >= 300) {
@@ -5760,6 +5253,14 @@ const isSerializableHeaderValue = (value) => value !== undefined &&
5760
5253
  value !== "" &&
5761
5254
  (!Object.getOwnPropertyNames(value).includes("length") || value.length != 0) &&
5762
5255
  (!Object.getOwnPropertyNames(value).includes("size") || value.size != 0);
5256
+ const _MR = "MaxResults";
5257
+ const _NT = "NextToken";
5258
+ const _OA = "OnlyAssociated";
5259
+ const _TK = "TagKeys";
5260
+ const _mR = "maxResults";
5261
+ const _nT = "nextToken";
5262
+ const _oA = "onlyAssociated";
5263
+ const _tK = "tagKeys";
5763
5264
  const parseBody = (streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
5764
5265
  if (encoded.length) {
5765
5266
  return JSON.parse(encoded);