@aws-sdk/client-pinpoint-email 3.474.0 → 3.477.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (3) hide show
  1. package/dist-cjs/protocols/Aws_restJson1.js +229 -543
  2. package/dist-es/protocols/Aws_restJson1.js +230 -544
  3. package/package.json +5 -4
package/dist-es/protocols/Aws_restJson1.js CHANGED
@@ -1,13 +1,13 @@
1
- import { HttpRequest as __HttpRequest } from "@smithy/protocol-http";
2
- import { _json, collectBody, decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, 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, 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, LimitExceededException, MailFromDomainNotVerifiedException, MessageRejected, NotFoundException, SendingPausedException, TooManyRequestsException, } from "../models/models_0";
4
4
  import { PinpointEmailServiceException as __BaseException } from "../models/PinpointEmailServiceException";
5
5
  export const se_CreateConfigurationSetCommand = 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 || ""}` + "/v1/email/configuration-sets";
10
+ b.bp("/v1/email/configuration-sets");
11
11
  let body;
12
12
  body = JSON.stringify(take(input, {
13
13
  ConfigurationSetName: [],
@@ -17,66 +17,44 @@ export const se_CreateConfigurationSetCommand = async (input, context) => {
17
17
  Tags: (_) => _json(_),
18
18
  TrackingOptions: (_) => _json(_),
19
19
  }));
20
- return new __HttpRequest({
21
- protocol,
22
- hostname,
23
- port,
24
- method: "POST",
25
- headers,
26
- path: resolvedPath,
27
- body,
28
- });
20
+ b.m("POST").h(headers).b(body);
21
+ return b.build();
29
22
  };
30
23
  export const se_CreateConfigurationSetEventDestinationCommand = async (input, context) => {
31
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
24
+ const b = rb(input, context);
32
25
  const headers = {
33
26
  "content-type": "application/json",
34
27
  };
35
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
36
- "/v1/email/configuration-sets/{ConfigurationSetName}/event-destinations";
37
- resolvedPath = __resolvedPath(resolvedPath, input, "ConfigurationSetName", () => input.ConfigurationSetName, "{ConfigurationSetName}", false);
28
+ b.bp("/v1/email/configuration-sets/{ConfigurationSetName}/event-destinations");
29
+ b.p("ConfigurationSetName", () => input.ConfigurationSetName, "{ConfigurationSetName}", false);
38
30
  let body;
39
31
  body = JSON.stringify(take(input, {
40
32
  EventDestination: (_) => _json(_),
41
33
  EventDestinationName: [],
42
34
  }));
43
- return new __HttpRequest({
44
- protocol,
45
- hostname,
46
- port,
47
- method: "POST",
48
- headers,
49
- path: resolvedPath,
50
- body,
51
- });
35
+ b.m("POST").h(headers).b(body);
36
+ return b.build();
52
37
  };
53
38
  export const se_CreateDedicatedIpPoolCommand = async (input, context) => {
54
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
39
+ const b = rb(input, context);
55
40
  const headers = {
56
41
  "content-type": "application/json",
57
42
  };
58
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/email/dedicated-ip-pools";
43
+ b.bp("/v1/email/dedicated-ip-pools");
59
44
  let body;
60
45
  body = JSON.stringify(take(input, {
61
46
  PoolName: [],
62
47
  Tags: (_) => _json(_),
63
48
  }));
64
- return new __HttpRequest({
65
- protocol,
66
- hostname,
67
- port,
68
- method: "POST",
69
- headers,
70
- path: resolvedPath,
71
- body,
72
- });
49
+ b.m("POST").h(headers).b(body);
50
+ return b.build();
73
51
  };
74
52
  export const se_CreateDeliverabilityTestReportCommand = async (input, context) => {
75
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
53
+ const b = rb(input, context);
76
54
  const headers = {
77
55
  "content-type": "application/json",
78
56
  };
79
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/email/deliverability-dashboard/test";
57
+ b.bp("/v1/email/deliverability-dashboard/test");
80
58
  let body;
81
59
  body = JSON.stringify(take(input, {
82
60
  Content: (_) => se_EmailContent(_, context),
@@ -84,706 +62,436 @@ export const se_CreateDeliverabilityTestReportCommand = async (input, context) =
84
62
  ReportName: [],
85
63
  Tags: (_) => _json(_),
86
64
  }));
87
- return new __HttpRequest({
88
- protocol,
89
- hostname,
90
- port,
91
- method: "POST",
92
- headers,
93
- path: resolvedPath,
94
- body,
95
- });
65
+ b.m("POST").h(headers).b(body);
66
+ return b.build();
96
67
  };
97
68
  export const se_CreateEmailIdentityCommand = async (input, context) => {
98
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
69
+ const b = rb(input, context);
99
70
  const headers = {
100
71
  "content-type": "application/json",
101
72
  };
102
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/email/identities";
73
+ b.bp("/v1/email/identities");
103
74
  let body;
104
75
  body = JSON.stringify(take(input, {
105
76
  EmailIdentity: [],
106
77
  Tags: (_) => _json(_),
107
78
  }));
108
- return new __HttpRequest({
109
- protocol,
110
- hostname,
111
- port,
112
- method: "POST",
113
- headers,
114
- path: resolvedPath,
115
- body,
116
- });
79
+ b.m("POST").h(headers).b(body);
80
+ return b.build();
117
81
  };
118
82
  export const se_DeleteConfigurationSetCommand = async (input, context) => {
119
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
83
+ const b = rb(input, context);
120
84
  const headers = {};
121
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
122
- "/v1/email/configuration-sets/{ConfigurationSetName}";
123
- resolvedPath = __resolvedPath(resolvedPath, input, "ConfigurationSetName", () => input.ConfigurationSetName, "{ConfigurationSetName}", false);
85
+ b.bp("/v1/email/configuration-sets/{ConfigurationSetName}");
86
+ b.p("ConfigurationSetName", () => input.ConfigurationSetName, "{ConfigurationSetName}", false);
124
87
  let body;
125
- return new __HttpRequest({
126
- protocol,
127
- hostname,
128
- port,
129
- method: "DELETE",
130
- headers,
131
- path: resolvedPath,
132
- body,
133
- });
88
+ b.m("DELETE").h(headers).b(body);
89
+ return b.build();
134
90
  };
135
91
  export const se_DeleteConfigurationSetEventDestinationCommand = async (input, context) => {
136
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
92
+ const b = rb(input, context);
137
93
  const headers = {};
138
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
139
- "/v1/email/configuration-sets/{ConfigurationSetName}/event-destinations/{EventDestinationName}";
140
- resolvedPath = __resolvedPath(resolvedPath, input, "ConfigurationSetName", () => input.ConfigurationSetName, "{ConfigurationSetName}", false);
141
- resolvedPath = __resolvedPath(resolvedPath, input, "EventDestinationName", () => input.EventDestinationName, "{EventDestinationName}", false);
94
+ b.bp("/v1/email/configuration-sets/{ConfigurationSetName}/event-destinations/{EventDestinationName}");
95
+ b.p("ConfigurationSetName", () => input.ConfigurationSetName, "{ConfigurationSetName}", false);
96
+ b.p("EventDestinationName", () => input.EventDestinationName, "{EventDestinationName}", false);
142
97
  let body;
143
- return new __HttpRequest({
144
- protocol,
145
- hostname,
146
- port,
147
- method: "DELETE",
148
- headers,
149
- path: resolvedPath,
150
- body,
151
- });
98
+ b.m("DELETE").h(headers).b(body);
99
+ return b.build();
152
100
  };
153
101
  export const se_DeleteDedicatedIpPoolCommand = async (input, context) => {
154
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
102
+ const b = rb(input, context);
155
103
  const headers = {};
156
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/email/dedicated-ip-pools/{PoolName}";
157
- resolvedPath = __resolvedPath(resolvedPath, input, "PoolName", () => input.PoolName, "{PoolName}", false);
104
+ b.bp("/v1/email/dedicated-ip-pools/{PoolName}");
105
+ b.p("PoolName", () => input.PoolName, "{PoolName}", false);
158
106
  let body;
159
- return new __HttpRequest({
160
- protocol,
161
- hostname,
162
- port,
163
- method: "DELETE",
164
- headers,
165
- path: resolvedPath,
166
- body,
167
- });
107
+ b.m("DELETE").h(headers).b(body);
108
+ return b.build();
168
109
  };
169
110
  export const se_DeleteEmailIdentityCommand = async (input, context) => {
170
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
111
+ const b = rb(input, context);
171
112
  const headers = {};
172
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/email/identities/{EmailIdentity}";
173
- resolvedPath = __resolvedPath(resolvedPath, input, "EmailIdentity", () => input.EmailIdentity, "{EmailIdentity}", false);
113
+ b.bp("/v1/email/identities/{EmailIdentity}");
114
+ b.p("EmailIdentity", () => input.EmailIdentity, "{EmailIdentity}", false);
174
115
  let body;
175
- return new __HttpRequest({
176
- protocol,
177
- hostname,
178
- port,
179
- method: "DELETE",
180
- headers,
181
- path: resolvedPath,
182
- body,
183
- });
116
+ b.m("DELETE").h(headers).b(body);
117
+ return b.build();
184
118
  };
185
119
  export const se_GetAccountCommand = async (input, context) => {
186
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
120
+ const b = rb(input, context);
187
121
  const headers = {
188
122
  "content-type": "application/json",
189
123
  };
190
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/email/account";
124
+ b.bp("/v1/email/account");
191
125
  let body;
192
126
  body = "";
193
- return new __HttpRequest({
194
- protocol,
195
- hostname,
196
- port,
197
- method: "GET",
198
- headers,
199
- path: resolvedPath,
200
- body,
201
- });
127
+ b.m("GET").h(headers).b(body);
128
+ return b.build();
202
129
  };
203
130
  export const se_GetBlacklistReportsCommand = async (input, context) => {
204
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
131
+ const b = rb(input, context);
205
132
  const headers = {};
206
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
207
- "/v1/email/deliverability-dashboard/blacklist-report";
133
+ b.bp("/v1/email/deliverability-dashboard/blacklist-report");
208
134
  const query = map({
209
- BlacklistItemNames: [
135
+ [_BIN]: [
210
136
  __expectNonNull(input.BlacklistItemNames, `BlacklistItemNames`) != null,
211
- () => (input.BlacklistItemNames || []).map((_entry) => _entry),
137
+ () => (input[_BIN] || []).map((_entry) => _entry),
212
138
  ],
213
139
  });
214
140
  let body;
215
- return new __HttpRequest({
216
- protocol,
217
- hostname,
218
- port,
219
- method: "GET",
220
- headers,
221
- path: resolvedPath,
222
- query,
223
- body,
224
- });
141
+ b.m("GET").h(headers).q(query).b(body);
142
+ return b.build();
225
143
  };
226
144
  export const se_GetConfigurationSetCommand = async (input, context) => {
227
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
145
+ const b = rb(input, context);
228
146
  const headers = {};
229
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
230
- "/v1/email/configuration-sets/{ConfigurationSetName}";
231
- resolvedPath = __resolvedPath(resolvedPath, input, "ConfigurationSetName", () => input.ConfigurationSetName, "{ConfigurationSetName}", false);
147
+ b.bp("/v1/email/configuration-sets/{ConfigurationSetName}");
148
+ b.p("ConfigurationSetName", () => input.ConfigurationSetName, "{ConfigurationSetName}", false);
232
149
  let body;
233
- return new __HttpRequest({
234
- protocol,
235
- hostname,
236
- port,
237
- method: "GET",
238
- headers,
239
- path: resolvedPath,
240
- body,
241
- });
150
+ b.m("GET").h(headers).b(body);
151
+ return b.build();
242
152
  };
243
153
  export const se_GetConfigurationSetEventDestinationsCommand = async (input, context) => {
244
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
154
+ const b = rb(input, context);
245
155
  const headers = {};
246
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
247
- "/v1/email/configuration-sets/{ConfigurationSetName}/event-destinations";
248
- resolvedPath = __resolvedPath(resolvedPath, input, "ConfigurationSetName", () => input.ConfigurationSetName, "{ConfigurationSetName}", false);
156
+ b.bp("/v1/email/configuration-sets/{ConfigurationSetName}/event-destinations");
157
+ b.p("ConfigurationSetName", () => input.ConfigurationSetName, "{ConfigurationSetName}", false);
249
158
  let body;
250
- return new __HttpRequest({
251
- protocol,
252
- hostname,
253
- port,
254
- method: "GET",
255
- headers,
256
- path: resolvedPath,
257
- body,
258
- });
159
+ b.m("GET").h(headers).b(body);
160
+ return b.build();
259
161
  };
260
162
  export const se_GetDedicatedIpCommand = async (input, context) => {
261
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
163
+ const b = rb(input, context);
262
164
  const headers = {};
263
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/email/dedicated-ips/{Ip}";
264
- resolvedPath = __resolvedPath(resolvedPath, input, "Ip", () => input.Ip, "{Ip}", false);
165
+ b.bp("/v1/email/dedicated-ips/{Ip}");
166
+ b.p("Ip", () => input.Ip, "{Ip}", false);
265
167
  let body;
266
- return new __HttpRequest({
267
- protocol,
268
- hostname,
269
- port,
270
- method: "GET",
271
- headers,
272
- path: resolvedPath,
273
- body,
274
- });
168
+ b.m("GET").h(headers).b(body);
169
+ return b.build();
275
170
  };
276
171
  export const se_GetDedicatedIpsCommand = async (input, context) => {
277
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
172
+ const b = rb(input, context);
278
173
  const headers = {};
279
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/email/dedicated-ips";
174
+ b.bp("/v1/email/dedicated-ips");
280
175
  const query = map({
281
- PoolName: [, input.PoolName],
282
- NextToken: [, input.NextToken],
283
- PageSize: [() => input.PageSize !== void 0, () => input.PageSize.toString()],
176
+ [_PN]: [, input[_PN]],
177
+ [_NT]: [, input[_NT]],
178
+ [_PS]: [() => input.PageSize !== void 0, () => input[_PS].toString()],
284
179
  });
285
180
  let body;
286
- return new __HttpRequest({
287
- protocol,
288
- hostname,
289
- port,
290
- method: "GET",
291
- headers,
292
- path: resolvedPath,
293
- query,
294
- body,
295
- });
181
+ b.m("GET").h(headers).q(query).b(body);
182
+ return b.build();
296
183
  };
297
184
  export const se_GetDeliverabilityDashboardOptionsCommand = async (input, context) => {
298
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
185
+ const b = rb(input, context);
299
186
  const headers = {
300
187
  "content-type": "application/json",
301
188
  };
302
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/email/deliverability-dashboard";
189
+ b.bp("/v1/email/deliverability-dashboard");
303
190
  let body;
304
191
  body = "";
305
- return new __HttpRequest({
306
- protocol,
307
- hostname,
308
- port,
309
- method: "GET",
310
- headers,
311
- path: resolvedPath,
312
- body,
313
- });
192
+ b.m("GET").h(headers).b(body);
193
+ return b.build();
314
194
  };
315
195
  export const se_GetDeliverabilityTestReportCommand = async (input, context) => {
316
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
196
+ const b = rb(input, context);
317
197
  const headers = {};
318
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
319
- "/v1/email/deliverability-dashboard/test-reports/{ReportId}";
320
- resolvedPath = __resolvedPath(resolvedPath, input, "ReportId", () => input.ReportId, "{ReportId}", false);
198
+ b.bp("/v1/email/deliverability-dashboard/test-reports/{ReportId}");
199
+ b.p("ReportId", () => input.ReportId, "{ReportId}", false);
321
200
  let body;
322
- return new __HttpRequest({
323
- protocol,
324
- hostname,
325
- port,
326
- method: "GET",
327
- headers,
328
- path: resolvedPath,
329
- body,
330
- });
201
+ b.m("GET").h(headers).b(body);
202
+ return b.build();
331
203
  };
332
204
  export const se_GetDomainDeliverabilityCampaignCommand = async (input, context) => {
333
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
205
+ const b = rb(input, context);
334
206
  const headers = {};
335
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
336
- "/v1/email/deliverability-dashboard/campaigns/{CampaignId}";
337
- resolvedPath = __resolvedPath(resolvedPath, input, "CampaignId", () => input.CampaignId, "{CampaignId}", false);
207
+ b.bp("/v1/email/deliverability-dashboard/campaigns/{CampaignId}");
208
+ b.p("CampaignId", () => input.CampaignId, "{CampaignId}", false);
338
209
  let body;
339
- return new __HttpRequest({
340
- protocol,
341
- hostname,
342
- port,
343
- method: "GET",
344
- headers,
345
- path: resolvedPath,
346
- body,
347
- });
210
+ b.m("GET").h(headers).b(body);
211
+ return b.build();
348
212
  };
349
213
  export const se_GetDomainStatisticsReportCommand = async (input, context) => {
350
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
214
+ const b = rb(input, context);
351
215
  const headers = {};
352
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
353
- "/v1/email/deliverability-dashboard/statistics-report/{Domain}";
354
- resolvedPath = __resolvedPath(resolvedPath, input, "Domain", () => input.Domain, "{Domain}", false);
216
+ b.bp("/v1/email/deliverability-dashboard/statistics-report/{Domain}");
217
+ b.p("Domain", () => input.Domain, "{Domain}", false);
355
218
  const query = map({
356
- StartDate: [
219
+ [_SD]: [
357
220
  __expectNonNull(input.StartDate, `StartDate`) != null,
358
- () => (input.StartDate.toISOString().split(".")[0] + "Z").toString(),
221
+ () => (input[_SD].toISOString().split(".")[0] + "Z").toString(),
359
222
  ],
360
- EndDate: [
223
+ [_ED]: [
361
224
  __expectNonNull(input.EndDate, `EndDate`) != null,
362
- () => (input.EndDate.toISOString().split(".")[0] + "Z").toString(),
225
+ () => (input[_ED].toISOString().split(".")[0] + "Z").toString(),
363
226
  ],
364
227
  });
365
228
  let body;
366
- return new __HttpRequest({
367
- protocol,
368
- hostname,
369
- port,
370
- method: "GET",
371
- headers,
372
- path: resolvedPath,
373
- query,
374
- body,
375
- });
229
+ b.m("GET").h(headers).q(query).b(body);
230
+ return b.build();
376
231
  };
377
232
  export const se_GetEmailIdentityCommand = async (input, context) => {
378
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
233
+ const b = rb(input, context);
379
234
  const headers = {};
380
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/email/identities/{EmailIdentity}";
381
- resolvedPath = __resolvedPath(resolvedPath, input, "EmailIdentity", () => input.EmailIdentity, "{EmailIdentity}", false);
235
+ b.bp("/v1/email/identities/{EmailIdentity}");
236
+ b.p("EmailIdentity", () => input.EmailIdentity, "{EmailIdentity}", false);
382
237
  let body;
383
- return new __HttpRequest({
384
- protocol,
385
- hostname,
386
- port,
387
- method: "GET",
388
- headers,
389
- path: resolvedPath,
390
- body,
391
- });
238
+ b.m("GET").h(headers).b(body);
239
+ return b.build();
392
240
  };
393
241
  export const se_ListConfigurationSetsCommand = async (input, context) => {
394
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
242
+ const b = rb(input, context);
395
243
  const headers = {};
396
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/email/configuration-sets";
244
+ b.bp("/v1/email/configuration-sets");
397
245
  const query = map({
398
- NextToken: [, input.NextToken],
399
- PageSize: [() => input.PageSize !== void 0, () => input.PageSize.toString()],
246
+ [_NT]: [, input[_NT]],
247
+ [_PS]: [() => input.PageSize !== void 0, () => input[_PS].toString()],
400
248
  });
401
249
  let body;
402
- return new __HttpRequest({
403
- protocol,
404
- hostname,
405
- port,
406
- method: "GET",
407
- headers,
408
- path: resolvedPath,
409
- query,
410
- body,
411
- });
250
+ b.m("GET").h(headers).q(query).b(body);
251
+ return b.build();
412
252
  };
413
253
  export const se_ListDedicatedIpPoolsCommand = async (input, context) => {
414
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
254
+ const b = rb(input, context);
415
255
  const headers = {};
416
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/email/dedicated-ip-pools";
256
+ b.bp("/v1/email/dedicated-ip-pools");
417
257
  const query = map({
418
- NextToken: [, input.NextToken],
419
- PageSize: [() => input.PageSize !== void 0, () => input.PageSize.toString()],
258
+ [_NT]: [, input[_NT]],
259
+ [_PS]: [() => input.PageSize !== void 0, () => input[_PS].toString()],
420
260
  });
421
261
  let body;
422
- return new __HttpRequest({
423
- protocol,
424
- hostname,
425
- port,
426
- method: "GET",
427
- headers,
428
- path: resolvedPath,
429
- query,
430
- body,
431
- });
262
+ b.m("GET").h(headers).q(query).b(body);
263
+ return b.build();
432
264
  };
433
265
  export const se_ListDeliverabilityTestReportsCommand = async (input, context) => {
434
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
266
+ const b = rb(input, context);
435
267
  const headers = {};
436
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
437
- "/v1/email/deliverability-dashboard/test-reports";
268
+ b.bp("/v1/email/deliverability-dashboard/test-reports");
438
269
  const query = map({
439
- NextToken: [, input.NextToken],
440
- PageSize: [() => input.PageSize !== void 0, () => input.PageSize.toString()],
270
+ [_NT]: [, input[_NT]],
271
+ [_PS]: [() => input.PageSize !== void 0, () => input[_PS].toString()],
441
272
  });
442
273
  let body;
443
- return new __HttpRequest({
444
- protocol,
445
- hostname,
446
- port,
447
- method: "GET",
448
- headers,
449
- path: resolvedPath,
450
- query,
451
- body,
452
- });
274
+ b.m("GET").h(headers).q(query).b(body);
275
+ return b.build();
453
276
  };
454
277
  export const se_ListDomainDeliverabilityCampaignsCommand = async (input, context) => {
455
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
278
+ const b = rb(input, context);
456
279
  const headers = {};
457
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
458
- "/v1/email/deliverability-dashboard/domains/{SubscribedDomain}/campaigns";
459
- resolvedPath = __resolvedPath(resolvedPath, input, "SubscribedDomain", () => input.SubscribedDomain, "{SubscribedDomain}", false);
280
+ b.bp("/v1/email/deliverability-dashboard/domains/{SubscribedDomain}/campaigns");
281
+ b.p("SubscribedDomain", () => input.SubscribedDomain, "{SubscribedDomain}", false);
460
282
  const query = map({
461
- StartDate: [
283
+ [_SD]: [
462
284
  __expectNonNull(input.StartDate, `StartDate`) != null,
463
- () => (input.StartDate.toISOString().split(".")[0] + "Z").toString(),
285
+ () => (input[_SD].toISOString().split(".")[0] + "Z").toString(),
464
286
  ],
465
- EndDate: [
287
+ [_ED]: [
466
288
  __expectNonNull(input.EndDate, `EndDate`) != null,
467
- () => (input.EndDate.toISOString().split(".")[0] + "Z").toString(),
289
+ () => (input[_ED].toISOString().split(".")[0] + "Z").toString(),
468
290
  ],
469
- NextToken: [, input.NextToken],
470
- PageSize: [() => input.PageSize !== void 0, () => input.PageSize.toString()],
291
+ [_NT]: [, input[_NT]],
292
+ [_PS]: [() => input.PageSize !== void 0, () => input[_PS].toString()],
471
293
  });
472
294
  let body;
473
- return new __HttpRequest({
474
- protocol,
475
- hostname,
476
- port,
477
- method: "GET",
478
- headers,
479
- path: resolvedPath,
480
- query,
481
- body,
482
- });
295
+ b.m("GET").h(headers).q(query).b(body);
296
+ return b.build();
483
297
  };
484
298
  export const se_ListEmailIdentitiesCommand = async (input, context) => {
485
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
299
+ const b = rb(input, context);
486
300
  const headers = {};
487
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/email/identities";
301
+ b.bp("/v1/email/identities");
488
302
  const query = map({
489
- NextToken: [, input.NextToken],
490
- PageSize: [() => input.PageSize !== void 0, () => input.PageSize.toString()],
303
+ [_NT]: [, input[_NT]],
304
+ [_PS]: [() => input.PageSize !== void 0, () => input[_PS].toString()],
491
305
  });
492
306
  let body;
493
- return new __HttpRequest({
494
- protocol,
495
- hostname,
496
- port,
497
- method: "GET",
498
- headers,
499
- path: resolvedPath,
500
- query,
501
- body,
502
- });
307
+ b.m("GET").h(headers).q(query).b(body);
308
+ return b.build();
503
309
  };
504
310
  export const se_ListTagsForResourceCommand = async (input, context) => {
505
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
311
+ const b = rb(input, context);
506
312
  const headers = {};
507
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/email/tags";
313
+ b.bp("/v1/email/tags");
508
314
  const query = map({
509
- ResourceArn: [, __expectNonNull(input.ResourceArn, `ResourceArn`)],
315
+ [_RA]: [, __expectNonNull(input[_RA], `ResourceArn`)],
510
316
  });
511
317
  let body;
512
- return new __HttpRequest({
513
- protocol,
514
- hostname,
515
- port,
516
- method: "GET",
517
- headers,
518
- path: resolvedPath,
519
- query,
520
- body,
521
- });
318
+ b.m("GET").h(headers).q(query).b(body);
319
+ return b.build();
522
320
  };
523
321
  export const se_PutAccountDedicatedIpWarmupAttributesCommand = async (input, context) => {
524
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
322
+ const b = rb(input, context);
525
323
  const headers = {
526
324
  "content-type": "application/json",
527
325
  };
528
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/email/account/dedicated-ips/warmup";
326
+ b.bp("/v1/email/account/dedicated-ips/warmup");
529
327
  let body;
530
328
  body = JSON.stringify(take(input, {
531
329
  AutoWarmupEnabled: [],
532
330
  }));
533
- return new __HttpRequest({
534
- protocol,
535
- hostname,
536
- port,
537
- method: "PUT",
538
- headers,
539
- path: resolvedPath,
540
- body,
541
- });
331
+ b.m("PUT").h(headers).b(body);
332
+ return b.build();
542
333
  };
543
334
  export const se_PutAccountSendingAttributesCommand = async (input, context) => {
544
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
335
+ const b = rb(input, context);
545
336
  const headers = {
546
337
  "content-type": "application/json",
547
338
  };
548
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/email/account/sending";
339
+ b.bp("/v1/email/account/sending");
549
340
  let body;
550
341
  body = JSON.stringify(take(input, {
551
342
  SendingEnabled: [],
552
343
  }));
553
- return new __HttpRequest({
554
- protocol,
555
- hostname,
556
- port,
557
- method: "PUT",
558
- headers,
559
- path: resolvedPath,
560
- body,
561
- });
344
+ b.m("PUT").h(headers).b(body);
345
+ return b.build();
562
346
  };
563
347
  export const se_PutConfigurationSetDeliveryOptionsCommand = async (input, context) => {
564
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
348
+ const b = rb(input, context);
565
349
  const headers = {
566
350
  "content-type": "application/json",
567
351
  };
568
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
569
- "/v1/email/configuration-sets/{ConfigurationSetName}/delivery-options";
570
- resolvedPath = __resolvedPath(resolvedPath, input, "ConfigurationSetName", () => input.ConfigurationSetName, "{ConfigurationSetName}", false);
352
+ b.bp("/v1/email/configuration-sets/{ConfigurationSetName}/delivery-options");
353
+ b.p("ConfigurationSetName", () => input.ConfigurationSetName, "{ConfigurationSetName}", false);
571
354
  let body;
572
355
  body = JSON.stringify(take(input, {
573
356
  SendingPoolName: [],
574
357
  TlsPolicy: [],
575
358
  }));
576
- return new __HttpRequest({
577
- protocol,
578
- hostname,
579
- port,
580
- method: "PUT",
581
- headers,
582
- path: resolvedPath,
583
- body,
584
- });
359
+ b.m("PUT").h(headers).b(body);
360
+ return b.build();
585
361
  };
586
362
  export const se_PutConfigurationSetReputationOptionsCommand = async (input, context) => {
587
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
363
+ const b = rb(input, context);
588
364
  const headers = {
589
365
  "content-type": "application/json",
590
366
  };
591
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
592
- "/v1/email/configuration-sets/{ConfigurationSetName}/reputation-options";
593
- resolvedPath = __resolvedPath(resolvedPath, input, "ConfigurationSetName", () => input.ConfigurationSetName, "{ConfigurationSetName}", false);
367
+ b.bp("/v1/email/configuration-sets/{ConfigurationSetName}/reputation-options");
368
+ b.p("ConfigurationSetName", () => input.ConfigurationSetName, "{ConfigurationSetName}", false);
594
369
  let body;
595
370
  body = JSON.stringify(take(input, {
596
371
  ReputationMetricsEnabled: [],
597
372
  }));
598
- return new __HttpRequest({
599
- protocol,
600
- hostname,
601
- port,
602
- method: "PUT",
603
- headers,
604
- path: resolvedPath,
605
- body,
606
- });
373
+ b.m("PUT").h(headers).b(body);
374
+ return b.build();
607
375
  };
608
376
  export const se_PutConfigurationSetSendingOptionsCommand = async (input, context) => {
609
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
377
+ const b = rb(input, context);
610
378
  const headers = {
611
379
  "content-type": "application/json",
612
380
  };
613
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
614
- "/v1/email/configuration-sets/{ConfigurationSetName}/sending";
615
- resolvedPath = __resolvedPath(resolvedPath, input, "ConfigurationSetName", () => input.ConfigurationSetName, "{ConfigurationSetName}", false);
381
+ b.bp("/v1/email/configuration-sets/{ConfigurationSetName}/sending");
382
+ b.p("ConfigurationSetName", () => input.ConfigurationSetName, "{ConfigurationSetName}", false);
616
383
  let body;
617
384
  body = JSON.stringify(take(input, {
618
385
  SendingEnabled: [],
619
386
  }));
620
- return new __HttpRequest({
621
- protocol,
622
- hostname,
623
- port,
624
- method: "PUT",
625
- headers,
626
- path: resolvedPath,
627
- body,
628
- });
387
+ b.m("PUT").h(headers).b(body);
388
+ return b.build();
629
389
  };
630
390
  export const se_PutConfigurationSetTrackingOptionsCommand = 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
393
  "content-type": "application/json",
634
394
  };
635
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
636
- "/v1/email/configuration-sets/{ConfigurationSetName}/tracking-options";
637
- resolvedPath = __resolvedPath(resolvedPath, input, "ConfigurationSetName", () => input.ConfigurationSetName, "{ConfigurationSetName}", false);
395
+ b.bp("/v1/email/configuration-sets/{ConfigurationSetName}/tracking-options");
396
+ b.p("ConfigurationSetName", () => input.ConfigurationSetName, "{ConfigurationSetName}", false);
638
397
  let body;
639
398
  body = JSON.stringify(take(input, {
640
399
  CustomRedirectDomain: [],
641
400
  }));
642
- return new __HttpRequest({
643
- protocol,
644
- hostname,
645
- port,
646
- method: "PUT",
647
- headers,
648
- path: resolvedPath,
649
- body,
650
- });
401
+ b.m("PUT").h(headers).b(body);
402
+ return b.build();
651
403
  };
652
404
  export const se_PutDedicatedIpInPoolCommand = async (input, context) => {
653
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
405
+ const b = rb(input, context);
654
406
  const headers = {
655
407
  "content-type": "application/json",
656
408
  };
657
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/email/dedicated-ips/{Ip}/pool";
658
- resolvedPath = __resolvedPath(resolvedPath, input, "Ip", () => input.Ip, "{Ip}", false);
409
+ b.bp("/v1/email/dedicated-ips/{Ip}/pool");
410
+ b.p("Ip", () => input.Ip, "{Ip}", false);
659
411
  let body;
660
412
  body = JSON.stringify(take(input, {
661
413
  DestinationPoolName: [],
662
414
  }));
663
- return new __HttpRequest({
664
- protocol,
665
- hostname,
666
- port,
667
- method: "PUT",
668
- headers,
669
- path: resolvedPath,
670
- body,
671
- });
415
+ b.m("PUT").h(headers).b(body);
416
+ return b.build();
672
417
  };
673
418
  export const se_PutDedicatedIpWarmupAttributesCommand = async (input, context) => {
674
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
419
+ const b = rb(input, context);
675
420
  const headers = {
676
421
  "content-type": "application/json",
677
422
  };
678
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/email/dedicated-ips/{Ip}/warmup";
679
- resolvedPath = __resolvedPath(resolvedPath, input, "Ip", () => input.Ip, "{Ip}", false);
423
+ b.bp("/v1/email/dedicated-ips/{Ip}/warmup");
424
+ b.p("Ip", () => input.Ip, "{Ip}", false);
680
425
  let body;
681
426
  body = JSON.stringify(take(input, {
682
427
  WarmupPercentage: [],
683
428
  }));
684
- return new __HttpRequest({
685
- protocol,
686
- hostname,
687
- port,
688
- method: "PUT",
689
- headers,
690
- path: resolvedPath,
691
- body,
692
- });
429
+ b.m("PUT").h(headers).b(body);
430
+ return b.build();
693
431
  };
694
432
  export const se_PutDeliverabilityDashboardOptionCommand = async (input, context) => {
695
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
433
+ const b = rb(input, context);
696
434
  const headers = {
697
435
  "content-type": "application/json",
698
436
  };
699
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/email/deliverability-dashboard";
437
+ b.bp("/v1/email/deliverability-dashboard");
700
438
  let body;
701
439
  body = JSON.stringify(take(input, {
702
440
  DashboardEnabled: [],
703
441
  SubscribedDomains: (_) => se_DomainDeliverabilityTrackingOptions(_, context),
704
442
  }));
705
- return new __HttpRequest({
706
- protocol,
707
- hostname,
708
- port,
709
- method: "PUT",
710
- headers,
711
- path: resolvedPath,
712
- body,
713
- });
443
+ b.m("PUT").h(headers).b(body);
444
+ return b.build();
714
445
  };
715
446
  export const se_PutEmailIdentityDkimAttributesCommand = async (input, context) => {
716
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
447
+ const b = rb(input, context);
717
448
  const headers = {
718
449
  "content-type": "application/json",
719
450
  };
720
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/email/identities/{EmailIdentity}/dkim";
721
- resolvedPath = __resolvedPath(resolvedPath, input, "EmailIdentity", () => input.EmailIdentity, "{EmailIdentity}", false);
451
+ b.bp("/v1/email/identities/{EmailIdentity}/dkim");
452
+ b.p("EmailIdentity", () => input.EmailIdentity, "{EmailIdentity}", false);
722
453
  let body;
723
454
  body = JSON.stringify(take(input, {
724
455
  SigningEnabled: [],
725
456
  }));
726
- return new __HttpRequest({
727
- protocol,
728
- hostname,
729
- port,
730
- method: "PUT",
731
- headers,
732
- path: resolvedPath,
733
- body,
734
- });
457
+ b.m("PUT").h(headers).b(body);
458
+ return b.build();
735
459
  };
736
460
  export const se_PutEmailIdentityFeedbackAttributesCommand = async (input, context) => {
737
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
461
+ const b = rb(input, context);
738
462
  const headers = {
739
463
  "content-type": "application/json",
740
464
  };
741
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
742
- "/v1/email/identities/{EmailIdentity}/feedback";
743
- resolvedPath = __resolvedPath(resolvedPath, input, "EmailIdentity", () => input.EmailIdentity, "{EmailIdentity}", false);
465
+ b.bp("/v1/email/identities/{EmailIdentity}/feedback");
466
+ b.p("EmailIdentity", () => input.EmailIdentity, "{EmailIdentity}", false);
744
467
  let body;
745
468
  body = JSON.stringify(take(input, {
746
469
  EmailForwardingEnabled: [],
747
470
  }));
748
- return new __HttpRequest({
749
- protocol,
750
- hostname,
751
- port,
752
- method: "PUT",
753
- headers,
754
- path: resolvedPath,
755
- body,
756
- });
471
+ b.m("PUT").h(headers).b(body);
472
+ return b.build();
757
473
  };
758
474
  export const se_PutEmailIdentityMailFromAttributesCommand = async (input, context) => {
759
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
475
+ const b = rb(input, context);
760
476
  const headers = {
761
477
  "content-type": "application/json",
762
478
  };
763
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
764
- "/v1/email/identities/{EmailIdentity}/mail-from";
765
- resolvedPath = __resolvedPath(resolvedPath, input, "EmailIdentity", () => input.EmailIdentity, "{EmailIdentity}", false);
479
+ b.bp("/v1/email/identities/{EmailIdentity}/mail-from");
480
+ b.p("EmailIdentity", () => input.EmailIdentity, "{EmailIdentity}", false);
766
481
  let body;
767
482
  body = JSON.stringify(take(input, {
768
483
  BehaviorOnMxFailure: [],
769
484
  MailFromDomain: [],
770
485
  }));
771
- return new __HttpRequest({
772
- protocol,
773
- hostname,
774
- port,
775
- method: "PUT",
776
- headers,
777
- path: resolvedPath,
778
- body,
779
- });
486
+ b.m("PUT").h(headers).b(body);
487
+ return b.build();
780
488
  };
781
489
  export const se_SendEmailCommand = async (input, context) => {
782
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
490
+ const b = rb(input, context);
783
491
  const headers = {
784
492
  "content-type": "application/json",
785
493
  };
786
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/email/outbound-emails";
494
+ b.bp("/v1/email/outbound-emails");
787
495
  let body;
788
496
  body = JSON.stringify(take(input, {
789
497
  ConfigurationSetName: [],
@@ -794,82 +502,52 @@ export const se_SendEmailCommand = async (input, context) => {
794
502
  FromEmailAddress: [],
795
503
  ReplyToAddresses: (_) => _json(_),
796
504
  }));
797
- return new __HttpRequest({
798
- protocol,
799
- hostname,
800
- port,
801
- method: "POST",
802
- headers,
803
- path: resolvedPath,
804
- body,
805
- });
505
+ b.m("POST").h(headers).b(body);
506
+ return b.build();
806
507
  };
807
508
  export const se_TagResourceCommand = async (input, context) => {
808
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
509
+ const b = rb(input, context);
809
510
  const headers = {
810
511
  "content-type": "application/json",
811
512
  };
812
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/email/tags";
513
+ b.bp("/v1/email/tags");
813
514
  let body;
814
515
  body = JSON.stringify(take(input, {
815
516
  ResourceArn: [],
816
517
  Tags: (_) => _json(_),
817
518
  }));
818
- return new __HttpRequest({
819
- protocol,
820
- hostname,
821
- port,
822
- method: "POST",
823
- headers,
824
- path: resolvedPath,
825
- body,
826
- });
519
+ b.m("POST").h(headers).b(body);
520
+ return b.build();
827
521
  };
828
522
  export const se_UntagResourceCommand = async (input, context) => {
829
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
523
+ const b = rb(input, context);
830
524
  const headers = {};
831
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/email/tags";
525
+ b.bp("/v1/email/tags");
832
526
  const query = map({
833
- ResourceArn: [, __expectNonNull(input.ResourceArn, `ResourceArn`)],
834
- TagKeys: [
527
+ [_RA]: [, __expectNonNull(input[_RA], `ResourceArn`)],
528
+ [_TK]: [
835
529
  __expectNonNull(input.TagKeys, `TagKeys`) != null,
836
- () => (input.TagKeys || []).map((_entry) => _entry),
530
+ () => (input[_TK] || []).map((_entry) => _entry),
837
531
  ],
838
532
  });
839
533
  let body;
840
- return new __HttpRequest({
841
- protocol,
842
- hostname,
843
- port,
844
- method: "DELETE",
845
- headers,
846
- path: resolvedPath,
847
- query,
848
- body,
849
- });
534
+ b.m("DELETE").h(headers).q(query).b(body);
535
+ return b.build();
850
536
  };
851
537
  export const se_UpdateConfigurationSetEventDestinationCommand = async (input, context) => {
852
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
538
+ const b = rb(input, context);
853
539
  const headers = {
854
540
  "content-type": "application/json",
855
541
  };
856
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
857
- "/v1/email/configuration-sets/{ConfigurationSetName}/event-destinations/{EventDestinationName}";
858
- resolvedPath = __resolvedPath(resolvedPath, input, "ConfigurationSetName", () => input.ConfigurationSetName, "{ConfigurationSetName}", false);
859
- resolvedPath = __resolvedPath(resolvedPath, input, "EventDestinationName", () => input.EventDestinationName, "{EventDestinationName}", false);
542
+ b.bp("/v1/email/configuration-sets/{ConfigurationSetName}/event-destinations/{EventDestinationName}");
543
+ b.p("ConfigurationSetName", () => input.ConfigurationSetName, "{ConfigurationSetName}", false);
544
+ b.p("EventDestinationName", () => input.EventDestinationName, "{EventDestinationName}", false);
860
545
  let body;
861
546
  body = JSON.stringify(take(input, {
862
547
  EventDestination: (_) => _json(_),
863
548
  }));
864
- return new __HttpRequest({
865
- protocol,
866
- hostname,
867
- port,
868
- method: "PUT",
869
- headers,
870
- path: resolvedPath,
871
- body,
872
- });
549
+ b.m("PUT").h(headers).b(body);
550
+ return b.build();
873
551
  };
874
552
  export const de_CreateConfigurationSetCommand = async (output, context) => {
875
553
  if (output.statusCode !== 200 && output.statusCode >= 300) {
@@ -2846,6 +2524,14 @@ const isSerializableHeaderValue = (value) => value !== undefined &&
2846
2524
  value !== "" &&
2847
2525
  (!Object.getOwnPropertyNames(value).includes("length") || value.length != 0) &&
2848
2526
  (!Object.getOwnPropertyNames(value).includes("size") || value.size != 0);
2527
+ const _BIN = "BlacklistItemNames";
2528
+ const _ED = "EndDate";
2529
+ const _NT = "NextToken";
2530
+ const _PN = "PoolName";
2531
+ const _PS = "PageSize";
2532
+ const _RA = "ResourceArn";
2533
+ const _SD = "StartDate";
2534
+ const _TK = "TagKeys";
2849
2535
  const parseBody = (streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
2850
2536
  if (encoded.length) {
2851
2537
  return JSON.parse(encoded);