@aws-sdk/client-sesv2 3.476.0 → 3.477.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (3) hide show
  1. package/dist-cjs/protocols/Aws_restJson1.js +483 -1176
  2. package/dist-es/protocols/Aws_restJson1.js +484 -1177
  3. package/package.json +5 -4
package/dist-es/protocols/Aws_restJson1.js CHANGED
@@ -1,49 +1,35 @@
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 { AccountSuspendedException, AlreadyExistsException, BadRequestException, ConcurrentModificationException, ConflictException, InternalServiceErrorException, InvalidNextTokenException, LimitExceededException, MailFromDomainNotVerifiedException, MessageRejected, NotFoundException, SendingPausedException, TooManyRequestsException, } from "../models/models_0";
4
4
  import { SESv2ServiceException as __BaseException } from "../models/SESv2ServiceException";
5
5
  export const se_BatchGetMetricDataCommand = async (input, context) => {
6
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
6
+ const b = rb(input, context);
7
7
  const headers = {
8
8
  "content-type": "application/json",
9
9
  };
10
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v2/email/metrics/batch";
10
+ b.bp("/v2/email/metrics/batch");
11
11
  let body;
12
12
  body = JSON.stringify(take(input, {
13
13
  Queries: (_) => se_BatchGetMetricDataQueries(_, context),
14
14
  }));
15
- return new __HttpRequest({
16
- protocol,
17
- hostname,
18
- port,
19
- method: "POST",
20
- headers,
21
- path: resolvedPath,
22
- body,
23
- });
15
+ b.m("POST").h(headers).b(body);
16
+ return b.build();
24
17
  };
25
18
  export const se_CancelExportJobCommand = async (input, context) => {
26
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
19
+ const b = rb(input, context);
27
20
  const headers = {};
28
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v2/email/export-jobs/{JobId}/cancel";
29
- resolvedPath = __resolvedPath(resolvedPath, input, "JobId", () => input.JobId, "{JobId}", false);
21
+ b.bp("/v2/email/export-jobs/{JobId}/cancel");
22
+ b.p("JobId", () => input.JobId, "{JobId}", false);
30
23
  let body;
31
- return new __HttpRequest({
32
- protocol,
33
- hostname,
34
- port,
35
- method: "PUT",
36
- headers,
37
- path: resolvedPath,
38
- body,
39
- });
24
+ b.m("PUT").h(headers).b(body);
25
+ return b.build();
40
26
  };
41
27
  export const se_CreateConfigurationSetCommand = async (input, context) => {
42
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
28
+ const b = rb(input, context);
43
29
  const headers = {
44
30
  "content-type": "application/json",
45
31
  };
46
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v2/email/configuration-sets";
32
+ b.bp("/v2/email/configuration-sets");
47
33
  let body;
48
34
  body = JSON.stringify(take(input, {
49
35
  ConfigurationSetName: [],
@@ -55,47 +41,31 @@ export const se_CreateConfigurationSetCommand = async (input, context) => {
55
41
  TrackingOptions: (_) => _json(_),
56
42
  VdmOptions: (_) => _json(_),
57
43
  }));
58
- return new __HttpRequest({
59
- protocol,
60
- hostname,
61
- port,
62
- method: "POST",
63
- headers,
64
- path: resolvedPath,
65
- body,
66
- });
44
+ b.m("POST").h(headers).b(body);
45
+ return b.build();
67
46
  };
68
47
  export const se_CreateConfigurationSetEventDestinationCommand = async (input, context) => {
69
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
48
+ const b = rb(input, context);
70
49
  const headers = {
71
50
  "content-type": "application/json",
72
51
  };
73
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
74
- "/v2/email/configuration-sets/{ConfigurationSetName}/event-destinations";
75
- resolvedPath = __resolvedPath(resolvedPath, input, "ConfigurationSetName", () => input.ConfigurationSetName, "{ConfigurationSetName}", false);
52
+ b.bp("/v2/email/configuration-sets/{ConfigurationSetName}/event-destinations");
53
+ b.p("ConfigurationSetName", () => input.ConfigurationSetName, "{ConfigurationSetName}", false);
76
54
  let body;
77
55
  body = JSON.stringify(take(input, {
78
56
  EventDestination: (_) => _json(_),
79
57
  EventDestinationName: [],
80
58
  }));
81
- return new __HttpRequest({
82
- protocol,
83
- hostname,
84
- port,
85
- method: "POST",
86
- headers,
87
- path: resolvedPath,
88
- body,
89
- });
59
+ b.m("POST").h(headers).b(body);
60
+ return b.build();
90
61
  };
91
62
  export const se_CreateContactCommand = async (input, context) => {
92
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
63
+ const b = rb(input, context);
93
64
  const headers = {
94
65
  "content-type": "application/json",
95
66
  };
96
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
97
- "/v2/email/contact-lists/{ContactListName}/contacts";
98
- resolvedPath = __resolvedPath(resolvedPath, input, "ContactListName", () => input.ContactListName, "{ContactListName}", false);
67
+ b.bp("/v2/email/contact-lists/{ContactListName}/contacts");
68
+ b.p("ContactListName", () => input.ContactListName, "{ContactListName}", false);
99
69
  let body;
100
70
  body = JSON.stringify(take(input, {
101
71
  AttributesData: [],
@@ -103,22 +73,15 @@ export const se_CreateContactCommand = async (input, context) => {
103
73
  TopicPreferences: (_) => _json(_),
104
74
  UnsubscribeAll: [],
105
75
  }));
106
- return new __HttpRequest({
107
- protocol,
108
- hostname,
109
- port,
110
- method: "POST",
111
- headers,
112
- path: resolvedPath,
113
- body,
114
- });
76
+ b.m("POST").h(headers).b(body);
77
+ return b.build();
115
78
  };
116
79
  export const se_CreateContactListCommand = async (input, context) => {
117
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
80
+ const b = rb(input, context);
118
81
  const headers = {
119
82
  "content-type": "application/json",
120
83
  };
121
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v2/email/contact-lists";
84
+ b.bp("/v2/email/contact-lists");
122
85
  let body;
123
86
  body = JSON.stringify(take(input, {
124
87
  ContactListName: [],
@@ -126,23 +89,15 @@ export const se_CreateContactListCommand = async (input, context) => {
126
89
  Tags: (_) => _json(_),
127
90
  Topics: (_) => _json(_),
128
91
  }));
129
- return new __HttpRequest({
130
- protocol,
131
- hostname,
132
- port,
133
- method: "POST",
134
- headers,
135
- path: resolvedPath,
136
- body,
137
- });
92
+ b.m("POST").h(headers).b(body);
93
+ return b.build();
138
94
  };
139
95
  export const se_CreateCustomVerificationEmailTemplateCommand = async (input, context) => {
140
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
96
+ const b = rb(input, context);
141
97
  const headers = {
142
98
  "content-type": "application/json",
143
99
  };
144
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
145
- "/v2/email/custom-verification-email-templates";
100
+ b.bp("/v2/email/custom-verification-email-templates");
146
101
  let body;
147
102
  body = JSON.stringify(take(input, {
148
103
  FailureRedirectionURL: [],
@@ -152,44 +107,30 @@ export const se_CreateCustomVerificationEmailTemplateCommand = async (input, con
152
107
  TemplateName: [],
153
108
  TemplateSubject: [],
154
109
  }));
155
- return new __HttpRequest({
156
- protocol,
157
- hostname,
158
- port,
159
- method: "POST",
160
- headers,
161
- path: resolvedPath,
162
- body,
163
- });
110
+ b.m("POST").h(headers).b(body);
111
+ return b.build();
164
112
  };
165
113
  export const se_CreateDedicatedIpPoolCommand = async (input, context) => {
166
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
114
+ const b = rb(input, context);
167
115
  const headers = {
168
116
  "content-type": "application/json",
169
117
  };
170
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v2/email/dedicated-ip-pools";
118
+ b.bp("/v2/email/dedicated-ip-pools");
171
119
  let body;
172
120
  body = JSON.stringify(take(input, {
173
121
  PoolName: [],
174
122
  ScalingMode: [],
175
123
  Tags: (_) => _json(_),
176
124
  }));
177
- return new __HttpRequest({
178
- protocol,
179
- hostname,
180
- port,
181
- method: "POST",
182
- headers,
183
- path: resolvedPath,
184
- body,
185
- });
125
+ b.m("POST").h(headers).b(body);
126
+ return b.build();
186
127
  };
187
128
  export const se_CreateDeliverabilityTestReportCommand = async (input, context) => {
188
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
129
+ const b = rb(input, context);
189
130
  const headers = {
190
131
  "content-type": "application/json",
191
132
  };
192
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v2/email/deliverability-dashboard/test";
133
+ b.bp("/v2/email/deliverability-dashboard/test");
193
134
  let body;
194
135
  body = JSON.stringify(take(input, {
195
136
  Content: (_) => se_EmailContent(_, context),
@@ -197,22 +138,15 @@ export const se_CreateDeliverabilityTestReportCommand = async (input, context) =
197
138
  ReportName: [],
198
139
  Tags: (_) => _json(_),
199
140
  }));
200
- return new __HttpRequest({
201
- protocol,
202
- hostname,
203
- port,
204
- method: "POST",
205
- headers,
206
- path: resolvedPath,
207
- body,
208
- });
141
+ b.m("POST").h(headers).b(body);
142
+ return b.build();
209
143
  };
210
144
  export const se_CreateEmailIdentityCommand = async (input, context) => {
211
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
145
+ const b = rb(input, context);
212
146
  const headers = {
213
147
  "content-type": "application/json",
214
148
  };
215
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v2/email/identities";
149
+ b.bp("/v2/email/identities");
216
150
  let body;
217
151
  body = JSON.stringify(take(input, {
218
152
  ConfigurationSetName: [],
@@ -220,849 +154,501 @@ export const se_CreateEmailIdentityCommand = async (input, context) => {
220
154
  EmailIdentity: [],
221
155
  Tags: (_) => _json(_),
222
156
  }));
223
- return new __HttpRequest({
224
- protocol,
225
- hostname,
226
- port,
227
- method: "POST",
228
- headers,
229
- path: resolvedPath,
230
- body,
231
- });
157
+ b.m("POST").h(headers).b(body);
158
+ return b.build();
232
159
  };
233
160
  export const se_CreateEmailIdentityPolicyCommand = async (input, context) => {
234
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
161
+ const b = rb(input, context);
235
162
  const headers = {
236
163
  "content-type": "application/json",
237
164
  };
238
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
239
- "/v2/email/identities/{EmailIdentity}/policies/{PolicyName}";
240
- resolvedPath = __resolvedPath(resolvedPath, input, "EmailIdentity", () => input.EmailIdentity, "{EmailIdentity}", false);
241
- resolvedPath = __resolvedPath(resolvedPath, input, "PolicyName", () => input.PolicyName, "{PolicyName}", false);
165
+ b.bp("/v2/email/identities/{EmailIdentity}/policies/{PolicyName}");
166
+ b.p("EmailIdentity", () => input.EmailIdentity, "{EmailIdentity}", false);
167
+ b.p("PolicyName", () => input.PolicyName, "{PolicyName}", false);
242
168
  let body;
243
169
  body = JSON.stringify(take(input, {
244
170
  Policy: [],
245
171
  }));
246
- return new __HttpRequest({
247
- protocol,
248
- hostname,
249
- port,
250
- method: "POST",
251
- headers,
252
- path: resolvedPath,
253
- body,
254
- });
172
+ b.m("POST").h(headers).b(body);
173
+ return b.build();
255
174
  };
256
175
  export const se_CreateEmailTemplateCommand = async (input, context) => {
257
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
176
+ const b = rb(input, context);
258
177
  const headers = {
259
178
  "content-type": "application/json",
260
179
  };
261
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v2/email/templates";
180
+ b.bp("/v2/email/templates");
262
181
  let body;
263
182
  body = JSON.stringify(take(input, {
264
183
  TemplateContent: (_) => _json(_),
265
184
  TemplateName: [],
266
185
  }));
267
- return new __HttpRequest({
268
- protocol,
269
- hostname,
270
- port,
271
- method: "POST",
272
- headers,
273
- path: resolvedPath,
274
- body,
275
- });
186
+ b.m("POST").h(headers).b(body);
187
+ return b.build();
276
188
  };
277
189
  export const se_CreateExportJobCommand = async (input, context) => {
278
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
190
+ const b = rb(input, context);
279
191
  const headers = {
280
192
  "content-type": "application/json",
281
193
  };
282
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v2/email/export-jobs";
194
+ b.bp("/v2/email/export-jobs");
283
195
  let body;
284
196
  body = JSON.stringify(take(input, {
285
197
  ExportDataSource: (_) => se_ExportDataSource(_, context),
286
198
  ExportDestination: (_) => _json(_),
287
199
  }));
288
- return new __HttpRequest({
289
- protocol,
290
- hostname,
291
- port,
292
- method: "POST",
293
- headers,
294
- path: resolvedPath,
295
- body,
296
- });
200
+ b.m("POST").h(headers).b(body);
201
+ return b.build();
297
202
  };
298
203
  export const se_CreateImportJobCommand = async (input, context) => {
299
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
204
+ const b = rb(input, context);
300
205
  const headers = {
301
206
  "content-type": "application/json",
302
207
  };
303
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v2/email/import-jobs";
208
+ b.bp("/v2/email/import-jobs");
304
209
  let body;
305
210
  body = JSON.stringify(take(input, {
306
211
  ImportDataSource: (_) => _json(_),
307
212
  ImportDestination: (_) => _json(_),
308
213
  }));
309
- return new __HttpRequest({
310
- protocol,
311
- hostname,
312
- port,
313
- method: "POST",
314
- headers,
315
- path: resolvedPath,
316
- body,
317
- });
214
+ b.m("POST").h(headers).b(body);
215
+ return b.build();
318
216
  };
319
217
  export const se_DeleteConfigurationSetCommand = async (input, context) => {
320
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
218
+ const b = rb(input, context);
321
219
  const headers = {};
322
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
323
- "/v2/email/configuration-sets/{ConfigurationSetName}";
324
- resolvedPath = __resolvedPath(resolvedPath, input, "ConfigurationSetName", () => input.ConfigurationSetName, "{ConfigurationSetName}", false);
220
+ b.bp("/v2/email/configuration-sets/{ConfigurationSetName}");
221
+ b.p("ConfigurationSetName", () => input.ConfigurationSetName, "{ConfigurationSetName}", false);
325
222
  let body;
326
- return new __HttpRequest({
327
- protocol,
328
- hostname,
329
- port,
330
- method: "DELETE",
331
- headers,
332
- path: resolvedPath,
333
- body,
334
- });
223
+ b.m("DELETE").h(headers).b(body);
224
+ return b.build();
335
225
  };
336
226
  export const se_DeleteConfigurationSetEventDestinationCommand = async (input, context) => {
337
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
227
+ const b = rb(input, context);
338
228
  const headers = {};
339
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
340
- "/v2/email/configuration-sets/{ConfigurationSetName}/event-destinations/{EventDestinationName}";
341
- resolvedPath = __resolvedPath(resolvedPath, input, "ConfigurationSetName", () => input.ConfigurationSetName, "{ConfigurationSetName}", false);
342
- resolvedPath = __resolvedPath(resolvedPath, input, "EventDestinationName", () => input.EventDestinationName, "{EventDestinationName}", false);
229
+ b.bp("/v2/email/configuration-sets/{ConfigurationSetName}/event-destinations/{EventDestinationName}");
230
+ b.p("ConfigurationSetName", () => input.ConfigurationSetName, "{ConfigurationSetName}", false);
231
+ b.p("EventDestinationName", () => input.EventDestinationName, "{EventDestinationName}", false);
343
232
  let body;
344
- return new __HttpRequest({
345
- protocol,
346
- hostname,
347
- port,
348
- method: "DELETE",
349
- headers,
350
- path: resolvedPath,
351
- body,
352
- });
233
+ b.m("DELETE").h(headers).b(body);
234
+ return b.build();
353
235
  };
354
236
  export const se_DeleteContactCommand = async (input, context) => {
355
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
237
+ const b = rb(input, context);
356
238
  const headers = {};
357
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
358
- "/v2/email/contact-lists/{ContactListName}/contacts/{EmailAddress}";
359
- resolvedPath = __resolvedPath(resolvedPath, input, "ContactListName", () => input.ContactListName, "{ContactListName}", false);
360
- resolvedPath = __resolvedPath(resolvedPath, input, "EmailAddress", () => input.EmailAddress, "{EmailAddress}", false);
239
+ b.bp("/v2/email/contact-lists/{ContactListName}/contacts/{EmailAddress}");
240
+ b.p("ContactListName", () => input.ContactListName, "{ContactListName}", false);
241
+ b.p("EmailAddress", () => input.EmailAddress, "{EmailAddress}", false);
361
242
  let body;
362
- return new __HttpRequest({
363
- protocol,
364
- hostname,
365
- port,
366
- method: "DELETE",
367
- headers,
368
- path: resolvedPath,
369
- body,
370
- });
243
+ b.m("DELETE").h(headers).b(body);
244
+ return b.build();
371
245
  };
372
246
  export const se_DeleteContactListCommand = async (input, context) => {
373
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
247
+ const b = rb(input, context);
374
248
  const headers = {};
375
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v2/email/contact-lists/{ContactListName}";
376
- resolvedPath = __resolvedPath(resolvedPath, input, "ContactListName", () => input.ContactListName, "{ContactListName}", false);
249
+ b.bp("/v2/email/contact-lists/{ContactListName}");
250
+ b.p("ContactListName", () => input.ContactListName, "{ContactListName}", false);
377
251
  let body;
378
- return new __HttpRequest({
379
- protocol,
380
- hostname,
381
- port,
382
- method: "DELETE",
383
- headers,
384
- path: resolvedPath,
385
- body,
386
- });
252
+ b.m("DELETE").h(headers).b(body);
253
+ return b.build();
387
254
  };
388
255
  export const se_DeleteCustomVerificationEmailTemplateCommand = async (input, context) => {
389
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
256
+ const b = rb(input, context);
390
257
  const headers = {};
391
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
392
- "/v2/email/custom-verification-email-templates/{TemplateName}";
393
- resolvedPath = __resolvedPath(resolvedPath, input, "TemplateName", () => input.TemplateName, "{TemplateName}", false);
258
+ b.bp("/v2/email/custom-verification-email-templates/{TemplateName}");
259
+ b.p("TemplateName", () => input.TemplateName, "{TemplateName}", false);
394
260
  let body;
395
- return new __HttpRequest({
396
- protocol,
397
- hostname,
398
- port,
399
- method: "DELETE",
400
- headers,
401
- path: resolvedPath,
402
- body,
403
- });
261
+ b.m("DELETE").h(headers).b(body);
262
+ return b.build();
404
263
  };
405
264
  export const se_DeleteDedicatedIpPoolCommand = async (input, context) => {
406
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
265
+ const b = rb(input, context);
407
266
  const headers = {};
408
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v2/email/dedicated-ip-pools/{PoolName}";
409
- resolvedPath = __resolvedPath(resolvedPath, input, "PoolName", () => input.PoolName, "{PoolName}", false);
267
+ b.bp("/v2/email/dedicated-ip-pools/{PoolName}");
268
+ b.p("PoolName", () => input.PoolName, "{PoolName}", false);
410
269
  let body;
411
- return new __HttpRequest({
412
- protocol,
413
- hostname,
414
- port,
415
- method: "DELETE",
416
- headers,
417
- path: resolvedPath,
418
- body,
419
- });
270
+ b.m("DELETE").h(headers).b(body);
271
+ return b.build();
420
272
  };
421
273
  export const se_DeleteEmailIdentityCommand = async (input, context) => {
422
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
274
+ const b = rb(input, context);
423
275
  const headers = {};
424
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v2/email/identities/{EmailIdentity}";
425
- resolvedPath = __resolvedPath(resolvedPath, input, "EmailIdentity", () => input.EmailIdentity, "{EmailIdentity}", false);
276
+ b.bp("/v2/email/identities/{EmailIdentity}");
277
+ b.p("EmailIdentity", () => input.EmailIdentity, "{EmailIdentity}", false);
426
278
  let body;
427
- return new __HttpRequest({
428
- protocol,
429
- hostname,
430
- port,
431
- method: "DELETE",
432
- headers,
433
- path: resolvedPath,
434
- body,
435
- });
279
+ b.m("DELETE").h(headers).b(body);
280
+ return b.build();
436
281
  };
437
282
  export const se_DeleteEmailIdentityPolicyCommand = async (input, context) => {
438
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
283
+ const b = rb(input, context);
439
284
  const headers = {};
440
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
441
- "/v2/email/identities/{EmailIdentity}/policies/{PolicyName}";
442
- resolvedPath = __resolvedPath(resolvedPath, input, "EmailIdentity", () => input.EmailIdentity, "{EmailIdentity}", false);
443
- resolvedPath = __resolvedPath(resolvedPath, input, "PolicyName", () => input.PolicyName, "{PolicyName}", false);
285
+ b.bp("/v2/email/identities/{EmailIdentity}/policies/{PolicyName}");
286
+ b.p("EmailIdentity", () => input.EmailIdentity, "{EmailIdentity}", false);
287
+ b.p("PolicyName", () => input.PolicyName, "{PolicyName}", false);
444
288
  let body;
445
- return new __HttpRequest({
446
- protocol,
447
- hostname,
448
- port,
449
- method: "DELETE",
450
- headers,
451
- path: resolvedPath,
452
- body,
453
- });
289
+ b.m("DELETE").h(headers).b(body);
290
+ return b.build();
454
291
  };
455
292
  export const se_DeleteEmailTemplateCommand = async (input, context) => {
456
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
293
+ const b = rb(input, context);
457
294
  const headers = {};
458
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v2/email/templates/{TemplateName}";
459
- resolvedPath = __resolvedPath(resolvedPath, input, "TemplateName", () => input.TemplateName, "{TemplateName}", false);
295
+ b.bp("/v2/email/templates/{TemplateName}");
296
+ b.p("TemplateName", () => input.TemplateName, "{TemplateName}", false);
460
297
  let body;
461
- return new __HttpRequest({
462
- protocol,
463
- hostname,
464
- port,
465
- method: "DELETE",
466
- headers,
467
- path: resolvedPath,
468
- body,
469
- });
298
+ b.m("DELETE").h(headers).b(body);
299
+ return b.build();
470
300
  };
471
301
  export const se_DeleteSuppressedDestinationCommand = async (input, context) => {
472
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
302
+ const b = rb(input, context);
473
303
  const headers = {};
474
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
475
- "/v2/email/suppression/addresses/{EmailAddress}";
476
- resolvedPath = __resolvedPath(resolvedPath, input, "EmailAddress", () => input.EmailAddress, "{EmailAddress}", false);
304
+ b.bp("/v2/email/suppression/addresses/{EmailAddress}");
305
+ b.p("EmailAddress", () => input.EmailAddress, "{EmailAddress}", false);
477
306
  let body;
478
- return new __HttpRequest({
479
- protocol,
480
- hostname,
481
- port,
482
- method: "DELETE",
483
- headers,
484
- path: resolvedPath,
485
- body,
486
- });
307
+ b.m("DELETE").h(headers).b(body);
308
+ return b.build();
487
309
  };
488
310
  export const se_GetAccountCommand = async (input, context) => {
489
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
311
+ const b = rb(input, context);
490
312
  const headers = {
491
313
  "content-type": "application/json",
492
314
  };
493
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v2/email/account";
315
+ b.bp("/v2/email/account");
494
316
  let body;
495
317
  body = "";
496
- return new __HttpRequest({
497
- protocol,
498
- hostname,
499
- port,
500
- method: "GET",
501
- headers,
502
- path: resolvedPath,
503
- body,
504
- });
318
+ b.m("GET").h(headers).b(body);
319
+ return b.build();
505
320
  };
506
321
  export const se_GetBlacklistReportsCommand = async (input, context) => {
507
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
322
+ const b = rb(input, context);
508
323
  const headers = {};
509
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
510
- "/v2/email/deliverability-dashboard/blacklist-report";
324
+ b.bp("/v2/email/deliverability-dashboard/blacklist-report");
511
325
  const query = map({
512
- BlacklistItemNames: [
326
+ [_BIN]: [
513
327
  __expectNonNull(input.BlacklistItemNames, `BlacklistItemNames`) != null,
514
- () => (input.BlacklistItemNames || []).map((_entry) => _entry),
328
+ () => (input[_BIN] || []).map((_entry) => _entry),
515
329
  ],
516
330
  });
517
331
  let body;
518
- return new __HttpRequest({
519
- protocol,
520
- hostname,
521
- port,
522
- method: "GET",
523
- headers,
524
- path: resolvedPath,
525
- query,
526
- body,
527
- });
332
+ b.m("GET").h(headers).q(query).b(body);
333
+ return b.build();
528
334
  };
529
335
  export const se_GetConfigurationSetCommand = async (input, context) => {
530
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
336
+ const b = rb(input, context);
531
337
  const headers = {};
532
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
533
- "/v2/email/configuration-sets/{ConfigurationSetName}";
534
- resolvedPath = __resolvedPath(resolvedPath, input, "ConfigurationSetName", () => input.ConfigurationSetName, "{ConfigurationSetName}", false);
338
+ b.bp("/v2/email/configuration-sets/{ConfigurationSetName}");
339
+ b.p("ConfigurationSetName", () => input.ConfigurationSetName, "{ConfigurationSetName}", false);
535
340
  let body;
536
- return new __HttpRequest({
537
- protocol,
538
- hostname,
539
- port,
540
- method: "GET",
541
- headers,
542
- path: resolvedPath,
543
- body,
544
- });
341
+ b.m("GET").h(headers).b(body);
342
+ return b.build();
545
343
  };
546
344
  export const se_GetConfigurationSetEventDestinationsCommand = async (input, context) => {
547
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
345
+ const b = rb(input, context);
548
346
  const headers = {};
549
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
550
- "/v2/email/configuration-sets/{ConfigurationSetName}/event-destinations";
551
- resolvedPath = __resolvedPath(resolvedPath, input, "ConfigurationSetName", () => input.ConfigurationSetName, "{ConfigurationSetName}", false);
347
+ b.bp("/v2/email/configuration-sets/{ConfigurationSetName}/event-destinations");
348
+ b.p("ConfigurationSetName", () => input.ConfigurationSetName, "{ConfigurationSetName}", false);
552
349
  let body;
553
- return new __HttpRequest({
554
- protocol,
555
- hostname,
556
- port,
557
- method: "GET",
558
- headers,
559
- path: resolvedPath,
560
- body,
561
- });
350
+ b.m("GET").h(headers).b(body);
351
+ return b.build();
562
352
  };
563
353
  export const se_GetContactCommand = async (input, context) => {
564
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
354
+ const b = rb(input, context);
565
355
  const headers = {};
566
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
567
- "/v2/email/contact-lists/{ContactListName}/contacts/{EmailAddress}";
568
- resolvedPath = __resolvedPath(resolvedPath, input, "ContactListName", () => input.ContactListName, "{ContactListName}", false);
569
- resolvedPath = __resolvedPath(resolvedPath, input, "EmailAddress", () => input.EmailAddress, "{EmailAddress}", false);
356
+ b.bp("/v2/email/contact-lists/{ContactListName}/contacts/{EmailAddress}");
357
+ b.p("ContactListName", () => input.ContactListName, "{ContactListName}", false);
358
+ b.p("EmailAddress", () => input.EmailAddress, "{EmailAddress}", false);
570
359
  let body;
571
- return new __HttpRequest({
572
- protocol,
573
- hostname,
574
- port,
575
- method: "GET",
576
- headers,
577
- path: resolvedPath,
578
- body,
579
- });
360
+ b.m("GET").h(headers).b(body);
361
+ return b.build();
580
362
  };
581
363
  export const se_GetContactListCommand = async (input, context) => {
582
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
364
+ const b = rb(input, context);
583
365
  const headers = {};
584
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v2/email/contact-lists/{ContactListName}";
585
- resolvedPath = __resolvedPath(resolvedPath, input, "ContactListName", () => input.ContactListName, "{ContactListName}", false);
366
+ b.bp("/v2/email/contact-lists/{ContactListName}");
367
+ b.p("ContactListName", () => input.ContactListName, "{ContactListName}", false);
586
368
  let body;
587
- return new __HttpRequest({
588
- protocol,
589
- hostname,
590
- port,
591
- method: "GET",
592
- headers,
593
- path: resolvedPath,
594
- body,
595
- });
369
+ b.m("GET").h(headers).b(body);
370
+ return b.build();
596
371
  };
597
372
  export const se_GetCustomVerificationEmailTemplateCommand = async (input, context) => {
598
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
373
+ const b = rb(input, context);
599
374
  const headers = {};
600
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
601
- "/v2/email/custom-verification-email-templates/{TemplateName}";
602
- resolvedPath = __resolvedPath(resolvedPath, input, "TemplateName", () => input.TemplateName, "{TemplateName}", false);
375
+ b.bp("/v2/email/custom-verification-email-templates/{TemplateName}");
376
+ b.p("TemplateName", () => input.TemplateName, "{TemplateName}", false);
603
377
  let body;
604
- return new __HttpRequest({
605
- protocol,
606
- hostname,
607
- port,
608
- method: "GET",
609
- headers,
610
- path: resolvedPath,
611
- body,
612
- });
378
+ b.m("GET").h(headers).b(body);
379
+ return b.build();
613
380
  };
614
381
  export const se_GetDedicatedIpCommand = async (input, context) => {
615
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
382
+ const b = rb(input, context);
616
383
  const headers = {};
617
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v2/email/dedicated-ips/{Ip}";
618
- resolvedPath = __resolvedPath(resolvedPath, input, "Ip", () => input.Ip, "{Ip}", false);
384
+ b.bp("/v2/email/dedicated-ips/{Ip}");
385
+ b.p("Ip", () => input.Ip, "{Ip}", false);
619
386
  let body;
620
- return new __HttpRequest({
621
- protocol,
622
- hostname,
623
- port,
624
- method: "GET",
625
- headers,
626
- path: resolvedPath,
627
- body,
628
- });
387
+ b.m("GET").h(headers).b(body);
388
+ return b.build();
629
389
  };
630
390
  export const se_GetDedicatedIpPoolCommand = async (input, context) => {
631
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
391
+ const b = rb(input, context);
632
392
  const headers = {};
633
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v2/email/dedicated-ip-pools/{PoolName}";
634
- resolvedPath = __resolvedPath(resolvedPath, input, "PoolName", () => input.PoolName, "{PoolName}", false);
393
+ b.bp("/v2/email/dedicated-ip-pools/{PoolName}");
394
+ b.p("PoolName", () => input.PoolName, "{PoolName}", false);
635
395
  let body;
636
- return new __HttpRequest({
637
- protocol,
638
- hostname,
639
- port,
640
- method: "GET",
641
- headers,
642
- path: resolvedPath,
643
- body,
644
- });
396
+ b.m("GET").h(headers).b(body);
397
+ return b.build();
645
398
  };
646
399
  export const se_GetDedicatedIpsCommand = async (input, context) => {
647
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
400
+ const b = rb(input, context);
648
401
  const headers = {};
649
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v2/email/dedicated-ips";
402
+ b.bp("/v2/email/dedicated-ips");
650
403
  const query = map({
651
- PoolName: [, input.PoolName],
652
- NextToken: [, input.NextToken],
653
- PageSize: [() => input.PageSize !== void 0, () => input.PageSize.toString()],
404
+ [_PN]: [, input[_PN]],
405
+ [_NT]: [, input[_NT]],
406
+ [_PS]: [() => input.PageSize !== void 0, () => input[_PS].toString()],
654
407
  });
655
408
  let body;
656
- return new __HttpRequest({
657
- protocol,
658
- hostname,
659
- port,
660
- method: "GET",
661
- headers,
662
- path: resolvedPath,
663
- query,
664
- body,
665
- });
409
+ b.m("GET").h(headers).q(query).b(body);
410
+ return b.build();
666
411
  };
667
412
  export const se_GetDeliverabilityDashboardOptionsCommand = async (input, context) => {
668
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
413
+ const b = rb(input, context);
669
414
  const headers = {
670
415
  "content-type": "application/json",
671
416
  };
672
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v2/email/deliverability-dashboard";
417
+ b.bp("/v2/email/deliverability-dashboard");
673
418
  let body;
674
419
  body = "";
675
- return new __HttpRequest({
676
- protocol,
677
- hostname,
678
- port,
679
- method: "GET",
680
- headers,
681
- path: resolvedPath,
682
- body,
683
- });
420
+ b.m("GET").h(headers).b(body);
421
+ return b.build();
684
422
  };
685
423
  export const se_GetDeliverabilityTestReportCommand = async (input, context) => {
686
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
424
+ const b = rb(input, context);
687
425
  const headers = {};
688
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
689
- "/v2/email/deliverability-dashboard/test-reports/{ReportId}";
690
- resolvedPath = __resolvedPath(resolvedPath, input, "ReportId", () => input.ReportId, "{ReportId}", false);
426
+ b.bp("/v2/email/deliverability-dashboard/test-reports/{ReportId}");
427
+ b.p("ReportId", () => input.ReportId, "{ReportId}", false);
691
428
  let body;
692
- return new __HttpRequest({
693
- protocol,
694
- hostname,
695
- port,
696
- method: "GET",
697
- headers,
698
- path: resolvedPath,
699
- body,
700
- });
429
+ b.m("GET").h(headers).b(body);
430
+ return b.build();
701
431
  };
702
432
  export const se_GetDomainDeliverabilityCampaignCommand = async (input, context) => {
703
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
433
+ const b = rb(input, context);
704
434
  const headers = {};
705
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
706
- "/v2/email/deliverability-dashboard/campaigns/{CampaignId}";
707
- resolvedPath = __resolvedPath(resolvedPath, input, "CampaignId", () => input.CampaignId, "{CampaignId}", false);
435
+ b.bp("/v2/email/deliverability-dashboard/campaigns/{CampaignId}");
436
+ b.p("CampaignId", () => input.CampaignId, "{CampaignId}", false);
708
437
  let body;
709
- return new __HttpRequest({
710
- protocol,
711
- hostname,
712
- port,
713
- method: "GET",
714
- headers,
715
- path: resolvedPath,
716
- body,
717
- });
438
+ b.m("GET").h(headers).b(body);
439
+ return b.build();
718
440
  };
719
441
  export const se_GetDomainStatisticsReportCommand = async (input, context) => {
720
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
442
+ const b = rb(input, context);
721
443
  const headers = {};
722
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
723
- "/v2/email/deliverability-dashboard/statistics-report/{Domain}";
724
- resolvedPath = __resolvedPath(resolvedPath, input, "Domain", () => input.Domain, "{Domain}", false);
444
+ b.bp("/v2/email/deliverability-dashboard/statistics-report/{Domain}");
445
+ b.p("Domain", () => input.Domain, "{Domain}", false);
725
446
  const query = map({
726
- StartDate: [
447
+ [_SD]: [
727
448
  __expectNonNull(input.StartDate, `StartDate`) != null,
728
- () => (input.StartDate.toISOString().split(".")[0] + "Z").toString(),
449
+ () => (input[_SD].toISOString().split(".")[0] + "Z").toString(),
729
450
  ],
730
- EndDate: [
451
+ [_ED]: [
731
452
  __expectNonNull(input.EndDate, `EndDate`) != null,
732
- () => (input.EndDate.toISOString().split(".")[0] + "Z").toString(),
453
+ () => (input[_ED].toISOString().split(".")[0] + "Z").toString(),
733
454
  ],
734
455
  });
735
456
  let body;
736
- return new __HttpRequest({
737
- protocol,
738
- hostname,
739
- port,
740
- method: "GET",
741
- headers,
742
- path: resolvedPath,
743
- query,
744
- body,
745
- });
457
+ b.m("GET").h(headers).q(query).b(body);
458
+ return b.build();
746
459
  };
747
460
  export const se_GetEmailIdentityCommand = async (input, context) => {
748
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
461
+ const b = rb(input, context);
749
462
  const headers = {};
750
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v2/email/identities/{EmailIdentity}";
751
- resolvedPath = __resolvedPath(resolvedPath, input, "EmailIdentity", () => input.EmailIdentity, "{EmailIdentity}", false);
463
+ b.bp("/v2/email/identities/{EmailIdentity}");
464
+ b.p("EmailIdentity", () => input.EmailIdentity, "{EmailIdentity}", false);
752
465
  let body;
753
- return new __HttpRequest({
754
- protocol,
755
- hostname,
756
- port,
757
- method: "GET",
758
- headers,
759
- path: resolvedPath,
760
- body,
761
- });
466
+ b.m("GET").h(headers).b(body);
467
+ return b.build();
762
468
  };
763
469
  export const se_GetEmailIdentityPoliciesCommand = async (input, context) => {
764
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
470
+ const b = rb(input, context);
765
471
  const headers = {};
766
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
767
- "/v2/email/identities/{EmailIdentity}/policies";
768
- resolvedPath = __resolvedPath(resolvedPath, input, "EmailIdentity", () => input.EmailIdentity, "{EmailIdentity}", false);
472
+ b.bp("/v2/email/identities/{EmailIdentity}/policies");
473
+ b.p("EmailIdentity", () => input.EmailIdentity, "{EmailIdentity}", false);
769
474
  let body;
770
- return new __HttpRequest({
771
- protocol,
772
- hostname,
773
- port,
774
- method: "GET",
775
- headers,
776
- path: resolvedPath,
777
- body,
778
- });
475
+ b.m("GET").h(headers).b(body);
476
+ return b.build();
779
477
  };
780
478
  export const se_GetEmailTemplateCommand = async (input, context) => {
781
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
479
+ const b = rb(input, context);
782
480
  const headers = {};
783
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v2/email/templates/{TemplateName}";
784
- resolvedPath = __resolvedPath(resolvedPath, input, "TemplateName", () => input.TemplateName, "{TemplateName}", false);
481
+ b.bp("/v2/email/templates/{TemplateName}");
482
+ b.p("TemplateName", () => input.TemplateName, "{TemplateName}", false);
785
483
  let body;
786
- return new __HttpRequest({
787
- protocol,
788
- hostname,
789
- port,
790
- method: "GET",
791
- headers,
792
- path: resolvedPath,
793
- body,
794
- });
484
+ b.m("GET").h(headers).b(body);
485
+ return b.build();
795
486
  };
796
487
  export const se_GetExportJobCommand = async (input, context) => {
797
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
488
+ const b = rb(input, context);
798
489
  const headers = {};
799
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v2/email/export-jobs/{JobId}";
800
- resolvedPath = __resolvedPath(resolvedPath, input, "JobId", () => input.JobId, "{JobId}", false);
490
+ b.bp("/v2/email/export-jobs/{JobId}");
491
+ b.p("JobId", () => input.JobId, "{JobId}", false);
801
492
  let body;
802
- return new __HttpRequest({
803
- protocol,
804
- hostname,
805
- port,
806
- method: "GET",
807
- headers,
808
- path: resolvedPath,
809
- body,
810
- });
493
+ b.m("GET").h(headers).b(body);
494
+ return b.build();
811
495
  };
812
496
  export const se_GetImportJobCommand = async (input, context) => {
813
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
497
+ const b = rb(input, context);
814
498
  const headers = {};
815
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v2/email/import-jobs/{JobId}";
816
- resolvedPath = __resolvedPath(resolvedPath, input, "JobId", () => input.JobId, "{JobId}", false);
499
+ b.bp("/v2/email/import-jobs/{JobId}");
500
+ b.p("JobId", () => input.JobId, "{JobId}", false);
817
501
  let body;
818
- return new __HttpRequest({
819
- protocol,
820
- hostname,
821
- port,
822
- method: "GET",
823
- headers,
824
- path: resolvedPath,
825
- body,
826
- });
502
+ b.m("GET").h(headers).b(body);
503
+ return b.build();
827
504
  };
828
505
  export const se_GetMessageInsightsCommand = async (input, context) => {
829
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
506
+ const b = rb(input, context);
830
507
  const headers = {};
831
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v2/email/insights/{MessageId}";
832
- resolvedPath = __resolvedPath(resolvedPath, input, "MessageId", () => input.MessageId, "{MessageId}", false);
508
+ b.bp("/v2/email/insights/{MessageId}");
509
+ b.p("MessageId", () => input.MessageId, "{MessageId}", false);
833
510
  let body;
834
- return new __HttpRequest({
835
- protocol,
836
- hostname,
837
- port,
838
- method: "GET",
839
- headers,
840
- path: resolvedPath,
841
- body,
842
- });
511
+ b.m("GET").h(headers).b(body);
512
+ return b.build();
843
513
  };
844
514
  export const se_GetSuppressedDestinationCommand = async (input, context) => {
845
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
515
+ const b = rb(input, context);
846
516
  const headers = {};
847
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
848
- "/v2/email/suppression/addresses/{EmailAddress}";
849
- resolvedPath = __resolvedPath(resolvedPath, input, "EmailAddress", () => input.EmailAddress, "{EmailAddress}", false);
517
+ b.bp("/v2/email/suppression/addresses/{EmailAddress}");
518
+ b.p("EmailAddress", () => input.EmailAddress, "{EmailAddress}", false);
850
519
  let body;
851
- return new __HttpRequest({
852
- protocol,
853
- hostname,
854
- port,
855
- method: "GET",
856
- headers,
857
- path: resolvedPath,
858
- body,
859
- });
520
+ b.m("GET").h(headers).b(body);
521
+ return b.build();
860
522
  };
861
523
  export const se_ListConfigurationSetsCommand = async (input, context) => {
862
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
524
+ const b = rb(input, context);
863
525
  const headers = {};
864
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v2/email/configuration-sets";
526
+ b.bp("/v2/email/configuration-sets");
865
527
  const query = map({
866
- NextToken: [, input.NextToken],
867
- PageSize: [() => input.PageSize !== void 0, () => input.PageSize.toString()],
528
+ [_NT]: [, input[_NT]],
529
+ [_PS]: [() => input.PageSize !== void 0, () => input[_PS].toString()],
868
530
  });
869
531
  let body;
870
- return new __HttpRequest({
871
- protocol,
872
- hostname,
873
- port,
874
- method: "GET",
875
- headers,
876
- path: resolvedPath,
877
- query,
878
- body,
879
- });
532
+ b.m("GET").h(headers).q(query).b(body);
533
+ return b.build();
880
534
  };
881
535
  export const se_ListContactListsCommand = async (input, context) => {
882
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
536
+ const b = rb(input, context);
883
537
  const headers = {};
884
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v2/email/contact-lists";
538
+ b.bp("/v2/email/contact-lists");
885
539
  const query = map({
886
- PageSize: [() => input.PageSize !== void 0, () => input.PageSize.toString()],
887
- NextToken: [, input.NextToken],
540
+ [_PS]: [() => input.PageSize !== void 0, () => input[_PS].toString()],
541
+ [_NT]: [, input[_NT]],
888
542
  });
889
543
  let body;
890
- return new __HttpRequest({
891
- protocol,
892
- hostname,
893
- port,
894
- method: "GET",
895
- headers,
896
- path: resolvedPath,
897
- query,
898
- body,
899
- });
544
+ b.m("GET").h(headers).q(query).b(body);
545
+ return b.build();
900
546
  };
901
547
  export const se_ListContactsCommand = async (input, context) => {
902
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
548
+ const b = rb(input, context);
903
549
  const headers = {
904
550
  "content-type": "application/json",
905
551
  };
906
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
907
- "/v2/email/contact-lists/{ContactListName}/contacts";
908
- resolvedPath = __resolvedPath(resolvedPath, input, "ContactListName", () => input.ContactListName, "{ContactListName}", false);
552
+ b.bp("/v2/email/contact-lists/{ContactListName}/contacts");
553
+ b.p("ContactListName", () => input.ContactListName, "{ContactListName}", false);
909
554
  const query = map({
910
- PageSize: [() => input.PageSize !== void 0, () => input.PageSize.toString()],
911
- NextToken: [, input.NextToken],
555
+ [_PS]: [() => input.PageSize !== void 0, () => input[_PS].toString()],
556
+ [_NT]: [, input[_NT]],
912
557
  });
913
558
  let body;
914
559
  body = JSON.stringify(take(input, {
915
560
  Filter: (_) => _json(_),
916
561
  }));
917
- return new __HttpRequest({
918
- protocol,
919
- hostname,
920
- port,
921
- method: "GET",
922
- headers,
923
- path: resolvedPath,
924
- query,
925
- body,
926
- });
562
+ b.m("GET").h(headers).q(query).b(body);
563
+ return b.build();
927
564
  };
928
565
  export const se_ListCustomVerificationEmailTemplatesCommand = async (input, context) => {
929
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
566
+ const b = rb(input, context);
930
567
  const headers = {};
931
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
932
- "/v2/email/custom-verification-email-templates";
568
+ b.bp("/v2/email/custom-verification-email-templates");
933
569
  const query = map({
934
- NextToken: [, input.NextToken],
935
- PageSize: [() => input.PageSize !== void 0, () => input.PageSize.toString()],
570
+ [_NT]: [, input[_NT]],
571
+ [_PS]: [() => input.PageSize !== void 0, () => input[_PS].toString()],
936
572
  });
937
573
  let body;
938
- return new __HttpRequest({
939
- protocol,
940
- hostname,
941
- port,
942
- method: "GET",
943
- headers,
944
- path: resolvedPath,
945
- query,
946
- body,
947
- });
574
+ b.m("GET").h(headers).q(query).b(body);
575
+ return b.build();
948
576
  };
949
577
  export const se_ListDedicatedIpPoolsCommand = async (input, context) => {
950
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
578
+ const b = rb(input, context);
951
579
  const headers = {};
952
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v2/email/dedicated-ip-pools";
580
+ b.bp("/v2/email/dedicated-ip-pools");
953
581
  const query = map({
954
- NextToken: [, input.NextToken],
955
- PageSize: [() => input.PageSize !== void 0, () => input.PageSize.toString()],
582
+ [_NT]: [, input[_NT]],
583
+ [_PS]: [() => input.PageSize !== void 0, () => input[_PS].toString()],
956
584
  });
957
585
  let body;
958
- return new __HttpRequest({
959
- protocol,
960
- hostname,
961
- port,
962
- method: "GET",
963
- headers,
964
- path: resolvedPath,
965
- query,
966
- body,
967
- });
586
+ b.m("GET").h(headers).q(query).b(body);
587
+ return b.build();
968
588
  };
969
589
  export const se_ListDeliverabilityTestReportsCommand = async (input, context) => {
970
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
590
+ const b = rb(input, context);
971
591
  const headers = {};
972
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
973
- "/v2/email/deliverability-dashboard/test-reports";
592
+ b.bp("/v2/email/deliverability-dashboard/test-reports");
974
593
  const query = map({
975
- NextToken: [, input.NextToken],
976
- PageSize: [() => input.PageSize !== void 0, () => input.PageSize.toString()],
594
+ [_NT]: [, input[_NT]],
595
+ [_PS]: [() => input.PageSize !== void 0, () => input[_PS].toString()],
977
596
  });
978
597
  let body;
979
- return new __HttpRequest({
980
- protocol,
981
- hostname,
982
- port,
983
- method: "GET",
984
- headers,
985
- path: resolvedPath,
986
- query,
987
- body,
988
- });
598
+ b.m("GET").h(headers).q(query).b(body);
599
+ return b.build();
989
600
  };
990
601
  export const se_ListDomainDeliverabilityCampaignsCommand = async (input, context) => {
991
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
602
+ const b = rb(input, context);
992
603
  const headers = {};
993
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
994
- "/v2/email/deliverability-dashboard/domains/{SubscribedDomain}/campaigns";
995
- resolvedPath = __resolvedPath(resolvedPath, input, "SubscribedDomain", () => input.SubscribedDomain, "{SubscribedDomain}", false);
604
+ b.bp("/v2/email/deliverability-dashboard/domains/{SubscribedDomain}/campaigns");
605
+ b.p("SubscribedDomain", () => input.SubscribedDomain, "{SubscribedDomain}", false);
996
606
  const query = map({
997
- StartDate: [
607
+ [_SD]: [
998
608
  __expectNonNull(input.StartDate, `StartDate`) != null,
999
- () => (input.StartDate.toISOString().split(".")[0] + "Z").toString(),
609
+ () => (input[_SD].toISOString().split(".")[0] + "Z").toString(),
1000
610
  ],
1001
- EndDate: [
611
+ [_ED]: [
1002
612
  __expectNonNull(input.EndDate, `EndDate`) != null,
1003
- () => (input.EndDate.toISOString().split(".")[0] + "Z").toString(),
613
+ () => (input[_ED].toISOString().split(".")[0] + "Z").toString(),
1004
614
  ],
1005
- NextToken: [, input.NextToken],
1006
- PageSize: [() => input.PageSize !== void 0, () => input.PageSize.toString()],
615
+ [_NT]: [, input[_NT]],
616
+ [_PS]: [() => input.PageSize !== void 0, () => input[_PS].toString()],
1007
617
  });
1008
618
  let body;
1009
- return new __HttpRequest({
1010
- protocol,
1011
- hostname,
1012
- port,
1013
- method: "GET",
1014
- headers,
1015
- path: resolvedPath,
1016
- query,
1017
- body,
1018
- });
619
+ b.m("GET").h(headers).q(query).b(body);
620
+ return b.build();
1019
621
  };
1020
622
  export const se_ListEmailIdentitiesCommand = async (input, context) => {
1021
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
623
+ const b = rb(input, context);
1022
624
  const headers = {};
1023
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v2/email/identities";
625
+ b.bp("/v2/email/identities");
1024
626
  const query = map({
1025
- NextToken: [, input.NextToken],
1026
- PageSize: [() => input.PageSize !== void 0, () => input.PageSize.toString()],
627
+ [_NT]: [, input[_NT]],
628
+ [_PS]: [() => input.PageSize !== void 0, () => input[_PS].toString()],
1027
629
  });
1028
630
  let body;
1029
- return new __HttpRequest({
1030
- protocol,
1031
- hostname,
1032
- port,
1033
- method: "GET",
1034
- headers,
1035
- path: resolvedPath,
1036
- query,
1037
- body,
1038
- });
631
+ b.m("GET").h(headers).q(query).b(body);
632
+ return b.build();
1039
633
  };
1040
634
  export const se_ListEmailTemplatesCommand = async (input, context) => {
1041
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
635
+ const b = rb(input, context);
1042
636
  const headers = {};
1043
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v2/email/templates";
637
+ b.bp("/v2/email/templates");
1044
638
  const query = map({
1045
- NextToken: [, input.NextToken],
1046
- PageSize: [() => input.PageSize !== void 0, () => input.PageSize.toString()],
639
+ [_NT]: [, input[_NT]],
640
+ [_PS]: [() => input.PageSize !== void 0, () => input[_PS].toString()],
1047
641
  });
1048
642
  let body;
1049
- return new __HttpRequest({
1050
- protocol,
1051
- hostname,
1052
- port,
1053
- method: "GET",
1054
- headers,
1055
- path: resolvedPath,
1056
- query,
1057
- body,
1058
- });
643
+ b.m("GET").h(headers).q(query).b(body);
644
+ return b.build();
1059
645
  };
1060
646
  export const se_ListExportJobsCommand = async (input, context) => {
1061
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
647
+ const b = rb(input, context);
1062
648
  const headers = {
1063
649
  "content-type": "application/json",
1064
650
  };
1065
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v2/email/list-export-jobs";
651
+ b.bp("/v2/email/list-export-jobs");
1066
652
  let body;
1067
653
  body = JSON.stringify(take(input, {
1068
654
  ExportSourceType: [],
@@ -1070,134 +656,86 @@ export const se_ListExportJobsCommand = async (input, context) => {
1070
656
  NextToken: [],
1071
657
  PageSize: [],
1072
658
  }));
1073
- return new __HttpRequest({
1074
- protocol,
1075
- hostname,
1076
- port,
1077
- method: "POST",
1078
- headers,
1079
- path: resolvedPath,
1080
- body,
1081
- });
659
+ b.m("POST").h(headers).b(body);
660
+ return b.build();
1082
661
  };
1083
662
  export const se_ListImportJobsCommand = async (input, context) => {
1084
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
663
+ const b = rb(input, context);
1085
664
  const headers = {
1086
665
  "content-type": "application/json",
1087
666
  };
1088
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v2/email/import-jobs";
667
+ b.bp("/v2/email/import-jobs");
1089
668
  const query = map({
1090
- NextToken: [, input.NextToken],
1091
- PageSize: [() => input.PageSize !== void 0, () => input.PageSize.toString()],
669
+ [_NT]: [, input[_NT]],
670
+ [_PS]: [() => input.PageSize !== void 0, () => input[_PS].toString()],
1092
671
  });
1093
672
  let body;
1094
673
  body = JSON.stringify(take(input, {
1095
674
  ImportDestinationType: [],
1096
675
  }));
1097
- return new __HttpRequest({
1098
- protocol,
1099
- hostname,
1100
- port,
1101
- method: "GET",
1102
- headers,
1103
- path: resolvedPath,
1104
- query,
1105
- body,
1106
- });
676
+ b.m("GET").h(headers).q(query).b(body);
677
+ return b.build();
1107
678
  };
1108
679
  export const se_ListRecommendationsCommand = async (input, context) => {
1109
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
680
+ const b = rb(input, context);
1110
681
  const headers = {
1111
682
  "content-type": "application/json",
1112
683
  };
1113
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v2/email/vdm/recommendations";
684
+ b.bp("/v2/email/vdm/recommendations");
1114
685
  let body;
1115
686
  body = JSON.stringify(take(input, {
1116
687
  Filter: (_) => _json(_),
1117
688
  NextToken: [],
1118
689
  PageSize: [],
1119
690
  }));
1120
- return new __HttpRequest({
1121
- protocol,
1122
- hostname,
1123
- port,
1124
- method: "POST",
1125
- headers,
1126
- path: resolvedPath,
1127
- body,
1128
- });
691
+ b.m("POST").h(headers).b(body);
692
+ return b.build();
1129
693
  };
1130
694
  export const se_ListSuppressedDestinationsCommand = async (input, context) => {
1131
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
695
+ const b = rb(input, context);
1132
696
  const headers = {};
1133
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v2/email/suppression/addresses";
697
+ b.bp("/v2/email/suppression/addresses");
1134
698
  const query = map({
1135
- Reason: [() => input.Reasons !== void 0, () => (input.Reasons || []).map((_entry) => _entry)],
1136
- StartDate: [
1137
- () => input.StartDate !== void 0,
1138
- () => (input.StartDate.toISOString().split(".")[0] + "Z").toString(),
1139
- ],
1140
- EndDate: [() => input.EndDate !== void 0, () => (input.EndDate.toISOString().split(".")[0] + "Z").toString()],
1141
- NextToken: [, input.NextToken],
1142
- PageSize: [() => input.PageSize !== void 0, () => input.PageSize.toString()],
699
+ [_Re]: [() => input.Reasons !== void 0, () => (input[_R] || []).map((_entry) => _entry)],
700
+ [_SD]: [() => input.StartDate !== void 0, () => (input[_SD].toISOString().split(".")[0] + "Z").toString()],
701
+ [_ED]: [() => input.EndDate !== void 0, () => (input[_ED].toISOString().split(".")[0] + "Z").toString()],
702
+ [_NT]: [, input[_NT]],
703
+ [_PS]: [() => input.PageSize !== void 0, () => input[_PS].toString()],
1143
704
  });
1144
705
  let body;
1145
- return new __HttpRequest({
1146
- protocol,
1147
- hostname,
1148
- port,
1149
- method: "GET",
1150
- headers,
1151
- path: resolvedPath,
1152
- query,
1153
- body,
1154
- });
706
+ b.m("GET").h(headers).q(query).b(body);
707
+ return b.build();
1155
708
  };
1156
709
  export const se_ListTagsForResourceCommand = async (input, context) => {
1157
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
710
+ const b = rb(input, context);
1158
711
  const headers = {};
1159
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v2/email/tags";
712
+ b.bp("/v2/email/tags");
1160
713
  const query = map({
1161
- ResourceArn: [, __expectNonNull(input.ResourceArn, `ResourceArn`)],
714
+ [_RA]: [, __expectNonNull(input[_RA], `ResourceArn`)],
1162
715
  });
1163
716
  let body;
1164
- return new __HttpRequest({
1165
- protocol,
1166
- hostname,
1167
- port,
1168
- method: "GET",
1169
- headers,
1170
- path: resolvedPath,
1171
- query,
1172
- body,
1173
- });
717
+ b.m("GET").h(headers).q(query).b(body);
718
+ return b.build();
1174
719
  };
1175
720
  export const se_PutAccountDedicatedIpWarmupAttributesCommand = async (input, context) => {
1176
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
721
+ const b = rb(input, context);
1177
722
  const headers = {
1178
723
  "content-type": "application/json",
1179
724
  };
1180
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v2/email/account/dedicated-ips/warmup";
725
+ b.bp("/v2/email/account/dedicated-ips/warmup");
1181
726
  let body;
1182
727
  body = JSON.stringify(take(input, {
1183
728
  AutoWarmupEnabled: [],
1184
729
  }));
1185
- return new __HttpRequest({
1186
- protocol,
1187
- hostname,
1188
- port,
1189
- method: "PUT",
1190
- headers,
1191
- path: resolvedPath,
1192
- body,
1193
- });
730
+ b.m("PUT").h(headers).b(body);
731
+ return b.build();
1194
732
  };
1195
733
  export const se_PutAccountDetailsCommand = async (input, context) => {
1196
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
734
+ const b = rb(input, context);
1197
735
  const headers = {
1198
736
  "content-type": "application/json",
1199
737
  };
1200
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v2/email/account/details";
738
+ b.bp("/v2/email/account/details");
1201
739
  let body;
1202
740
  body = JSON.stringify(take(input, {
1203
741
  AdditionalContactEmailAddresses: (_) => _json(_),
@@ -1207,432 +745,281 @@ export const se_PutAccountDetailsCommand = async (input, context) => {
1207
745
  UseCaseDescription: [],
1208
746
  WebsiteURL: [],
1209
747
  }));
1210
- return new __HttpRequest({
1211
- protocol,
1212
- hostname,
1213
- port,
1214
- method: "POST",
1215
- headers,
1216
- path: resolvedPath,
1217
- body,
1218
- });
748
+ b.m("POST").h(headers).b(body);
749
+ return b.build();
1219
750
  };
1220
751
  export const se_PutAccountSendingAttributesCommand = async (input, context) => {
1221
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
752
+ const b = rb(input, context);
1222
753
  const headers = {
1223
754
  "content-type": "application/json",
1224
755
  };
1225
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v2/email/account/sending";
756
+ b.bp("/v2/email/account/sending");
1226
757
  let body;
1227
758
  body = JSON.stringify(take(input, {
1228
759
  SendingEnabled: [],
1229
760
  }));
1230
- return new __HttpRequest({
1231
- protocol,
1232
- hostname,
1233
- port,
1234
- method: "PUT",
1235
- headers,
1236
- path: resolvedPath,
1237
- body,
1238
- });
761
+ b.m("PUT").h(headers).b(body);
762
+ return b.build();
1239
763
  };
1240
764
  export const se_PutAccountSuppressionAttributesCommand = async (input, context) => {
1241
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
765
+ const b = rb(input, context);
1242
766
  const headers = {
1243
767
  "content-type": "application/json",
1244
768
  };
1245
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v2/email/account/suppression";
769
+ b.bp("/v2/email/account/suppression");
1246
770
  let body;
1247
771
  body = JSON.stringify(take(input, {
1248
772
  SuppressedReasons: (_) => _json(_),
1249
773
  }));
1250
- return new __HttpRequest({
1251
- protocol,
1252
- hostname,
1253
- port,
1254
- method: "PUT",
1255
- headers,
1256
- path: resolvedPath,
1257
- body,
1258
- });
774
+ b.m("PUT").h(headers).b(body);
775
+ return b.build();
1259
776
  };
1260
777
  export const se_PutAccountVdmAttributesCommand = async (input, context) => {
1261
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
778
+ const b = rb(input, context);
1262
779
  const headers = {
1263
780
  "content-type": "application/json",
1264
781
  };
1265
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v2/email/account/vdm";
782
+ b.bp("/v2/email/account/vdm");
1266
783
  let body;
1267
784
  body = JSON.stringify(take(input, {
1268
785
  VdmAttributes: (_) => _json(_),
1269
786
  }));
1270
- return new __HttpRequest({
1271
- protocol,
1272
- hostname,
1273
- port,
1274
- method: "PUT",
1275
- headers,
1276
- path: resolvedPath,
1277
- body,
1278
- });
787
+ b.m("PUT").h(headers).b(body);
788
+ return b.build();
1279
789
  };
1280
790
  export const se_PutConfigurationSetDeliveryOptionsCommand = async (input, context) => {
1281
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
791
+ const b = rb(input, context);
1282
792
  const headers = {
1283
793
  "content-type": "application/json",
1284
794
  };
1285
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1286
- "/v2/email/configuration-sets/{ConfigurationSetName}/delivery-options";
1287
- resolvedPath = __resolvedPath(resolvedPath, input, "ConfigurationSetName", () => input.ConfigurationSetName, "{ConfigurationSetName}", false);
795
+ b.bp("/v2/email/configuration-sets/{ConfigurationSetName}/delivery-options");
796
+ b.p("ConfigurationSetName", () => input.ConfigurationSetName, "{ConfigurationSetName}", false);
1288
797
  let body;
1289
798
  body = JSON.stringify(take(input, {
1290
799
  SendingPoolName: [],
1291
800
  TlsPolicy: [],
1292
801
  }));
1293
- return new __HttpRequest({
1294
- protocol,
1295
- hostname,
1296
- port,
1297
- method: "PUT",
1298
- headers,
1299
- path: resolvedPath,
1300
- body,
1301
- });
802
+ b.m("PUT").h(headers).b(body);
803
+ return b.build();
1302
804
  };
1303
805
  export const se_PutConfigurationSetReputationOptionsCommand = async (input, context) => {
1304
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
806
+ const b = rb(input, context);
1305
807
  const headers = {
1306
808
  "content-type": "application/json",
1307
809
  };
1308
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1309
- "/v2/email/configuration-sets/{ConfigurationSetName}/reputation-options";
1310
- resolvedPath = __resolvedPath(resolvedPath, input, "ConfigurationSetName", () => input.ConfigurationSetName, "{ConfigurationSetName}", false);
810
+ b.bp("/v2/email/configuration-sets/{ConfigurationSetName}/reputation-options");
811
+ b.p("ConfigurationSetName", () => input.ConfigurationSetName, "{ConfigurationSetName}", false);
1311
812
  let body;
1312
813
  body = JSON.stringify(take(input, {
1313
814
  ReputationMetricsEnabled: [],
1314
815
  }));
1315
- return new __HttpRequest({
1316
- protocol,
1317
- hostname,
1318
- port,
1319
- method: "PUT",
1320
- headers,
1321
- path: resolvedPath,
1322
- body,
1323
- });
816
+ b.m("PUT").h(headers).b(body);
817
+ return b.build();
1324
818
  };
1325
819
  export const se_PutConfigurationSetSendingOptionsCommand = async (input, context) => {
1326
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
820
+ const b = rb(input, context);
1327
821
  const headers = {
1328
822
  "content-type": "application/json",
1329
823
  };
1330
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1331
- "/v2/email/configuration-sets/{ConfigurationSetName}/sending";
1332
- resolvedPath = __resolvedPath(resolvedPath, input, "ConfigurationSetName", () => input.ConfigurationSetName, "{ConfigurationSetName}", false);
824
+ b.bp("/v2/email/configuration-sets/{ConfigurationSetName}/sending");
825
+ b.p("ConfigurationSetName", () => input.ConfigurationSetName, "{ConfigurationSetName}", false);
1333
826
  let body;
1334
827
  body = JSON.stringify(take(input, {
1335
828
  SendingEnabled: [],
1336
829
  }));
1337
- return new __HttpRequest({
1338
- protocol,
1339
- hostname,
1340
- port,
1341
- method: "PUT",
1342
- headers,
1343
- path: resolvedPath,
1344
- body,
1345
- });
830
+ b.m("PUT").h(headers).b(body);
831
+ return b.build();
1346
832
  };
1347
833
  export const se_PutConfigurationSetSuppressionOptionsCommand = async (input, context) => {
1348
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
834
+ const b = rb(input, context);
1349
835
  const headers = {
1350
836
  "content-type": "application/json",
1351
837
  };
1352
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1353
- "/v2/email/configuration-sets/{ConfigurationSetName}/suppression-options";
1354
- resolvedPath = __resolvedPath(resolvedPath, input, "ConfigurationSetName", () => input.ConfigurationSetName, "{ConfigurationSetName}", false);
838
+ b.bp("/v2/email/configuration-sets/{ConfigurationSetName}/suppression-options");
839
+ b.p("ConfigurationSetName", () => input.ConfigurationSetName, "{ConfigurationSetName}", false);
1355
840
  let body;
1356
841
  body = JSON.stringify(take(input, {
1357
842
  SuppressedReasons: (_) => _json(_),
1358
843
  }));
1359
- return new __HttpRequest({
1360
- protocol,
1361
- hostname,
1362
- port,
1363
- method: "PUT",
1364
- headers,
1365
- path: resolvedPath,
1366
- body,
1367
- });
844
+ b.m("PUT").h(headers).b(body);
845
+ return b.build();
1368
846
  };
1369
847
  export const se_PutConfigurationSetTrackingOptionsCommand = async (input, context) => {
1370
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
848
+ const b = rb(input, context);
1371
849
  const headers = {
1372
850
  "content-type": "application/json",
1373
851
  };
1374
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1375
- "/v2/email/configuration-sets/{ConfigurationSetName}/tracking-options";
1376
- resolvedPath = __resolvedPath(resolvedPath, input, "ConfigurationSetName", () => input.ConfigurationSetName, "{ConfigurationSetName}", false);
852
+ b.bp("/v2/email/configuration-sets/{ConfigurationSetName}/tracking-options");
853
+ b.p("ConfigurationSetName", () => input.ConfigurationSetName, "{ConfigurationSetName}", false);
1377
854
  let body;
1378
855
  body = JSON.stringify(take(input, {
1379
856
  CustomRedirectDomain: [],
1380
857
  }));
1381
- return new __HttpRequest({
1382
- protocol,
1383
- hostname,
1384
- port,
1385
- method: "PUT",
1386
- headers,
1387
- path: resolvedPath,
1388
- body,
1389
- });
858
+ b.m("PUT").h(headers).b(body);
859
+ return b.build();
1390
860
  };
1391
861
  export const se_PutConfigurationSetVdmOptionsCommand = async (input, context) => {
1392
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
862
+ const b = rb(input, context);
1393
863
  const headers = {
1394
864
  "content-type": "application/json",
1395
865
  };
1396
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1397
- "/v2/email/configuration-sets/{ConfigurationSetName}/vdm-options";
1398
- resolvedPath = __resolvedPath(resolvedPath, input, "ConfigurationSetName", () => input.ConfigurationSetName, "{ConfigurationSetName}", false);
866
+ b.bp("/v2/email/configuration-sets/{ConfigurationSetName}/vdm-options");
867
+ b.p("ConfigurationSetName", () => input.ConfigurationSetName, "{ConfigurationSetName}", false);
1399
868
  let body;
1400
869
  body = JSON.stringify(take(input, {
1401
870
  VdmOptions: (_) => _json(_),
1402
871
  }));
1403
- return new __HttpRequest({
1404
- protocol,
1405
- hostname,
1406
- port,
1407
- method: "PUT",
1408
- headers,
1409
- path: resolvedPath,
1410
- body,
1411
- });
872
+ b.m("PUT").h(headers).b(body);
873
+ return b.build();
1412
874
  };
1413
875
  export const se_PutDedicatedIpInPoolCommand = async (input, context) => {
1414
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
876
+ const b = rb(input, context);
1415
877
  const headers = {
1416
878
  "content-type": "application/json",
1417
879
  };
1418
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v2/email/dedicated-ips/{Ip}/pool";
1419
- resolvedPath = __resolvedPath(resolvedPath, input, "Ip", () => input.Ip, "{Ip}", false);
880
+ b.bp("/v2/email/dedicated-ips/{Ip}/pool");
881
+ b.p("Ip", () => input.Ip, "{Ip}", false);
1420
882
  let body;
1421
883
  body = JSON.stringify(take(input, {
1422
884
  DestinationPoolName: [],
1423
885
  }));
1424
- return new __HttpRequest({
1425
- protocol,
1426
- hostname,
1427
- port,
1428
- method: "PUT",
1429
- headers,
1430
- path: resolvedPath,
1431
- body,
1432
- });
886
+ b.m("PUT").h(headers).b(body);
887
+ return b.build();
1433
888
  };
1434
889
  export const se_PutDedicatedIpPoolScalingAttributesCommand = async (input, context) => {
1435
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
890
+ const b = rb(input, context);
1436
891
  const headers = {
1437
892
  "content-type": "application/json",
1438
893
  };
1439
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1440
- "/v2/email/dedicated-ip-pools/{PoolName}/scaling";
1441
- resolvedPath = __resolvedPath(resolvedPath, input, "PoolName", () => input.PoolName, "{PoolName}", false);
894
+ b.bp("/v2/email/dedicated-ip-pools/{PoolName}/scaling");
895
+ b.p("PoolName", () => input.PoolName, "{PoolName}", false);
1442
896
  let body;
1443
897
  body = JSON.stringify(take(input, {
1444
898
  ScalingMode: [],
1445
899
  }));
1446
- return new __HttpRequest({
1447
- protocol,
1448
- hostname,
1449
- port,
1450
- method: "PUT",
1451
- headers,
1452
- path: resolvedPath,
1453
- body,
1454
- });
900
+ b.m("PUT").h(headers).b(body);
901
+ return b.build();
1455
902
  };
1456
903
  export const se_PutDedicatedIpWarmupAttributesCommand = async (input, context) => {
1457
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
904
+ const b = rb(input, context);
1458
905
  const headers = {
1459
906
  "content-type": "application/json",
1460
907
  };
1461
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v2/email/dedicated-ips/{Ip}/warmup";
1462
- resolvedPath = __resolvedPath(resolvedPath, input, "Ip", () => input.Ip, "{Ip}", false);
908
+ b.bp("/v2/email/dedicated-ips/{Ip}/warmup");
909
+ b.p("Ip", () => input.Ip, "{Ip}", false);
1463
910
  let body;
1464
911
  body = JSON.stringify(take(input, {
1465
912
  WarmupPercentage: [],
1466
913
  }));
1467
- return new __HttpRequest({
1468
- protocol,
1469
- hostname,
1470
- port,
1471
- method: "PUT",
1472
- headers,
1473
- path: resolvedPath,
1474
- body,
1475
- });
914
+ b.m("PUT").h(headers).b(body);
915
+ return b.build();
1476
916
  };
1477
917
  export const se_PutDeliverabilityDashboardOptionCommand = async (input, context) => {
1478
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
918
+ const b = rb(input, context);
1479
919
  const headers = {
1480
920
  "content-type": "application/json",
1481
921
  };
1482
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v2/email/deliverability-dashboard";
922
+ b.bp("/v2/email/deliverability-dashboard");
1483
923
  let body;
1484
924
  body = JSON.stringify(take(input, {
1485
925
  DashboardEnabled: [],
1486
926
  SubscribedDomains: (_) => se_DomainDeliverabilityTrackingOptions(_, context),
1487
927
  }));
1488
- return new __HttpRequest({
1489
- protocol,
1490
- hostname,
1491
- port,
1492
- method: "PUT",
1493
- headers,
1494
- path: resolvedPath,
1495
- body,
1496
- });
928
+ b.m("PUT").h(headers).b(body);
929
+ return b.build();
1497
930
  };
1498
931
  export const se_PutEmailIdentityConfigurationSetAttributesCommand = async (input, context) => {
1499
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
932
+ const b = rb(input, context);
1500
933
  const headers = {
1501
934
  "content-type": "application/json",
1502
935
  };
1503
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1504
- "/v2/email/identities/{EmailIdentity}/configuration-set";
1505
- resolvedPath = __resolvedPath(resolvedPath, input, "EmailIdentity", () => input.EmailIdentity, "{EmailIdentity}", false);
936
+ b.bp("/v2/email/identities/{EmailIdentity}/configuration-set");
937
+ b.p("EmailIdentity", () => input.EmailIdentity, "{EmailIdentity}", false);
1506
938
  let body;
1507
939
  body = JSON.stringify(take(input, {
1508
940
  ConfigurationSetName: [],
1509
941
  }));
1510
- return new __HttpRequest({
1511
- protocol,
1512
- hostname,
1513
- port,
1514
- method: "PUT",
1515
- headers,
1516
- path: resolvedPath,
1517
- body,
1518
- });
942
+ b.m("PUT").h(headers).b(body);
943
+ return b.build();
1519
944
  };
1520
945
  export const se_PutEmailIdentityDkimAttributesCommand = async (input, context) => {
1521
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
946
+ const b = rb(input, context);
1522
947
  const headers = {
1523
948
  "content-type": "application/json",
1524
949
  };
1525
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v2/email/identities/{EmailIdentity}/dkim";
1526
- resolvedPath = __resolvedPath(resolvedPath, input, "EmailIdentity", () => input.EmailIdentity, "{EmailIdentity}", false);
950
+ b.bp("/v2/email/identities/{EmailIdentity}/dkim");
951
+ b.p("EmailIdentity", () => input.EmailIdentity, "{EmailIdentity}", false);
1527
952
  let body;
1528
953
  body = JSON.stringify(take(input, {
1529
954
  SigningEnabled: [],
1530
955
  }));
1531
- return new __HttpRequest({
1532
- protocol,
1533
- hostname,
1534
- port,
1535
- method: "PUT",
1536
- headers,
1537
- path: resolvedPath,
1538
- body,
1539
- });
956
+ b.m("PUT").h(headers).b(body);
957
+ return b.build();
1540
958
  };
1541
959
  export const se_PutEmailIdentityDkimSigningAttributesCommand = async (input, context) => {
1542
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
960
+ const b = rb(input, context);
1543
961
  const headers = {
1544
962
  "content-type": "application/json",
1545
963
  };
1546
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1547
- "/v1/email/identities/{EmailIdentity}/dkim/signing";
1548
- resolvedPath = __resolvedPath(resolvedPath, input, "EmailIdentity", () => input.EmailIdentity, "{EmailIdentity}", false);
964
+ b.bp("/v1/email/identities/{EmailIdentity}/dkim/signing");
965
+ b.p("EmailIdentity", () => input.EmailIdentity, "{EmailIdentity}", false);
1549
966
  let body;
1550
967
  body = JSON.stringify(take(input, {
1551
968
  SigningAttributes: (_) => _json(_),
1552
969
  SigningAttributesOrigin: [],
1553
970
  }));
1554
- return new __HttpRequest({
1555
- protocol,
1556
- hostname,
1557
- port,
1558
- method: "PUT",
1559
- headers,
1560
- path: resolvedPath,
1561
- body,
1562
- });
971
+ b.m("PUT").h(headers).b(body);
972
+ return b.build();
1563
973
  };
1564
974
  export const se_PutEmailIdentityFeedbackAttributesCommand = async (input, context) => {
1565
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
975
+ const b = rb(input, context);
1566
976
  const headers = {
1567
977
  "content-type": "application/json",
1568
978
  };
1569
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1570
- "/v2/email/identities/{EmailIdentity}/feedback";
1571
- resolvedPath = __resolvedPath(resolvedPath, input, "EmailIdentity", () => input.EmailIdentity, "{EmailIdentity}", false);
979
+ b.bp("/v2/email/identities/{EmailIdentity}/feedback");
980
+ b.p("EmailIdentity", () => input.EmailIdentity, "{EmailIdentity}", false);
1572
981
  let body;
1573
982
  body = JSON.stringify(take(input, {
1574
983
  EmailForwardingEnabled: [],
1575
984
  }));
1576
- return new __HttpRequest({
1577
- protocol,
1578
- hostname,
1579
- port,
1580
- method: "PUT",
1581
- headers,
1582
- path: resolvedPath,
1583
- body,
1584
- });
985
+ b.m("PUT").h(headers).b(body);
986
+ return b.build();
1585
987
  };
1586
988
  export const se_PutEmailIdentityMailFromAttributesCommand = async (input, context) => {
1587
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
989
+ const b = rb(input, context);
1588
990
  const headers = {
1589
991
  "content-type": "application/json",
1590
992
  };
1591
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1592
- "/v2/email/identities/{EmailIdentity}/mail-from";
1593
- resolvedPath = __resolvedPath(resolvedPath, input, "EmailIdentity", () => input.EmailIdentity, "{EmailIdentity}", false);
993
+ b.bp("/v2/email/identities/{EmailIdentity}/mail-from");
994
+ b.p("EmailIdentity", () => input.EmailIdentity, "{EmailIdentity}", false);
1594
995
  let body;
1595
996
  body = JSON.stringify(take(input, {
1596
997
  BehaviorOnMxFailure: [],
1597
998
  MailFromDomain: [],
1598
999
  }));
1599
- return new __HttpRequest({
1600
- protocol,
1601
- hostname,
1602
- port,
1603
- method: "PUT",
1604
- headers,
1605
- path: resolvedPath,
1606
- body,
1607
- });
1000
+ b.m("PUT").h(headers).b(body);
1001
+ return b.build();
1608
1002
  };
1609
1003
  export const se_PutSuppressedDestinationCommand = async (input, context) => {
1610
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1004
+ const b = rb(input, context);
1611
1005
  const headers = {
1612
1006
  "content-type": "application/json",
1613
1007
  };
1614
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v2/email/suppression/addresses";
1008
+ b.bp("/v2/email/suppression/addresses");
1615
1009
  let body;
1616
1010
  body = JSON.stringify(take(input, {
1617
1011
  EmailAddress: [],
1618
1012
  Reason: [],
1619
1013
  }));
1620
- return new __HttpRequest({
1621
- protocol,
1622
- hostname,
1623
- port,
1624
- method: "PUT",
1625
- headers,
1626
- path: resolvedPath,
1627
- body,
1628
- });
1014
+ b.m("PUT").h(headers).b(body);
1015
+ return b.build();
1629
1016
  };
1630
1017
  export const se_SendBulkEmailCommand = async (input, context) => {
1631
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1018
+ const b = rb(input, context);
1632
1019
  const headers = {
1633
1020
  "content-type": "application/json",
1634
1021
  };
1635
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v2/email/outbound-bulk-emails";
1022
+ b.bp("/v2/email/outbound-bulk-emails");
1636
1023
  let body;
1637
1024
  body = JSON.stringify(take(input, {
1638
1025
  BulkEmailEntries: (_) => _json(_),
@@ -1645,45 +1032,30 @@ export const se_SendBulkEmailCommand = async (input, context) => {
1645
1032
  FromEmailAddressIdentityArn: [],
1646
1033
  ReplyToAddresses: (_) => _json(_),
1647
1034
  }));
1648
- return new __HttpRequest({
1649
- protocol,
1650
- hostname,
1651
- port,
1652
- method: "POST",
1653
- headers,
1654
- path: resolvedPath,
1655
- body,
1656
- });
1035
+ b.m("POST").h(headers).b(body);
1036
+ return b.build();
1657
1037
  };
1658
1038
  export const se_SendCustomVerificationEmailCommand = async (input, context) => {
1659
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1039
+ const b = rb(input, context);
1660
1040
  const headers = {
1661
1041
  "content-type": "application/json",
1662
1042
  };
1663
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1664
- "/v2/email/outbound-custom-verification-emails";
1043
+ b.bp("/v2/email/outbound-custom-verification-emails");
1665
1044
  let body;
1666
1045
  body = JSON.stringify(take(input, {
1667
1046
  ConfigurationSetName: [],
1668
1047
  EmailAddress: [],
1669
1048
  TemplateName: [],
1670
1049
  }));
1671
- return new __HttpRequest({
1672
- protocol,
1673
- hostname,
1674
- port,
1675
- method: "POST",
1676
- headers,
1677
- path: resolvedPath,
1678
- body,
1679
- });
1050
+ b.m("POST").h(headers).b(body);
1051
+ return b.build();
1680
1052
  };
1681
1053
  export const se_SendEmailCommand = async (input, context) => {
1682
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1054
+ const b = rb(input, context);
1683
1055
  const headers = {
1684
1056
  "content-type": "application/json",
1685
1057
  };
1686
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v2/email/outbound-emails";
1058
+ b.bp("/v2/email/outbound-emails");
1687
1059
  let body;
1688
1060
  body = JSON.stringify(take(input, {
1689
1061
  ConfigurationSetName: [],
@@ -1697,159 +1069,106 @@ export const se_SendEmailCommand = async (input, context) => {
1697
1069
  ListManagementOptions: (_) => _json(_),
1698
1070
  ReplyToAddresses: (_) => _json(_),
1699
1071
  }));
1700
- return new __HttpRequest({
1701
- protocol,
1702
- hostname,
1703
- port,
1704
- method: "POST",
1705
- headers,
1706
- path: resolvedPath,
1707
- body,
1708
- });
1072
+ b.m("POST").h(headers).b(body);
1073
+ return b.build();
1709
1074
  };
1710
1075
  export const se_TagResourceCommand = async (input, context) => {
1711
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1076
+ const b = rb(input, context);
1712
1077
  const headers = {
1713
1078
  "content-type": "application/json",
1714
1079
  };
1715
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v2/email/tags";
1080
+ b.bp("/v2/email/tags");
1716
1081
  let body;
1717
1082
  body = JSON.stringify(take(input, {
1718
1083
  ResourceArn: [],
1719
1084
  Tags: (_) => _json(_),
1720
1085
  }));
1721
- return new __HttpRequest({
1722
- protocol,
1723
- hostname,
1724
- port,
1725
- method: "POST",
1726
- headers,
1727
- path: resolvedPath,
1728
- body,
1729
- });
1086
+ b.m("POST").h(headers).b(body);
1087
+ return b.build();
1730
1088
  };
1731
1089
  export const se_TestRenderEmailTemplateCommand = async (input, context) => {
1732
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1090
+ const b = rb(input, context);
1733
1091
  const headers = {
1734
1092
  "content-type": "application/json",
1735
1093
  };
1736
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v2/email/templates/{TemplateName}/render";
1737
- resolvedPath = __resolvedPath(resolvedPath, input, "TemplateName", () => input.TemplateName, "{TemplateName}", false);
1094
+ b.bp("/v2/email/templates/{TemplateName}/render");
1095
+ b.p("TemplateName", () => input.TemplateName, "{TemplateName}", false);
1738
1096
  let body;
1739
1097
  body = JSON.stringify(take(input, {
1740
1098
  TemplateData: [],
1741
1099
  }));
1742
- return new __HttpRequest({
1743
- protocol,
1744
- hostname,
1745
- port,
1746
- method: "POST",
1747
- headers,
1748
- path: resolvedPath,
1749
- body,
1750
- });
1100
+ b.m("POST").h(headers).b(body);
1101
+ return b.build();
1751
1102
  };
1752
1103
  export const se_UntagResourceCommand = async (input, context) => {
1753
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1104
+ const b = rb(input, context);
1754
1105
  const headers = {};
1755
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v2/email/tags";
1106
+ b.bp("/v2/email/tags");
1756
1107
  const query = map({
1757
- ResourceArn: [, __expectNonNull(input.ResourceArn, `ResourceArn`)],
1758
- TagKeys: [
1108
+ [_RA]: [, __expectNonNull(input[_RA], `ResourceArn`)],
1109
+ [_TK]: [
1759
1110
  __expectNonNull(input.TagKeys, `TagKeys`) != null,
1760
- () => (input.TagKeys || []).map((_entry) => _entry),
1111
+ () => (input[_TK] || []).map((_entry) => _entry),
1761
1112
  ],
1762
1113
  });
1763
1114
  let body;
1764
- return new __HttpRequest({
1765
- protocol,
1766
- hostname,
1767
- port,
1768
- method: "DELETE",
1769
- headers,
1770
- path: resolvedPath,
1771
- query,
1772
- body,
1773
- });
1115
+ b.m("DELETE").h(headers).q(query).b(body);
1116
+ return b.build();
1774
1117
  };
1775
1118
  export const se_UpdateConfigurationSetEventDestinationCommand = async (input, context) => {
1776
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1119
+ const b = rb(input, context);
1777
1120
  const headers = {
1778
1121
  "content-type": "application/json",
1779
1122
  };
1780
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1781
- "/v2/email/configuration-sets/{ConfigurationSetName}/event-destinations/{EventDestinationName}";
1782
- resolvedPath = __resolvedPath(resolvedPath, input, "ConfigurationSetName", () => input.ConfigurationSetName, "{ConfigurationSetName}", false);
1783
- resolvedPath = __resolvedPath(resolvedPath, input, "EventDestinationName", () => input.EventDestinationName, "{EventDestinationName}", false);
1123
+ b.bp("/v2/email/configuration-sets/{ConfigurationSetName}/event-destinations/{EventDestinationName}");
1124
+ b.p("ConfigurationSetName", () => input.ConfigurationSetName, "{ConfigurationSetName}", false);
1125
+ b.p("EventDestinationName", () => input.EventDestinationName, "{EventDestinationName}", false);
1784
1126
  let body;
1785
1127
  body = JSON.stringify(take(input, {
1786
1128
  EventDestination: (_) => _json(_),
1787
1129
  }));
1788
- return new __HttpRequest({
1789
- protocol,
1790
- hostname,
1791
- port,
1792
- method: "PUT",
1793
- headers,
1794
- path: resolvedPath,
1795
- body,
1796
- });
1130
+ b.m("PUT").h(headers).b(body);
1131
+ return b.build();
1797
1132
  };
1798
1133
  export const se_UpdateContactCommand = async (input, context) => {
1799
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1134
+ const b = rb(input, context);
1800
1135
  const headers = {
1801
1136
  "content-type": "application/json",
1802
1137
  };
1803
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1804
- "/v2/email/contact-lists/{ContactListName}/contacts/{EmailAddress}";
1805
- resolvedPath = __resolvedPath(resolvedPath, input, "ContactListName", () => input.ContactListName, "{ContactListName}", false);
1806
- resolvedPath = __resolvedPath(resolvedPath, input, "EmailAddress", () => input.EmailAddress, "{EmailAddress}", false);
1138
+ b.bp("/v2/email/contact-lists/{ContactListName}/contacts/{EmailAddress}");
1139
+ b.p("ContactListName", () => input.ContactListName, "{ContactListName}", false);
1140
+ b.p("EmailAddress", () => input.EmailAddress, "{EmailAddress}", false);
1807
1141
  let body;
1808
1142
  body = JSON.stringify(take(input, {
1809
1143
  AttributesData: [],
1810
1144
  TopicPreferences: (_) => _json(_),
1811
1145
  UnsubscribeAll: [],
1812
1146
  }));
1813
- return new __HttpRequest({
1814
- protocol,
1815
- hostname,
1816
- port,
1817
- method: "PUT",
1818
- headers,
1819
- path: resolvedPath,
1820
- body,
1821
- });
1147
+ b.m("PUT").h(headers).b(body);
1148
+ return b.build();
1822
1149
  };
1823
1150
  export const se_UpdateContactListCommand = async (input, context) => {
1824
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1151
+ const b = rb(input, context);
1825
1152
  const headers = {
1826
1153
  "content-type": "application/json",
1827
1154
  };
1828
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v2/email/contact-lists/{ContactListName}";
1829
- resolvedPath = __resolvedPath(resolvedPath, input, "ContactListName", () => input.ContactListName, "{ContactListName}", false);
1155
+ b.bp("/v2/email/contact-lists/{ContactListName}");
1156
+ b.p("ContactListName", () => input.ContactListName, "{ContactListName}", false);
1830
1157
  let body;
1831
1158
  body = JSON.stringify(take(input, {
1832
1159
  Description: [],
1833
1160
  Topics: (_) => _json(_),
1834
1161
  }));
1835
- return new __HttpRequest({
1836
- protocol,
1837
- hostname,
1838
- port,
1839
- method: "PUT",
1840
- headers,
1841
- path: resolvedPath,
1842
- body,
1843
- });
1162
+ b.m("PUT").h(headers).b(body);
1163
+ return b.build();
1844
1164
  };
1845
1165
  export const se_UpdateCustomVerificationEmailTemplateCommand = async (input, context) => {
1846
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1166
+ const b = rb(input, context);
1847
1167
  const headers = {
1848
1168
  "content-type": "application/json",
1849
1169
  };
1850
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1851
- "/v2/email/custom-verification-email-templates/{TemplateName}";
1852
- resolvedPath = __resolvedPath(resolvedPath, input, "TemplateName", () => input.TemplateName, "{TemplateName}", false);
1170
+ b.bp("/v2/email/custom-verification-email-templates/{TemplateName}");
1171
+ b.p("TemplateName", () => input.TemplateName, "{TemplateName}", false);
1853
1172
  let body;
1854
1173
  body = JSON.stringify(take(input, {
1855
1174
  FailureRedirectionURL: [],
@@ -1858,59 +1177,37 @@ export const se_UpdateCustomVerificationEmailTemplateCommand = async (input, con
1858
1177
  TemplateContent: [],
1859
1178
  TemplateSubject: [],
1860
1179
  }));
1861
- return new __HttpRequest({
1862
- protocol,
1863
- hostname,
1864
- port,
1865
- method: "PUT",
1866
- headers,
1867
- path: resolvedPath,
1868
- body,
1869
- });
1180
+ b.m("PUT").h(headers).b(body);
1181
+ return b.build();
1870
1182
  };
1871
1183
  export const se_UpdateEmailIdentityPolicyCommand = async (input, context) => {
1872
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1184
+ const b = rb(input, context);
1873
1185
  const headers = {
1874
1186
  "content-type": "application/json",
1875
1187
  };
1876
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1877
- "/v2/email/identities/{EmailIdentity}/policies/{PolicyName}";
1878
- resolvedPath = __resolvedPath(resolvedPath, input, "EmailIdentity", () => input.EmailIdentity, "{EmailIdentity}", false);
1879
- resolvedPath = __resolvedPath(resolvedPath, input, "PolicyName", () => input.PolicyName, "{PolicyName}", false);
1188
+ b.bp("/v2/email/identities/{EmailIdentity}/policies/{PolicyName}");
1189
+ b.p("EmailIdentity", () => input.EmailIdentity, "{EmailIdentity}", false);
1190
+ b.p("PolicyName", () => input.PolicyName, "{PolicyName}", false);
1880
1191
  let body;
1881
1192
  body = JSON.stringify(take(input, {
1882
1193
  Policy: [],
1883
1194
  }));
1884
- return new __HttpRequest({
1885
- protocol,
1886
- hostname,
1887
- port,
1888
- method: "PUT",
1889
- headers,
1890
- path: resolvedPath,
1891
- body,
1892
- });
1195
+ b.m("PUT").h(headers).b(body);
1196
+ return b.build();
1893
1197
  };
1894
1198
  export const se_UpdateEmailTemplateCommand = async (input, context) => {
1895
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1199
+ const b = rb(input, context);
1896
1200
  const headers = {
1897
1201
  "content-type": "application/json",
1898
1202
  };
1899
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v2/email/templates/{TemplateName}";
1900
- resolvedPath = __resolvedPath(resolvedPath, input, "TemplateName", () => input.TemplateName, "{TemplateName}", false);
1203
+ b.bp("/v2/email/templates/{TemplateName}");
1204
+ b.p("TemplateName", () => input.TemplateName, "{TemplateName}", false);
1901
1205
  let body;
1902
1206
  body = JSON.stringify(take(input, {
1903
1207
  TemplateContent: (_) => _json(_),
1904
1208
  }));
1905
- return new __HttpRequest({
1906
- protocol,
1907
- hostname,
1908
- port,
1909
- method: "PUT",
1910
- headers,
1911
- path: resolvedPath,
1912
- body,
1913
- });
1209
+ b.m("PUT").h(headers).b(body);
1210
+ return b.build();
1914
1211
  };
1915
1212
  export const de_BatchGetMetricDataCommand = async (output, context) => {
1916
1213
  if (output.statusCode !== 200 && output.statusCode >= 300) {
@@ -6140,6 +5437,16 @@ const isSerializableHeaderValue = (value) => value !== undefined &&
6140
5437
  value !== "" &&
6141
5438
  (!Object.getOwnPropertyNames(value).includes("length") || value.length != 0) &&
6142
5439
  (!Object.getOwnPropertyNames(value).includes("size") || value.size != 0);
5440
+ const _BIN = "BlacklistItemNames";
5441
+ const _ED = "EndDate";
5442
+ const _NT = "NextToken";
5443
+ const _PN = "PoolName";
5444
+ const _PS = "PageSize";
5445
+ const _R = "Reasons";
5446
+ const _RA = "ResourceArn";
5447
+ const _Re = "Reason";
5448
+ const _SD = "StartDate";
5449
+ const _TK = "TagKeys";
6143
5450
  const parseBody = (streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
6144
5451
  if (encoded.length) {
6145
5452
  return JSON.parse(encoded);